z3py Namespace Reference
Functions | |
| z3_debug () | |
| _is_int (v) | |
| enable_trace (msg) | |
| disable_trace (msg) | |
| get_version_string () | |
| get_version () | |
| get_full_version () | |
| _z3_assert (cond, msg) | |
| _z3_check_cint_overflow (n, name) | |
| open_log (fname) | |
| append_log (s) | |
| to_symbol (s, ctx=None) | |
| _symbol2py (ctx, s) | |
| _get_args (args) | |
| _get_args_ast_list (args) | |
| _to_param_value (val) | |
| z3_error_handler (c, e) | |
| Context | main_ctx () |
| Context | _get_ctx (ctx) |
| Context | get_ctx (ctx) |
| set_param (*args, **kws) | |
| None | reset_params () |
| set_option (*args, **kws) | |
| get_param (name) | |
| bool | is_ast (Any a) |
| bool | eq (AstRef a, AstRef b) |
| int | _ast_kind (Context ctx, Any a) |
| _ctx_from_ast_arg_list (args, default_ctx=None) | |
| _ctx_from_ast_args (*args) | |
| _to_func_decl_array (args) | |
| _to_ast_array (args) | |
| _to_ref_array (ref, args) | |
| _to_ast_ref (a, ctx) | |
| _sort_kind (ctx, s) | |
| Sorts. | |
| bool | is_sort (Any s) |
| _to_sort_ref (s, ctx) | |
| SortRef | _sort (Context ctx, Any a) |
| SortRef | DeclareSort (name, ctx=None) |
| DeclareTypeVar (name, ctx=None) | |
| is_func_decl (a) | |
| Function (name, *sig) | |
| FreshFunction (*sig) | |
| _to_func_decl_ref (a, ctx) | |
| RecFunction (name, *sig) | |
| RecAddDefinition (f, args, body) | |
| deserialize (st) | |
| _to_expr_ref (a, ctx) | |
| _coerce_expr_merge (s, a) | |
| _check_same_sort (a, b, ctx=None) | |
| _coerce_exprs (a, b, ctx=None) | |
| _reduce (func, sequence, initial) | |
| _coerce_expr_list (alist, ctx=None) | |
| is_expr (a) | |
| is_app (a) | |
| is_const (a) | |
| is_var (a) | |
| get_var_index (a) | |
| is_app_of (a, k) | |
| If (a, b, c, ctx=None) | |
| Distinct (*args) | |
| _mk_bin (f, a, b) | |
| Const (name, sort) | |
| Consts (names, sort) | |
| FreshConst (sort, prefix="c") | |
| ExprRef | Var (int idx, SortRef s) |
| ExprRef | RealVar (int idx, ctx=None) |
| RealVarVector (int n, ctx=None) | |
| bool | is_bool (Any a) |
| bool | is_true (Any a) |
| bool | is_false (Any a) |
| bool | is_and (Any a) |
| bool | is_or (Any a) |
| bool | is_implies (Any a) |
| bool | is_not (Any a) |
| bool | is_eq (Any a) |
| bool | is_distinct (Any a) |
| BoolSort (ctx=None) | |
| BoolVal (val, ctx=None) | |
| Bool (name, ctx=None) | |
| Bools (names, ctx=None) | |
| BoolVector (prefix, sz, ctx=None) | |
| FreshBool (prefix="b", ctx=None) | |
| Implies (a, b, ctx=None) | |
| Xor (a, b, ctx=None) | |
| Not (a, ctx=None) | |
| mk_not (a) | |
| _has_probe (args) | |
| And (*args) | |
| Or (*args) | |
| is_pattern (a) | |
| MultiPattern (*args) | |
| _to_pattern (arg) | |
| is_quantifier (a) | |
| _mk_quantifier (is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| ForAll (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| Exists (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| Lambda (vs, body) | |
| bool | is_arith_sort (Any s) |
| is_arith (a) | |
| bool | is_int (a) |
| is_real (a) | |
| _is_numeral (ctx, a) | |
| _is_algebraic (ctx, a) | |
| is_int_value (a) | |
| is_rational_value (a) | |
| is_algebraic_value (a) | |
| bool | is_add (Any a) |
| bool | is_mul (Any a) |
| bool | is_sub (Any a) |
| bool | is_div (Any a) |
| bool | is_idiv (Any a) |
| bool | is_mod (Any a) |
| bool | is_le (Any a) |
| bool | is_lt (Any a) |
| bool | is_ge (Any a) |
| bool | is_gt (Any a) |
| bool | is_is_int (Any a) |
| bool | is_to_real (Any a) |
| bool | is_to_int (Any a) |
| _py2expr (a, ctx=None) | |
| IntSort (ctx=None) | |
| RealSort (ctx=None) | |
| _to_int_str (val) | |
| IntVal (val, ctx=None) | |
| RealVal (val, ctx=None) | |
| RatVal (a, b, ctx=None) | |
| Q (a, b, ctx=None) | |
| Int (name, ctx=None) | |
| Ints (names, ctx=None) | |
| IntVector (prefix, sz, ctx=None) | |
| FreshInt (prefix="x", ctx=None) | |
| Real (name, ctx=None) | |
| Reals (names, ctx=None) | |
| RealVector (prefix, sz, ctx=None) | |
| FreshReal (prefix="b", ctx=None) | |
| ToReal (a) | |
| ToInt (a) | |
| IsInt (a) | |
| Sqrt (a, ctx=None) | |
| Cbrt (a, ctx=None) | |
| is_bv_sort (s) | |
| is_bv (a) | |
| is_bv_value (a) | |
| BV2Int (a, is_signed=False) | |
| Int2BV (a, num_bits) | |
| BitVecSort (sz, ctx=None) | |
| BitVecVal (val, bv, ctx=None) | |
| BitVec (name, bv, ctx=None) | |
| BitVecs (names, bv, ctx=None) | |
| Concat (*args) | |
| Extract (high, low, a) | |
| _check_bv_args (a, b) | |
| ULE (a, b) | |
| ULT (a, b) | |
| UGE (a, b) | |
| UGT (a, b) | |
| UDiv (a, b) | |
| URem (a, b) | |
| SRem (a, b) | |
| LShR (a, b) | |
| RotateLeft (a, b) | |
| RotateRight (a, b) | |
| SignExt (n, a) | |
| ZeroExt (n, a) | |
| RepeatBitVec (n, a) | |
| BVRedAnd (a) | |
| BVRedOr (a) | |
| BVAddNoOverflow (a, b, signed) | |
| BVAddNoUnderflow (a, b) | |
| BVSubNoOverflow (a, b) | |
| BVSubNoUnderflow (a, b, signed) | |
| BVSDivNoOverflow (a, b) | |
| BVSNegNoOverflow (a) | |
| BVMulNoOverflow (a, b, signed) | |
| BVMulNoUnderflow (a, b) | |
| _array_select (ar, arg) | |
| is_array_sort (a) | |
| bool | is_array (Any a) |
| is_const_array (a) | |
| is_K (a) | |
| is_map (a) | |
| is_default (a) | |
| get_map_func (a) | |
| ArraySort (*sig) | |
| Array (name, *sorts) | |
| Update (a, *args) | |
| Default (a) | |
| Store (a, *args) | |
| Select (a, *args) | |
| Map (f, *args) | |
| K (dom, v) | |
| Ext (a, b) | |
| SetHasSize (a, k) | |
| is_select (a) | |
| is_store (a) | |
| SetSort (s) | |
| Sets. | |
| EmptySet (s) | |
| FullSet (s) | |
| SetUnion (*args) | |
| SetIntersect (*args) | |
| SetAdd (s, e) | |
| SetDel (s, e) | |
| SetComplement (s) | |
| SetDifference (a, b) | |
| IsMember (e, s) | |
| IsSubset (a, b) | |
| _valid_accessor (acc) | |
| Datatypes. | |
| CreateDatatypes (*ds) | |
| DatatypeSort (name, params=None, ctx=None) | |
| TupleSort (name, sorts, ctx=None) | |
| DisjointSum (name, sorts, ctx=None) | |
| EnumSort (name, values, ctx=None) | |
| args2params (arguments, keywords, ctx=None) | |
| Model (ctx=None, eval={}) | |
| is_as_array (n) | |
| get_as_array_func (n) | |
| SolverFor (logic, ctx=None, logFile=None) | |
| SimpleSolver (ctx=None, logFile=None) | |
| FiniteDomainSort (name, sz, ctx=None) | |
| is_finite_domain_sort (s) | |
| is_finite_domain (a) | |
| FiniteDomainVal (val, sort, ctx=None) | |
| is_finite_domain_value (a) | |
| _global_on_model (ctx) | |
| _to_goal (a) | |
| _to_tactic (t, ctx=None) | |
| _and_then (t1, t2, ctx=None) | |
| _or_else (t1, t2, ctx=None) | |
| AndThen (*ts, **ks) | |
| Then (*ts, **ks) | |
| OrElse (*ts, **ks) | |
| ParOr (*ts, **ks) | |
| ParThen (t1, t2, ctx=None) | |
| ParAndThen (t1, t2, ctx=None) | |
| With (t, *args, **keys) | |
| WithParams (t, p) | |
| Repeat (t, max=4294967295, ctx=None) | |
| TryFor (t, ms, ctx=None) | |
| tactics (ctx=None) | |
| tactic_description (name, ctx=None) | |
| describe_tactics () | |
| is_probe (p) | |
| _to_probe (p, ctx=None) | |
| probes (ctx=None) | |
| probe_description (name, ctx=None) | |
| describe_probes () | |
| _probe_nary (f, args, ctx) | |
| _probe_and (args, ctx) | |
| _probe_or (args, ctx) | |
| FailIf (p, ctx=None) | |
| When (p, t, ctx=None) | |
| Cond (p, t1, t2, ctx=None) | |
| simplify (a, *arguments, **keywords) | |
| Utils. | |
| help_simplify () | |
| simplify_param_descrs () | |
| substitute (t, *m) | |
| substitute_vars (t, *m) | |
| substitute_funs (t, *m) | |
| Sum (*args) | |
| Product (*args) | |
| Abs (arg) | |
| AtMost (*args) | |
| AtLeast (*args) | |
| _reorder_pb_arg (arg) | |
| _pb_args_coeffs (args, default_ctx=None) | |
| PbLe (args, k) | |
| PbGe (args, k) | |
| PbEq (args, k, ctx=None) | |
| solve (*args, **keywords) | |
| solve_using (s, *args, **keywords) | |
| prove (claim, show=False, **keywords) | |
| _solve_html (*args, **keywords) | |
| _solve_using_html (s, *args, **keywords) | |
| _prove_html (claim, show=False, **keywords) | |
| _dict2sarray (sorts, ctx) | |
| _dict2darray (decls, ctx) | |
| parse_smt2_string (s, sorts={}, decls={}, ctx=None) | |
| parse_smt2_file (f, sorts={}, decls={}, ctx=None) | |
| get_default_rounding_mode (ctx=None) | |
| set_default_rounding_mode (rm, ctx=None) | |
| get_default_fp_sort (ctx=None) | |
| set_default_fp_sort (ebits, sbits, ctx=None) | |
| _dflt_rm (ctx=None) | |
| _dflt_fps (ctx=None) | |
| _coerce_fp_expr_list (alist, ctx) | |
| Float16 (ctx=None) | |
| FloatHalf (ctx=None) | |
| Float32 (ctx=None) | |
| FloatSingle (ctx=None) | |
| Float64 (ctx=None) | |
| FloatDouble (ctx=None) | |
| Float128 (ctx=None) | |
| FloatQuadruple (ctx=None) | |
| is_fp_sort (s) | |
| is_fprm_sort (s) | |
| RoundNearestTiesToEven (ctx=None) | |
| RNE (ctx=None) | |
| RoundNearestTiesToAway (ctx=None) | |
| RNA (ctx=None) | |
| RoundTowardPositive (ctx=None) | |
| RTP (ctx=None) | |
| RoundTowardNegative (ctx=None) | |
| RTN (ctx=None) | |
| RoundTowardZero (ctx=None) | |
| RTZ (ctx=None) | |
| is_fprm (a) | |
| is_fprm_value (a) | |
| is_fp (a) | |
| is_fp_value (a) | |
| FPSort (ebits, sbits, ctx=None) | |
| _to_float_str (val, exp=0) | |
| fpNaN (s) | |
| fpPlusInfinity (s) | |
| fpMinusInfinity (s) | |
| fpInfinity (s, negative) | |
| fpPlusZero (s) | |
| fpMinusZero (s) | |
| fpZero (s, negative) | |
| FPVal (sig, exp=None, fps=None, ctx=None) | |
| FP (name, fpsort, ctx=None) | |
| FPs (names, fpsort, ctx=None) | |
| fpAbs (a, ctx=None) | |
| fpNeg (a, ctx=None) | |
| _mk_fp_unary (f, rm, a, ctx) | |
| _mk_fp_unary_pred (f, a, ctx) | |
| _mk_fp_bin (f, rm, a, b, ctx) | |
| _mk_fp_bin_norm (f, a, b, ctx) | |
| _mk_fp_bin_pred (f, a, b, ctx) | |
| _mk_fp_tern (f, rm, a, b, c, ctx) | |
| fpAdd (rm, a, b, ctx=None) | |
| fpSub (rm, a, b, ctx=None) | |
| fpMul (rm, a, b, ctx=None) | |
| fpDiv (rm, a, b, ctx=None) | |
| fpRem (a, b, ctx=None) | |
| fpMin (a, b, ctx=None) | |
| fpMax (a, b, ctx=None) | |
| fpFMA (rm, a, b, c, ctx=None) | |
| fpSqrt (rm, a, ctx=None) | |
| fpRoundToIntegral (rm, a, ctx=None) | |
| fpIsNaN (a, ctx=None) | |
| fpIsInf (a, ctx=None) | |
| fpIsZero (a, ctx=None) | |
| fpIsNormal (a, ctx=None) | |
| fpIsSubnormal (a, ctx=None) | |
| fpIsNegative (a, ctx=None) | |
| fpIsPositive (a, ctx=None) | |
| _check_fp_args (a, b) | |
| fpLT (a, b, ctx=None) | |
| fpLEQ (a, b, ctx=None) | |
| fpGT (a, b, ctx=None) | |
| fpGEQ (a, b, ctx=None) | |
| fpEQ (a, b, ctx=None) | |
| fpNEQ (a, b, ctx=None) | |
| fpFP (sgn, exp, sig, ctx=None) | |
| fpToFP (a1, a2=None, a3=None, ctx=None) | |
| fpBVToFP (v, sort, ctx=None) | |
| fpFPToFP (rm, v, sort, ctx=None) | |
| fpRealToFP (rm, v, sort, ctx=None) | |
| fpSignedToFP (rm, v, sort, ctx=None) | |
| fpUnsignedToFP (rm, v, sort, ctx=None) | |
| fpToFPUnsigned (rm, x, s, ctx=None) | |
| fpToSBV (rm, x, s, ctx=None) | |
| fpToUBV (rm, x, s, ctx=None) | |
| fpToReal (x, ctx=None) | |
| fpToIEEEBV (x, ctx=None) | |
| StringSort (ctx=None) | |
| CharSort (ctx=None) | |
| SeqSort (s) | |
| _coerce_char (ch, ctx=None) | |
| CharVal (ch, ctx=None) | |
| CharFromBv (bv) | |
| CharToBv (ch, ctx=None) | |
| CharToInt (ch, ctx=None) | |
| CharIsDigit (ch, ctx=None) | |
| _coerce_seq (s, ctx=None) | |
| _get_ctx2 (a, b, ctx=None) | |
| is_seq (a) | |
| bool | is_string (Any a) |
| bool | is_string_value (Any a) |
| StringVal (s, ctx=None) | |
| String (name, ctx=None) | |
| Strings (names, ctx=None) | |
| SubString (s, offset, length) | |
| SubSeq (s, offset, length) | |
| Empty (s) | |
| Full (s) | |
| Unit (a) | |
| PrefixOf (a, b) | |
| SuffixOf (a, b) | |
| Contains (a, b) | |
| Replace (s, src, dst) | |
| IndexOf (s, substr, offset=None) | |
| LastIndexOf (s, substr) | |
| Length (s) | |
| SeqMap (f, s) | |
| SeqMapI (f, i, s) | |
| SeqFoldLeft (f, a, s) | |
| SeqFoldLeftI (f, i, a, s) | |
| StrToInt (s) | |
| IntToStr (s) | |
| StrToCode (s) | |
| StrFromCode (c) | |
| Re (s, ctx=None) | |
| ReSort (s) | |
| is_re (s) | |
| InRe (s, re) | |
| Union (*args) | |
| Intersect (*args) | |
| Plus (re) | |
| Option (re) | |
| Complement (re) | |
| Star (re) | |
| Loop (re, lo, hi=0) | |
| Range (lo, hi, ctx=None) | |
| Diff (a, b, ctx=None) | |
| AllChar (regex_sort, ctx=None) | |
| PartialOrder (a, index) | |
| LinearOrder (a, index) | |
| TreeOrder (a, index) | |
| PiecewiseLinearOrder (a, index) | |
| TransitiveClosure (f) | |
| to_Ast (ptr) | |
| to_ContextObj (ptr) | |
| to_AstVectorObj (ptr) | |
| on_clause_eh (ctx, p, n, dep, clause) | |
| ensure_prop_closures () | |
| user_prop_push (ctx, cb) | |
| user_prop_pop (ctx, cb, num_scopes) | |
| user_prop_fresh (ctx, _new_ctx) | |
| user_prop_fixed (ctx, cb, id, value) | |
| user_prop_created (ctx, cb, id) | |
| user_prop_final (ctx, cb) | |
| user_prop_eq (ctx, cb, x, y) | |
| user_prop_diseq (ctx, cb, x, y) | |
| user_prop_decide (ctx, cb, t_ref, idx, phase) | |
| user_prop_binding (ctx, cb, q_ref, inst_ref) | |
| PropagateFunction (name, *sig) | |
Variables | |
| Z3_DEBUG = __debug__ | |
| _main_ctx = None | |
| sat = CheckSatResult(Z3_L_TRUE) | |
| unsat = CheckSatResult(Z3_L_FALSE) | |
| unknown = CheckSatResult(Z3_L_UNDEF) | |
| dict | _on_models = {} |
| _on_model_eh = on_model_eh_type(_global_on_model) | |
| _dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN | |
| Floating-Point Arithmetic. | |
| int | _dflt_fpsort_ebits = 11 |
| int | _dflt_fpsort_sbits = 53 |
| _ROUNDING_MODES | |
| _my_hacky_class = None | |
| _on_clause_eh = Z3_on_clause_eh(on_clause_eh) | |
| _prop_closures = None | |
| _user_prop_push = Z3_push_eh(user_prop_push) | |
| _user_prop_pop = Z3_pop_eh(user_prop_pop) | |
| _user_prop_fresh = Z3_fresh_eh(user_prop_fresh) | |
| _user_prop_fixed = Z3_fixed_eh(user_prop_fixed) | |
| _user_prop_created = Z3_created_eh(user_prop_created) | |
| _user_prop_final = Z3_final_eh(user_prop_final) | |
| _user_prop_eq = Z3_eq_eh(user_prop_eq) | |
| _user_prop_diseq = Z3_eq_eh(user_prop_diseq) | |
| _user_prop_decide = Z3_decide_eh(user_prop_decide) | |
| _user_prop_binding = Z3_on_binding_eh(user_prop_binding) | |
Function Documentation
◆ _and_then()
|
protected |
Definition at line 8575 of file z3py.py.
8575def _and_then(t1, t2, ctx=None):
8576 t1 = _to_tactic(t1, ctx)
8577 t2 = _to_tactic(t2, ctx)
8578 if z3_debug():
8579 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8581
8582
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.
◆ _array_select()
|
protected |
Definition at line 4732 of file z3py.py.
4732def _array_select(ar, arg):
4733 if isinstance(arg, tuple):
4734 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4735 _args, sz = _to_ast_array(args)
4737 arg = ar.sort().domain().cast(arg)
4739
4740
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_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.
Referenced by ArrayRef.__getitem__(), and QuantifierRef.__getitem__().
◆ _ast_kind()
|
protected |
Definition at line 505 of file z3py.py.
505def _ast_kind(ctx : Context, a : Any) -> int:
506 if is_ast(a):
507 a = a.as_ast()
509
510
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
Referenced by _to_ast_ref(), is_app(), and is_var().
◆ _check_bv_args()
|
protected |
Definition at line 4293 of file z3py.py.
4293def _check_bv_args(a, b):
4294 if z3_debug():
4295 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4296
4297
Referenced by BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().
◆ _check_fp_args()
|
protected |
◆ _check_same_sort()
|
protected |
Definition at line 1248 of file z3py.py.
1248def _check_same_sort(a, b, ctx=None):
1249 if not isinstance(a, ExprRef):
1250 return False
1251 if not isinstance(b, ExprRef):
1252 return False
1253 if ctx is None:
1254 ctx = a.ctx
1255
1256 a_sort = Z3_get_sort(ctx.ctx, a.ast)
1257 b_sort = Z3_get_sort(ctx.ctx, b.ast)
1259
1260
Referenced by _coerce_exprs().
◆ _coerce_char()
|
protected |
◆ _coerce_expr_list()
|
protected |
Definition at line 1292 of file z3py.py.
1292def _coerce_expr_list(alist, ctx=None):
1293 has_expr = False
1294 for a in alist:
1295 if is_expr(a):
1296 has_expr = True
1297 break
1298 if not has_expr:
1299 alist = [_py2expr(a, ctx) for a in alist]
1300 s = _reduce(_coerce_expr_merge, alist, None)
1301 return [s.cast(a) for a in alist]
1302
1303
Referenced by And(), Distinct(), and Or().
◆ _coerce_expr_merge()
|
protected |
Definition at line 1230 of file z3py.py.
1230def _coerce_expr_merge(s, a):
1231 if is_expr(a):
1232 s1 = a.sort()
1233 if s is None:
1234 return s1
1235 if s1.eq(s):
1236 return s
1237 elif s.subsort(s1):
1238 return s1
1239 elif s1.subsort(s):
1240 return s
1241 else:
1242 if z3_debug():
1243 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1244 _z3_assert(False, "sort mismatch")
1245 else:
1246 return s
1247
Referenced by _coerce_exprs().
◆ _coerce_exprs()
|
protected |
Definition at line 1261 of file z3py.py.
1261def _coerce_exprs(a, b, ctx=None):
1262 if not is_expr(a) and not is_expr(b):
1263 a = _py2expr(a, ctx)
1264 b = _py2expr(b, ctx)
1265 if isinstance(a, str) and isinstance(b, SeqRef):
1266 a = StringVal(a, b.ctx)
1267 if isinstance(b, str) and isinstance(a, SeqRef):
1268 b = StringVal(b, a.ctx)
1269 if isinstance(a, float) and isinstance(b, ArithRef):
1270 a = RealVal(a, b.ctx)
1271 if isinstance(b, float) and isinstance(a, ArithRef):
1272 b = RealVal(b, a.ctx)
1273
1274 if _check_same_sort(a, b, ctx):
1275 return (a, b)
1276
1277 s = None
1278 s = _coerce_expr_merge(s, a)
1279 s = _coerce_expr_merge(s, b)
1280 a = s.cast(a)
1281 b = s.cast(b)
1282 return (a, b)
1283
1284
Referenced by ArithRef.__add__(), BitVecRef.__add__(), BitVecRef.__and__(), ArithRef.__div__(), BitVecRef.__div__(), ExprRef.__eq__(), ArithRef.__ge__(), BitVecRef.__ge__(), ArithRef.__gt__(), BitVecRef.__gt__(), ArithRef.__le__(), BitVecRef.__le__(), BitVecRef.__lshift__(), ArithRef.__lt__(), BitVecRef.__lt__(), ArithRef.__mod__(), BitVecRef.__mod__(), ArithRef.__mul__(), BitVecRef.__mul__(), ExprRef.__ne__(), BitVecRef.__or__(), ArithRef.__pow__(), ArithRef.__radd__(), BitVecRef.__radd__(), BitVecRef.__rand__(), ArithRef.__rdiv__(), BitVecRef.__rdiv__(), BitVecRef.__rlshift__(), ArithRef.__rmod__(), BitVecRef.__rmod__(), ArithRef.__rmul__(), BitVecRef.__rmul__(), BitVecRef.__ror__(), ArithRef.__rpow__(), BitVecRef.__rrshift__(), BitVecRef.__rshift__(), ArithRef.__rsub__(), BitVecRef.__rsub__(), BitVecRef.__rxor__(), ArithRef.__sub__(), BitVecRef.__sub__(), BitVecRef.__xor__(), BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), Extract(), If(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().
◆ _coerce_fp_expr_list()
|
protected |
Definition at line 9636 of file z3py.py.
9636def _coerce_fp_expr_list(alist, ctx):
9637 first_fp_sort = None
9638 for a in alist:
9639 if is_fp(a):
9640 if first_fp_sort is None:
9641 first_fp_sort = a.sort()
9642 elif first_fp_sort == a.sort():
9643 pass # OK, same as before
9644 else:
9645 # we saw at least 2 different float sorts; something will
9646 # throw a sort mismatch later, for now assume None.
9647 first_fp_sort = None
9648 break
9649
9650 r = []
9651 for i in range(len(alist)):
9652 a = alist[i]
9653 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9654 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9655 r.append(FPVal(a, None, first_fp_sort, ctx))
9656 else:
9657 r.append(a)
9658 return _coerce_expr_list(r, ctx)
9659
9660
9661# FP Sorts
9662
◆ _coerce_seq()
|
protected |
Definition at line 11180 of file z3py.py.
11180def _coerce_seq(s, ctx=None):
11181 if isinstance(s, str):
11182 ctx = _get_ctx(ctx)
11183 s = StringVal(s, ctx)
11184 if not is_expr(s):
11185 raise Z3Exception("Non-expression passed as a sequence")
11186 if not is_seq(s):
11187 raise Z3Exception("Non-sequence passed as a sequence")
11188 return s
11189
11190
Referenced by Concat().
◆ _ctx_from_ast_arg_list()
|
protected |
Definition at line 511 of file z3py.py.
511def _ctx_from_ast_arg_list(args, default_ctx=None):
512 ctx = None
513 for a in args:
514 if is_ast(a) or is_probe(a):
515 if ctx is None:
516 ctx = a.ctx
517 else:
518 if z3_debug():
519 _z3_assert(ctx == a.ctx, "Context mismatch")
520 if ctx is None:
521 ctx = default_ctx
522 return ctx
523
524
Referenced by _ctx_from_ast_args(), And(), Distinct(), If(), Implies(), IsMember(), IsSubset(), Not(), Or(), SetAdd(), SetDel(), SetDifference(), SetIntersect(), SetUnion(), and Xor().
◆ _ctx_from_ast_args()
|
protected |
◆ _dflt_fps()
|
protected |
◆ _dflt_rm()
|
protected |
◆ _dict2darray()
|
protected |
Definition at line 9501 of file z3py.py.
9501def _dict2darray(decls, ctx):
9502 sz = len(decls)
9503 _names = (Symbol * sz)()
9504 _decls = (FuncDecl * sz)()
9505 i = 0
9506 for k in decls:
9507 v = decls[k]
9508 if z3_debug():
9509 _z3_assert(isinstance(k, str), "String expected")
9510 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9511 _names[i] = to_symbol(k, ctx)
9512 if is_const(v):
9513 _decls[i] = v.decl().ast
9514 else:
9515 _decls[i] = v.ast
9516 i = i + 1
9517 return sz, _names, _decls
9518
◆ _dict2sarray()
|
protected |
Definition at line 9485 of file z3py.py.
9485def _dict2sarray(sorts, ctx):
9486 sz = len(sorts)
9487 _names = (Symbol * sz)()
9488 _sorts = (Sort * sz)()
9489 i = 0
9490 for k in sorts:
9491 v = sorts[k]
9492 if z3_debug():
9493 _z3_assert(isinstance(k, str), "String expected")
9494 _z3_assert(is_sort(v), "Z3 sort expected")
9495 _names[i] = to_symbol(k, ctx)
9496 _sorts[i] = v.ast
9497 i = i + 1
9498 return sz, _names, _sorts
9499
9500
◆ _get_args()
|
protected |
Definition at line 152 of file z3py.py.
152def _get_args(args):
153 try:
154 if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)):
155 return args[0]
156 elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)):
157 return [arg for arg in args[0]]
158 elif len(args) == 1 and isinstance(args[0], Iterator):
159 return list(args[0])
160 else:
161 return args
162 except TypeError: # len is not necessarily defined when args is not a sequence (use reflection?)
163 return args
164
165# Use this when function takes multiple arguments
166
167
Referenced by FuncDeclRef.__call__(), And(), ArraySort(), Goal.assert_exprs(), Solver.assert_exprs(), Solver.check(), Concat(), CreateDatatypes(), Distinct(), FreshFunction(), Function(), Map(), Or(), RecAddDefinition(), RecFunction(), Select(), SetIntersect(), SetUnion(), and Update().
◆ _get_args_ast_list()
|
protected |
◆ _get_ctx()
|
protected |
Definition at line 270 of file z3py.py.
270def _get_ctx(ctx) -> Context:
271 if ctx is None:
272 return main_ctx()
273 else:
274 return ctx
275
276
Referenced by And(), BitVec(), BitVecs(), BitVecSort(), BitVecVal(), Bool(), Bools(), BoolSort(), BoolVal(), Cbrt(), DatatypeSort(), DeclareSort(), DeclareTypeVar(), EnumSort(), FreshBool(), FreshConst(), FreshInt(), FreshReal(), get_ctx(), If(), Implies(), Int(), Ints(), IntSort(), IntVal(), IntVector(), Model(), Not(), Or(), Real(), Reals(), RealSort(), RealVal(), RealVector(), Sqrt(), to_symbol(), and Xor().
◆ _get_ctx2()
|
protected |
◆ _global_on_model()
|
protected |
◆ _has_probe()
|
protected |
Return `True` if one of the elements of the given collection is a Z3 probe.
Definition at line 1933 of file z3py.py.
1933def _has_probe(args):
1934 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1935 for arg in args:
1936 if is_probe(arg):
1937 return True
1938 return False
1939
1940
◆ _is_algebraic()
|
protected |
Definition at line 2830 of file z3py.py.
2830def _is_algebraic(ctx, a):
2832
2833
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.
Referenced by _to_expr_ref(), and is_algebraic_value().
◆ _is_int()
|
protected |
Definition at line 76 of file z3py.py.
76 def _is_int(v):
77 return isinstance(v, (int, long))
Referenced by ModelRef.__getitem__(), ParamDescrsRef.__getitem__(), _py2expr(), Extract(), RatVal(), RepeatBitVec(), ParamsRef.set(), SignExt(), to_symbol(), and ZeroExt().
◆ _is_numeral()
|
protected |
Definition at line 2826 of file z3py.py.
2826def _is_numeral(ctx, a):
2828
2829
bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a)
Referenced by _to_expr_ref(), is_bv_value(), is_int_value(), and is_rational_value().
◆ _mk_bin()
|
protected |
Definition at line 1490 of file z3py.py.
1490def _mk_bin(f, a, b):
1491 args = (Ast * 2)()
1492 if z3_debug():
1493 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1494 args[0] = a.as_ast()
1495 args[1] = b.as_ast()
1496 return f(a.ctx.ref(), 2, args)
1497
1498
Referenced by ArithRef.__add__(), ArithRef.__mul__(), ArithRef.__radd__(), ArithRef.__rmul__(), ArithRef.__rsub__(), and ArithRef.__sub__().
◆ _mk_fp_bin()
|
protected |
Definition at line 10475 of file z3py.py.
10475def _mk_fp_bin(f, rm, a, b, ctx):
10476 ctx = _get_ctx(ctx)
10477 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10478 if z3_debug():
10479 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10480 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10481 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10482
10483
◆ _mk_fp_bin_norm()
|
protected |
Definition at line 10484 of file z3py.py.
10484def _mk_fp_bin_norm(f, a, b, ctx):
10485 ctx = _get_ctx(ctx)
10486 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10487 if z3_debug():
10488 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10489 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10490
10491
◆ _mk_fp_bin_pred()
|
protected |
Definition at line 10492 of file z3py.py.
10492def _mk_fp_bin_pred(f, a, b, ctx):
10493 ctx = _get_ctx(ctx)
10494 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10495 if z3_debug():
10496 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10497 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10498
10499
◆ _mk_fp_tern()
|
protected |
Definition at line 10500 of file z3py.py.
10500def _mk_fp_tern(f, rm, a, b, c, ctx):
10501 ctx = _get_ctx(ctx)
10502 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10503 if z3_debug():
10504 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10505 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10506 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10507 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10508
10509
◆ _mk_fp_unary()
|
protected |
Definition at line 10458 of file z3py.py.
10458def _mk_fp_unary(f, rm, a, ctx):
10459 ctx = _get_ctx(ctx)
10460 [a] = _coerce_fp_expr_list([a], ctx)
10461 if z3_debug():
10462 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10463 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10464 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10465
10466
◆ _mk_fp_unary_pred()
|
protected |
Definition at line 10467 of file z3py.py.
10467def _mk_fp_unary_pred(f, a, ctx):
10468 ctx = _get_ctx(ctx)
10469 [a] = _coerce_fp_expr_list([a], ctx)
10470 if z3_debug():
10471 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10472 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10473
10474
◆ _mk_quantifier()
|
protected |
Definition at line 2289 of file z3py.py.
2289def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2290 if z3_debug():
2291 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2292 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2293 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2294 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2295 if is_app(vs):
2296 ctx = vs.ctx
2297 vs = [vs]
2298 else:
2299 ctx = vs[0].ctx
2300 if not is_expr(body):
2301 body = BoolVal(body, ctx)
2302 num_vars = len(vs)
2303 if num_vars == 0:
2304 return body
2305 _vs = (Ast * num_vars)()
2306 for i in range(num_vars):
2307 # TODO: Check if is constant
2308 _vs[i] = vs[i].as_ast()
2309 patterns = [_to_pattern(p) for p in patterns]
2310 num_pats = len(patterns)
2311 _pats = (Pattern * num_pats)()
2312 for i in range(num_pats):
2313 _pats[i] = patterns[i].ast
2314 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2315 qid = to_symbol(qid, ctx)
2316 skid = to_symbol(skid, ctx)
2318 num_vars, _vs,
2319 num_pats, _pats,
2320 num_no_pats, _no_pats,
2321 body.as_ast()), ctx)
2322
2323
Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c, bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], unsigned num_no_patterns, Z3_ast const no_patterns[], Z3_ast body)
Create a universal or existential quantifier using a list of constants that will form the set of boun...
◆ _or_else()
|
protected |
Definition at line 8583 of file z3py.py.
8583def _or_else(t1, t2, ctx=None):
8584 t1 = _to_tactic(t1, ctx)
8585 t2 = _to_tactic(t2, ctx)
8586 if z3_debug():
8587 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8589
8590
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...
◆ _pb_args_coeffs()
|
protected |
Definition at line 9274 of file z3py.py.
9274def _pb_args_coeffs(args, default_ctx=None):
9275 args = _get_args_ast_list(args)
9276 if len(args) == 0:
9277 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9278 args = [_reorder_pb_arg(arg) for arg in args]
9279 args, coeffs = zip(*args)
9280 if z3_debug():
9281 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9282 ctx = _ctx_from_ast_arg_list(args)
9283 if z3_debug():
9284 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9285 args = _coerce_expr_list(args, ctx)
9286 _args, sz = _to_ast_array(args)
9287 _coeffs = (ctypes.c_int * len(coeffs))()
9288 for i in range(len(coeffs)):
9289 _z3_check_cint_overflow(coeffs[i], "coefficient")
9290 _coeffs[i] = coeffs[i]
9291 return ctx, sz, _args, _coeffs, args
9292
9293
◆ _probe_and()
|
protected |
◆ _probe_nary()
|
protected |
Definition at line 8988 of file z3py.py.
8988def _probe_nary(f, args, ctx):
8989 if z3_debug():
8990 _z3_assert(len(args) > 0, "At least one argument expected")
8991 num = len(args)
8992 r = _to_probe(args[0], ctx)
8993 for i in range(num - 1):
8994 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8995 return r
8996
8997
◆ _probe_or()
|
protected |
◆ _prove_html()
|
protected |
Version of function `prove` that renders HTML.
Definition at line 9465 of file z3py.py.
9465def _prove_html(claim, show=False, **keywords):
9466 """Version of function `prove` that renders HTML."""
9467 if z3_debug():
9468 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9469 s = Solver()
9470 s.set(**keywords)
9471 s.add(Not(claim))
9472 if show:
9473 print(s)
9474 r = s.check()
9475 if r == unsat:
9476 print("<b>proved</b>")
9477 elif r == unknown:
9478 print("<b>failed to prove</b>")
9479 print(s.model())
9480 else:
9481 print("<b>counterexample</b>")
9482 print(s.model())
9483
9484
◆ _py2expr()
|
protected |
Definition at line 3231 of file z3py.py.
3231def _py2expr(a, ctx=None):
3232 if isinstance(a, bool):
3233 return BoolVal(a, ctx)
3234 if _is_int(a):
3235 return IntVal(a, ctx)
3236 if isinstance(a, float):
3237 return RealVal(a, ctx)
3238 if isinstance(a, str):
3239 return StringVal(a, ctx)
3240 if is_expr(a):
3241 return a
3242 if z3_debug():
3243 _z3_assert(False, "Python bool, int, long or float expected")
3244
3245
Referenced by _coerce_expr_list(), _coerce_exprs(), IsMember(), K(), SetAdd(), SetDel(), SetHasSize(), and ModelRef.update_value().
◆ _reduce()
|
protected |
Definition at line 1285 of file z3py.py.
1285def _reduce(func, sequence, initial):
1286 result = initial
1287 for element in sequence:
1288 result = func(result, element)
1289 return result
1290
1291
Referenced by _coerce_expr_list().
◆ _reorder_pb_arg()
|
protected |
◆ _solve_html()
|
protected |
Version of function `solve` that renders HTML output.
Definition at line 9416 of file z3py.py.
9416def _solve_html(*args, **keywords):
9417 """Version of function `solve` that renders HTML output."""
9418 show = keywords.pop("show", False)
9419 s = Solver()
9420 s.set(**keywords)
9421 s.add(*args)
9422 if show:
9423 print("<b>Problem:</b>")
9424 print(s)
9425 r = s.check()
9426 if r == unsat:
9427 print("<b>no solution</b>")
9428 elif r == unknown:
9429 print("<b>failed to solve</b>")
9430 try:
9431 print(s.model())
9432 except Z3Exception:
9433 return
9434 else:
9435 if show:
9436 print("<b>Solution:</b>")
9437 print(s.model())
9438
9439
◆ _solve_using_html()
|
protected |
Version of function `solve_using` that renders HTML.
Definition at line 9440 of file z3py.py.
9440def _solve_using_html(s, *args, **keywords):
9441 """Version of function `solve_using` that renders HTML."""
9442 show = keywords.pop("show", False)
9443 if z3_debug():
9444 _z3_assert(isinstance(s, Solver), "Solver object expected")
9445 s.set(**keywords)
9446 s.add(*args)
9447 if show:
9448 print("<b>Problem:</b>")
9449 print(s)
9450 r = s.check()
9451 if r == unsat:
9452 print("<b>no solution</b>")
9453 elif r == unknown:
9454 print("<b>failed to solve</b>")
9455 try:
9456 print(s.model())
9457 except Z3Exception:
9458 return
9459 else:
9460 if show:
9461 print("<b>Solution:</b>")
9462 print(s.model())
9463
9464
◆ _sort()
◆ _sort_kind()
|
protected |
Sorts.
Definition at line 569 of file z3py.py.
569def _sort_kind(ctx, s):
571
572
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).
Referenced by _to_sort_ref().
◆ _symbol2py()
|
protected |
Convert a Z3 symbol back into a Python object.
Definition at line 140 of file z3py.py.
140def _symbol2py(ctx, s):
141 """Convert a Z3 symbol back into a Python object. """
144 else:
146
147# Hack for having nary functions that can receive one argument that is the
148# list of arguments.
149# Use this when function takes a single list of arguments
150
151
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
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...
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
Referenced by ParamDescrsRef.get_name(), SortRef.name(), QuantifierRef.qid(), QuantifierRef.skolem_id(), and QuantifierRef.var_name().
◆ _to_ast_array()
|
protected |
Definition at line 537 of file z3py.py.
537def _to_ast_array(args):
538 sz = len(args)
539 _args = (Ast * sz)()
540 for i in range(sz):
541 _args[i] = args[i].as_ast()
542 return _args, sz
543
544
Referenced by ExprRef.__ne__(), _array_select(), _mk_quantifier(), And(), Distinct(), Map(), MultiPattern(), Or(), SetIntersect(), SetUnion(), and Update().
◆ _to_ast_ref()
|
protected |
Definition at line 553 of file z3py.py.
553def _to_ast_ref(a, ctx):
554 k = _ast_kind(ctx, a)
555 if k == Z3_SORT_AST:
556 return _to_sort_ref(a, ctx)
557 elif k == Z3_FUNC_DECL_AST:
558 return _to_func_decl_ref(a, ctx)
559 else:
560 return _to_expr_ref(a, ctx)
561
562
Referenced by AstRef.__deepcopy__(), AstMap.__getitem__(), AstVector.__getitem__(), and AstRef.translate().
◆ _to_expr_ref()
|
protected |
Definition at line 1180 of file z3py.py.
1180def _to_expr_ref(a, ctx):
1181 if isinstance(a, Pattern):
1182 return PatternRef(a, ctx)
1183 ctx_ref = ctx.ref()
1184 k = Z3_get_ast_kind(ctx_ref, a)
1185 if k == Z3_QUANTIFIER_AST:
1186 return QuantifierRef(a, ctx)
1188 if sk == Z3_BOOL_SORT:
1189 return BoolRef(a, ctx)
1190 if sk == Z3_INT_SORT:
1191 if k == Z3_NUMERAL_AST:
1192 return IntNumRef(a, ctx)
1193 return ArithRef(a, ctx)
1194 if sk == Z3_REAL_SORT:
1195 if k == Z3_NUMERAL_AST:
1196 return RatNumRef(a, ctx)
1197 if _is_algebraic(ctx, a):
1198 return AlgebraicNumRef(a, ctx)
1199 return ArithRef(a, ctx)
1200 if sk == Z3_BV_SORT:
1201 if k == Z3_NUMERAL_AST:
1202 return BitVecNumRef(a, ctx)
1203 else:
1204 return BitVecRef(a, ctx)
1205 if sk == Z3_ARRAY_SORT:
1206 return ArrayRef(a, ctx)
1207 if sk == Z3_DATATYPE_SORT:
1208 return DatatypeRef(a, ctx)
1209 if sk == Z3_FLOATING_POINT_SORT:
1210 if k == Z3_APP_AST and _is_numeral(ctx, a):
1211 return FPNumRef(a, ctx)
1212 else:
1213 return FPRef(a, ctx)
1214 if sk == Z3_FINITE_DOMAIN_SORT:
1215 if k == Z3_NUMERAL_AST:
1216 return FiniteDomainNumRef(a, ctx)
1217 else:
1218 return FiniteDomainRef(a, ctx)
1219 if sk == Z3_ROUNDING_MODE_SORT:
1220 return FPRMRef(a, ctx)
1221 if sk == Z3_SEQ_SORT:
1222 return SeqRef(a, ctx)
1223 if sk == Z3_CHAR_SORT:
1224 return CharRef(a, ctx)
1225 if sk == Z3_RE_SORT:
1226 return ReRef(a, ctx)
1227 return ExprRef(a, ctx)
1228
1229
Referenced by FuncDeclRef.__call__(), _array_select(), _to_ast_ref(), ExprRef.arg(), FuncEntry.arg_value(), QuantifierRef.body(), Const(), ArrayRef.default(), FuncInterp.else_value(), ModelRef.eval(), Ext(), FreshConst(), Goal.get(), ModelRef.get_interp(), If(), QuantifierRef.no_pattern(), ModelRef.project(), ModelRef.project_with_witness(), SetHasSize(), Update(), FuncEntry.value(), and Var().
◆ _to_float_str()
|
protected |
Definition at line 10220 of file z3py.py.
10220def _to_float_str(val, exp=0):
10221 if isinstance(val, float):
10222 if math.isnan(val):
10223 res = "NaN"
10224 elif val == 0.0:
10225 sone = math.copysign(1.0, val)
10226 if sone < 0.0:
10227 return "-0.0"
10228 else:
10229 return "+0.0"
10230 elif val == float("+inf"):
10231 res = "+oo"
10232 elif val == float("-inf"):
10233 res = "-oo"
10234 else:
10235 v = val.as_integer_ratio()
10236 num = v[0]
10237 den = v[1]
10238 rvs = str(num) + "/" + str(den)
10239 res = rvs + "p" + _to_int_str(exp)
10240 elif isinstance(val, bool):
10241 if val:
10242 res = "1.0"
10243 else:
10244 res = "0.0"
10245 elif _is_int(val):
10246 res = str(val)
10247 elif isinstance(val, str):
10248 inx = val.find("*(2**")
10249 if inx == -1:
10250 res = val
10251 elif val[-1] == ")":
10252 res = val[0:inx]
10253 exp = str(int(val[inx + 5:-1]) + int(exp))
10254 else:
10255 _z3_assert(False, "String does not have floating-point numeral form.")
10256 elif z3_debug():
10257 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10258 if exp == 0:
10259 return res
10260 else:
10261 return res + "p" + exp
10262
10263
◆ _to_func_decl_array()
|
protected |
◆ _to_func_decl_ref()
|
protected |
Definition at line 945 of file z3py.py.
945def _to_func_decl_ref(a, ctx):
946 return FuncDeclRef(a, ctx)
947
948
Referenced by _to_ast_ref().
◆ _to_goal()
|
protected |
◆ _to_int_str()
|
protected |
Definition at line 3280 of file z3py.py.
3280def _to_int_str(val):
3281 if isinstance(val, float):
3282 return str(int(val))
3283 elif isinstance(val, bool):
3284 if val:
3285 return "1"
3286 else:
3287 return "0"
3288 else:
3289 return str(val)
3290
3291
Referenced by BitVecVal(), and IntVal().
◆ _to_param_value()
|
protected |
Definition at line 178 of file z3py.py.
178def _to_param_value(val):
179 if isinstance(val, bool):
180 return "true" if val else "false"
181 return str(val)
182
183
Referenced by Context.__init__(), and set_param().
◆ _to_pattern()
|
protected |
Definition at line 2067 of file z3py.py.
2067def _to_pattern(arg):
2068 if is_pattern(arg):
2069 return arg
2070 else:
2071 return MultiPattern(arg)
2072
Referenced by _mk_quantifier().
◆ _to_probe()
|
protected |
◆ _to_ref_array()
|
protected |
◆ _to_sort_ref()
|
protected |
Definition at line 678 of file z3py.py.
678def _to_sort_ref(s, ctx):
679 if z3_debug():
680 _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
681 k = _sort_kind(ctx, s)
682 if k == Z3_BOOL_SORT:
683 return BoolSortRef(s, ctx)
684 elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
685 return ArithSortRef(s, ctx)
686 elif k == Z3_BV_SORT:
687 return BitVecSortRef(s, ctx)
688 elif k == Z3_ARRAY_SORT:
689 return ArraySortRef(s, ctx)
690 elif k == Z3_DATATYPE_SORT:
691 return DatatypeSortRef(s, ctx)
692 elif k == Z3_FINITE_DOMAIN_SORT:
693 return FiniteDomainSortRef(s, ctx)
694 elif k == Z3_FLOATING_POINT_SORT:
695 return FPSortRef(s, ctx)
696 elif k == Z3_ROUNDING_MODE_SORT:
697 return FPRMSortRef(s, ctx)
698 elif k == Z3_RE_SORT:
699 return ReSortRef(s, ctx)
700 elif k == Z3_SEQ_SORT:
701 return SeqSortRef(s, ctx)
702 elif k == Z3_CHAR_SORT:
703 return CharSortRef(s, ctx)
704 elif k == Z3_TYPE_VAR:
705 return TypeVarRef(s, ctx)
706 return SortRef(s, ctx)
707
708
Referenced by _sort(), _to_ast_ref(), FuncDeclRef.domain(), ArraySortRef.domain_n(), ModelRef.get_sort(), ArraySortRef.range(), FuncDeclRef.range(), and QuantifierRef.var_sort().
◆ _to_tactic()
|
protected |
◆ _valid_accessor()
|
protected |
Datatypes.
Return `True` if acc is pair of the form (String, Datatype or Sort).
Definition at line 5171 of file z3py.py.
5171def _valid_accessor(acc):
5172 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5173 if not isinstance(acc, tuple):
5174 return False
5175 if len(acc) != 2:
5176 return False
5177 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5178
5179
Referenced by Datatype.declare_core().
◆ _z3_assert()
|
protected |
Definition at line 113 of file z3py.py.
113def _z3_assert(cond, msg):
114 if not cond:
115 raise Z3Exception(msg)
116
117
Referenced by ModelRef.__getitem__(), QuantifierRef.__getitem__(), Context.__init__(), Goal.__init__(), ParamDescrsRef.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _check_bv_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _mk_bin(), _mk_quantifier(), _py2expr(), _to_sort_ref(), _z3_check_cint_overflow(), DatatypeSortRef.accessor(), And(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), RatNumRef.as_long(), Solver.assert_and_track(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), AstRef.eq(), eq(), Ext(), Extract(), FreshConst(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), IsInt(), K(), ExprRef.kind(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), QuantifierRef.pattern(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Update(), ParamsRef.validate(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().
◆ _z3_check_cint_overflow()
|
protected |
◆ Abs()
| Abs | ( | arg | ) |
◆ AllChar()
| AllChar | ( | regex_sort, | |
| ctx = None ) |
Create a regular expression that accepts all single character strings
Definition at line 11663 of file z3py.py.
11663def AllChar(regex_sort, ctx=None):
11664 """Create a regular expression that accepts all single character strings
11665 """
11667
11668# Special Relations
11669
11670
Z3_ast Z3_API Z3_mk_re_allchar(Z3_context c, Z3_sort regex_sort)
Create a regular expression that accepts all singleton sequences of the regular expression sort.
◆ And()
| And | ( | * | args | ) |
Create a Z3 and-expression or and-probe.
>>> p, q, r = Bools('p q r')
>>> And(p, q, r)
And(p, q, r)
>>> P = BoolVector('p', 5)
>>> And(P)
And(p__0, p__1, p__2, p__3, p__4)
Definition at line 1941 of file z3py.py.
1941def And(*args):
1942 """Create a Z3 and-expression or and-probe.
1943
1944 >>> p, q, r = Bools('p q r')
1945 >>> And(p, q, r)
1946 And(p, q, r)
1947 >>> P = BoolVector('p', 5)
1948 >>> And(P)
1949 And(p__0, p__1, p__2, p__3, p__4)
1950 """
1951 last_arg = None
1952 if len(args) > 0:
1953 last_arg = args[len(args) - 1]
1954 if isinstance(last_arg, Context):
1955 ctx = args[len(args) - 1]
1956 args = args[:len(args) - 1]
1957 elif len(args) == 1 and isinstance(args[0], AstVector):
1958 ctx = args[0].ctx
1959 args = [a for a in args[0]]
1960 else:
1961 ctx = None
1962 args = _get_args(args)
1963 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1964 if z3_debug():
1965 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1966 if _has_probe(args):
1967 return _probe_and(args, ctx)
1968 else:
1969 args = _coerce_expr_list(args, ctx)
1970 _args, sz = _to_ast_array(args)
1972
1973
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].
Referenced by BoolRef.__and__(), and Goal.as_expr().
◆ AndThen()
| AndThen | ( | * | ts, |
| ** | ks ) |
Return a tactic that applies the tactics in `*ts` in sequence.
>>> x, y = Ints('x y')
>>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
>>> t(And(x == 0, y > x + 1))
[[Not(y <= 1)]]
>>> t(And(x == 0, y > x + 1)).as_expr()
Not(y <= 1)
Definition at line 8591 of file z3py.py.
8591def AndThen(*ts, **ks):
8592 """Return a tactic that applies the tactics in `*ts` in sequence.
8593
8594 >>> x, y = Ints('x y')
8595 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8596 >>> t(And(x == 0, y > x + 1))
8597 [[Not(y <= 1)]]
8598 >>> t(And(x == 0, y > x + 1)).as_expr()
8599 Not(y <= 1)
8600 """
8601 if z3_debug():
8602 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8603 ctx = ks.get("ctx", None)
8604 num = len(ts)
8605 r = ts[0]
8606 for i in range(num - 1):
8607 r = _and_then(r, ts[i + 1], ctx)
8608 return r
8609
8610
◆ append_log()
| append_log | ( | s | ) |
Append user-defined string to interaction log.
Definition at line 127 of file z3py.py.
127def append_log(s):
128 """Append user-defined string to interaction log. """
129 Z3_append_log(s)
130
131
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.
◆ args2params()
| args2params | ( | arguments, | |
| keywords, | |||
| ctx = None ) |
Convert python arguments into a Z3_params object.
A ':' is added to the keywords, and '_' is replaced with '-'
>>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
(params model true relevancy 2 elim_and true)
Definition at line 5620 of file z3py.py.
5620def args2params(arguments, keywords, ctx=None):
5621 """Convert python arguments into a Z3_params object.
5622 A ':' is added to the keywords, and '_' is replaced with '-'
5623
5624 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5625 (params model true relevancy 2 elim_and true)
5626 """
5627 if z3_debug():
5628 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5629 prev = None
5630 r = ParamsRef(ctx)
5631 for a in arguments:
5632 if prev is None:
5633 prev = a
5634 else:
5635 r.set(prev, a)
5636 prev = None
5637 for k in keywords:
5638 v = keywords[k]
5639 r.set(k, v)
5640 return r
5641
5642
Referenced by Solver.set().
◆ Array()
| Array | ( | name, | |
| * | sorts ) |
Return an array constant named `name` with the given domain and range sorts.
>>> a = Array('a', IntSort(), IntSort())
>>> a.sort()
Array(Int, Int)
>>> a[0]
a[0]
Definition at line 4867 of file z3py.py.
4867def Array(name, *sorts):
4868 """Return an array constant named `name` with the given domain and range sorts.
4869
4870 >>> a = Array('a', IntSort(), IntSort())
4871 >>> a.sort()
4872 Array(Int, Int)
4873 >>> a[0]
4874 a[0]
4875 """
4876 s = ArraySort(sorts)
4877 ctx = s.ctx
4879
4880
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
◆ ArraySort()
| ArraySort | ( | * | sig | ) |
Return the Z3 array sort with the given domain and range sorts. >>> A = ArraySort(IntSort(), BoolSort()) >>> A Array(Int, Bool) >>> A.domain() Int >>> A.range() Bool >>> AA = ArraySort(IntSort(), A) >>> AA Array(Int, Array(Int, Bool))
Definition at line 4834 of file z3py.py.
4834def ArraySort(*sig):
4835 """Return the Z3 array sort with the given domain and range sorts.
4836
4837 >>> A = ArraySort(IntSort(), BoolSort())
4838 >>> A
4839 Array(Int, Bool)
4840 >>> A.domain()
4841 Int
4842 >>> A.range()
4843 Bool
4844 >>> AA = ArraySort(IntSort(), A)
4845 >>> AA
4846 Array(Int, Array(Int, Bool))
4847 """
4848 sig = _get_args(sig)
4849 if z3_debug():
4850 _z3_assert(len(sig) > 1, "At least two arguments expected")
4851 arity = len(sig) - 1
4852 r = sig[arity]
4853 d = sig[0]
4854 if z3_debug():
4855 for s in sig:
4856 _z3_assert(is_sort(s), "Z3 sort expected")
4857 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4858 ctx = d.ctx
4859 if len(sig) == 2:
4861 dom = (Sort * arity)()
4862 for i in range(arity):
4863 dom[i] = sig[i].ast
4865
4866
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_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
Referenced by SortRef.__gt__(), Array(), and SetSort().
◆ AtLeast()
| AtLeast | ( | * | args | ) |
Create an at-least Pseudo-Boolean k constraint.
>>> a, b, c = Bools('a b c')
>>> f = AtLeast(a, b, c, 2)
Definition at line 9249 of file z3py.py.
9249def AtLeast(*args):
9250 """Create an at-least Pseudo-Boolean k constraint.
9251
9252 >>> a, b, c = Bools('a b c')
9253 >>> f = AtLeast(a, b, c, 2)
9254 """
9255 args = _get_args(args)
9256 if z3_debug():
9257 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9258 ctx = _ctx_from_ast_arg_list(args)
9259 if z3_debug():
9260 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9261 args1 = _coerce_expr_list(args[:-1], ctx)
9262 k = args[-1]
9263 _args, sz = _to_ast_array(args1)
9265
9266
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
◆ AtMost()
| AtMost | ( | * | args | ) |
Create an at-most Pseudo-Boolean k constraint.
>>> a, b, c = Bools('a b c')
>>> f = AtMost(a, b, c, 2)
Definition at line 9231 of file z3py.py.
9231def AtMost(*args):
9232 """Create an at-most Pseudo-Boolean k constraint.
9233
9234 >>> a, b, c = Bools('a b c')
9235 >>> f = AtMost(a, b, c, 2)
9236 """
9237 args = _get_args(args)
9238 if z3_debug():
9239 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9240 ctx = _ctx_from_ast_arg_list(args)
9241 if z3_debug():
9242 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9243 args1 = _coerce_expr_list(args[:-1], ctx)
9244 k = args[-1]
9245 _args, sz = _to_ast_array(args1)
9247
9248
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
◆ BitVec()
| BitVec | ( | name, | |
| bv, | |||
| ctx = None ) |
Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
If `ctx=None`, then the global context is used.
>>> x = BitVec('x', 16)
>>> is_bv(x)
True
>>> x.size()
16
>>> x.sort()
BitVec(16)
>>> word = BitVecSort(16)
>>> x2 = BitVec('x', word)
>>> eq(x, x2)
True
Definition at line 4148 of file z3py.py.
4148def BitVec(name, bv, ctx=None):
4149 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4150 If `ctx=None`, then the global context is used.
4151
4152 >>> x = BitVec('x', 16)
4153 >>> is_bv(x)
4154 True
4155 >>> x.size()
4156 16
4157 >>> x.sort()
4158 BitVec(16)
4159 >>> word = BitVecSort(16)
4160 >>> x2 = BitVec('x', word)
4161 >>> eq(x, x2)
4162 True
4163 """
4164 if isinstance(bv, BitVecSortRef):
4165 ctx = bv.ctx
4166 else:
4167 ctx = _get_ctx(ctx)
4168 bv = BitVecSort(bv, ctx)
4170
4171
Referenced by BitVecs().
◆ BitVecs()
| BitVecs | ( | names, | |
| bv, | |||
| ctx = None ) |
Return a tuple of bit-vector constants of size bv.
>>> x, y, z = BitVecs('x y z', 16)
>>> x.size()
16
>>> x.sort()
BitVec(16)
>>> Sum(x, y, z)
0 + x + y + z
>>> Product(x, y, z)
1*x*y*z
>>> simplify(Product(x, y, z))
x*y*z
Definition at line 4172 of file z3py.py.
4172def BitVecs(names, bv, ctx=None):
4173 """Return a tuple of bit-vector constants of size bv.
4174
4175 >>> x, y, z = BitVecs('x y z', 16)
4176 >>> x.size()
4177 16
4178 >>> x.sort()
4179 BitVec(16)
4180 >>> Sum(x, y, z)
4181 0 + x + y + z
4182 >>> Product(x, y, z)
4183 1*x*y*z
4184 >>> simplify(Product(x, y, z))
4185 x*y*z
4186 """
4187 ctx = _get_ctx(ctx)
4188 if isinstance(names, str):
4189 names = names.split(" ")
4190 return [BitVec(name, bv, ctx) for name in names]
4191
4192
◆ BitVecSort()
| BitVecSort | ( | sz, | |
| ctx = None ) |
Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
>>> Byte = BitVecSort(8)
>>> Word = BitVecSort(16)
>>> Byte
BitVec(8)
>>> x = Const('x', Byte)
>>> eq(x, BitVec('x', 8))
True
Definition at line 4116 of file z3py.py.
4116def BitVecSort(sz, ctx=None):
4117 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4118
4119 >>> Byte = BitVecSort(8)
4120 >>> Word = BitVecSort(16)
4121 >>> Byte
4122 BitVec(8)
4123 >>> x = Const('x', Byte)
4124 >>> eq(x, BitVec('x', 8))
4125 True
4126 """
4127 ctx = _get_ctx(ctx)
4129
4130
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
Referenced by BitVec(), and BitVecVal().
◆ BitVecVal()
| BitVecVal | ( | val, | |
| bv, | |||
| ctx = None ) |
Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
>>> v = BitVecVal(10, 32)
>>> v
10
>>> print("0x%.8x" % v.as_long())
0x0000000a
Definition at line 4131 of file z3py.py.
4131def BitVecVal(val, bv, ctx=None):
4132 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4133
4134 >>> v = BitVecVal(10, 32)
4135 >>> v
4136 10
4137 >>> print("0x%.8x" % v.as_long())
4138 0x0000000a
4139 """
4140 if is_bv_sort(bv):
4141 ctx = bv.ctx
4143 else:
4144 ctx = _get_ctx(ctx)
4146
4147
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
◆ Bool()
| Bool | ( | name, | |
| ctx = None ) |
Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
>>> p = Bool('p')
>>> q = Bool('q')
>>> And(p, q)
And(p, q)
Definition at line 1820 of file z3py.py.
1820def Bool(name, ctx=None):
1821 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1822
1823 >>> p = Bool('p')
1824 >>> q = Bool('q')
1825 >>> And(p, q)
1826 And(p, q)
1827 """
1828 ctx = _get_ctx(ctx)
1830
1831
Referenced by Solver.assert_and_track(), Bools(), and BoolVector().
◆ Bools()
| Bools | ( | names, | |
| ctx = None ) |
Return a tuple of Boolean constants.
`names` is a single string containing all names separated by blank spaces.
If `ctx=None`, then the global context is used.
>>> p, q, r = Bools('p q r')
>>> And(p, Or(q, r))
And(p, Or(q, r))
Definition at line 1832 of file z3py.py.
1832def Bools(names, ctx=None):
1833 """Return a tuple of Boolean constants.
1834
1835 `names` is a single string containing all names separated by blank spaces.
1836 If `ctx=None`, then the global context is used.
1837
1838 >>> p, q, r = Bools('p q r')
1839 >>> And(p, Or(q, r))
1840 And(p, Or(q, r))
1841 """
1842 ctx = _get_ctx(ctx)
1843 if isinstance(names, str):
1844 names = names.split(" ")
1845 return [Bool(name, ctx) for name in names]
1846
1847
◆ BoolSort()
| BoolSort | ( | ctx = None | ) |
Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
>>> BoolSort()
Bool
>>> p = Const('p', BoolSort())
>>> is_bool(p)
True
>>> r = Function('r', IntSort(), IntSort(), BoolSort())
>>> r(0, 1)
r(0, 1)
>>> is_bool(r(0, 1))
True
Definition at line 1783 of file z3py.py.
1783def BoolSort(ctx=None):
1784 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1785
1786 >>> BoolSort()
1787 Bool
1788 >>> p = Const('p', BoolSort())
1789 >>> is_bool(p)
1790 True
1791 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1792 >>> r(0, 1)
1793 r(0, 1)
1794 >>> is_bool(r(0, 1))
1795 True
1796 """
1797 ctx = _get_ctx(ctx)
1799
1800
Referenced by Goal.assert_exprs(), Solver.assert_exprs(), Bool(), Solver.check(), FreshBool(), If(), Implies(), Not(), SetSort(), and Xor().
◆ BoolVal()
| BoolVal | ( | val, | |
| ctx = None ) |
Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used. >>> BoolVal(True) True >>> is_true(BoolVal(True)) True >>> is_true(True) False >>> is_false(BoolVal(False)) True
Definition at line 1801 of file z3py.py.
1801def BoolVal(val, ctx=None):
1802 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1803
1804 >>> BoolVal(True)
1805 True
1806 >>> is_true(BoolVal(True))
1807 True
1808 >>> is_true(True)
1809 False
1810 >>> is_false(BoolVal(False))
1811 True
1812 """
1813 ctx = _get_ctx(ctx)
1814 if val:
1816 else:
1818
1819
Referenced by _mk_quantifier(), _py2expr(), and Goal.as_expr().
◆ BoolVector()
| BoolVector | ( | prefix, | |
| sz, | |||
| ctx = None ) |
Return a list of Boolean constants of size `sz`.
The constants are named using the given prefix.
If `ctx=None`, then the global context is used.
>>> P = BoolVector('p', 3)
>>> P
[p__0, p__1, p__2]
>>> And(P)
And(p__0, p__1, p__2)
Definition at line 1848 of file z3py.py.
1848def BoolVector(prefix, sz, ctx=None):
1849 """Return a list of Boolean constants of size `sz`.
1850
1851 The constants are named using the given prefix.
1852 If `ctx=None`, then the global context is used.
1853
1854 >>> P = BoolVector('p', 3)
1855 >>> P
1856 [p__0, p__1, p__2]
1857 >>> And(P)
1858 And(p__0, p__1, p__2)
1859 """
1860 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1861
1862
◆ BV2Int()
| BV2Int | ( | a, | |
| is_signed = False ) |
Return the Z3 expression BV2Int(a).
>>> b = BitVec('b', 3)
>>> BV2Int(b).sort()
Int
>>> x = Int('x')
>>> x > BV2Int(b)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=False)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=True)
x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
>>> solve(x > BV2Int(b), b == 1, x < 3)
[x = 2, b = 1]
Definition at line 4084 of file z3py.py.
4084def BV2Int(a, is_signed=False):
4085 """Return the Z3 expression BV2Int(a).
4086
4087 >>> b = BitVec('b', 3)
4088 >>> BV2Int(b).sort()
4089 Int
4090 >>> x = Int('x')
4091 >>> x > BV2Int(b)
4092 x > BV2Int(b)
4093 >>> x > BV2Int(b, is_signed=False)
4094 x > BV2Int(b)
4095 >>> x > BV2Int(b, is_signed=True)
4096 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4097 >>> solve(x > BV2Int(b), b == 1, x < 3)
4098 [x = 2, b = 1]
4099 """
4100 if z3_debug():
4101 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4102 ctx = a.ctx
4103 # investigate problem with bv2int
4105
4106
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...
◆ BVAddNoOverflow()
| BVAddNoOverflow | ( | a, | |
| b, | |||
| signed ) |
A predicate the determines that bit-vector addition does not overflow
Definition at line 4593 of file z3py.py.
4593def BVAddNoOverflow(a, b, signed):
4594 """A predicate the determines that bit-vector addition does not overflow"""
4595 _check_bv_args(a, b)
4596 a, b = _coerce_exprs(a, b)
4598
4599
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.
◆ BVAddNoUnderflow()
| BVAddNoUnderflow | ( | a, | |
| b ) |
A predicate the determines that signed bit-vector addition does not underflow
Definition at line 4600 of file z3py.py.
4600def BVAddNoUnderflow(a, b):
4601 """A predicate the determines that signed bit-vector addition does not underflow"""
4602 _check_bv_args(a, b)
4603 a, b = _coerce_exprs(a, b)
4605
4606
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.
◆ BVMulNoOverflow()
| BVMulNoOverflow | ( | a, | |
| b, | |||
| signed ) |
A predicate the determines that bit-vector multiplication does not overflow
Definition at line 4635 of file z3py.py.
4635def BVMulNoOverflow(a, b, signed):
4636 """A predicate the determines that bit-vector multiplication does not overflow"""
4637 _check_bv_args(a, b)
4638 a, b = _coerce_exprs(a, b)
4640
4641
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.
◆ BVMulNoUnderflow()
| BVMulNoUnderflow | ( | a, | |
| b ) |
A predicate the determines that bit-vector signed multiplication does not underflow
Definition at line 4642 of file z3py.py.
4642def BVMulNoUnderflow(a, b):
4643 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4644 _check_bv_args(a, b)
4645 a, b = _coerce_exprs(a, b)
4647
4648
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...
◆ BVRedAnd()
| BVRedAnd | ( | a | ) |
Return the reduction-and expression of `a`.
Definition at line 4579 of file z3py.py.
4579def BVRedAnd(a):
4580 """Return the reduction-and expression of `a`."""
4581 if z3_debug():
4582 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4584
4585
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
◆ BVRedOr()
| BVRedOr | ( | a | ) |
Return the reduction-or expression of `a`.
Definition at line 4586 of file z3py.py.
4586def BVRedOr(a):
4587 """Return the reduction-or expression of `a`."""
4588 if z3_debug():
4589 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4591
4592
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
◆ BVSDivNoOverflow()
| BVSDivNoOverflow | ( | a, | |
| b ) |
A predicate the determines that bit-vector signed division does not overflow
Definition at line 4621 of file z3py.py.
4621def BVSDivNoOverflow(a, b):
4622 """A predicate the determines that bit-vector signed division does not overflow"""
4623 _check_bv_args(a, b)
4624 a, b = _coerce_exprs(a, b)
4626
4627
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.
◆ BVSNegNoOverflow()
| BVSNegNoOverflow | ( | a | ) |
A predicate the determines that bit-vector unary negation does not overflow
Definition at line 4628 of file z3py.py.
4628def BVSNegNoOverflow(a):
4629 """A predicate the determines that bit-vector unary negation does not overflow"""
4630 if z3_debug():
4631 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4633
4634
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.
◆ BVSubNoOverflow()
| BVSubNoOverflow | ( | a, | |
| b ) |
A predicate the determines that bit-vector subtraction does not overflow
Definition at line 4607 of file z3py.py.
4607def BVSubNoOverflow(a, b):
4608 """A predicate the determines that bit-vector subtraction does not overflow"""
4609 _check_bv_args(a, b)
4610 a, b = _coerce_exprs(a, b)
4612
4613
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.
◆ BVSubNoUnderflow()
| BVSubNoUnderflow | ( | a, | |
| b, | |||
| signed ) |
A predicate the determines that bit-vector subtraction does not underflow
Definition at line 4614 of file z3py.py.
4614def BVSubNoUnderflow(a, b, signed):
4615 """A predicate the determines that bit-vector subtraction does not underflow"""
4616 _check_bv_args(a, b)
4617 a, b = _coerce_exprs(a, b)
4619
4620
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.
◆ Cbrt()
| Cbrt | ( | a, | |
| ctx = None ) |
Return a Z3 expression which represents the cubic root of a.
>>> x = Real('x')
>>> Cbrt(x)
x**(1/3)
Definition at line 3530 of file z3py.py.
3530def Cbrt(a, ctx=None):
3531 """ Return a Z3 expression which represents the cubic root of a.
3532
3533 >>> x = Real('x')
3534 >>> Cbrt(x)
3535 x**(1/3)
3536 """
3537 if not is_expr(a):
3538 ctx = _get_ctx(ctx)
3539 a = RealVal(a, ctx)
3540 return a ** "1/3"
3541
◆ CharFromBv()
| CharFromBv | ( | bv | ) |
◆ CharIsDigit()
| CharIsDigit | ( | ch, | |
| ctx = None ) |
◆ CharSort()
| CharSort | ( | ctx = None | ) |
◆ CharToBv()
| CharToBv | ( | ch, | |
| ctx = None ) |
◆ CharToInt()
| CharToInt | ( | ch, | |
| ctx = None ) |
◆ CharVal()
| CharVal | ( | ch, | |
| ctx = None ) |
◆ Complement()
| Complement | ( | re | ) |
◆ Concat()
| Concat | ( | * | args | ) |
Create a Z3 bit-vector concatenation expression.
>>> v = BitVecVal(1, 4)
>>> Concat(v, v+1, v)
Concat(Concat(1, 1 + 1), 1)
>>> simplify(Concat(v, v+1, v))
289
>>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
121
Definition at line 4193 of file z3py.py.
4193def Concat(*args):
4194 """Create a Z3 bit-vector concatenation expression.
4195
4196 >>> v = BitVecVal(1, 4)
4197 >>> Concat(v, v+1, v)
4198 Concat(Concat(1, 1 + 1), 1)
4199 >>> simplify(Concat(v, v+1, v))
4200 289
4201 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4202 121
4203 """
4204 args = _get_args(args)
4205 sz = len(args)
4206 if z3_debug():
4207 _z3_assert(sz >= 2, "At least two arguments expected.")
4208
4209 ctx = None
4210 for a in args:
4211 if is_expr(a):
4212 ctx = a.ctx
4213 break
4214 if is_seq(args[0]) or isinstance(args[0], str):
4215 args = [_coerce_seq(s, ctx) for s in args]
4216 if z3_debug():
4217 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4218 v = (Ast * sz)()
4219 for i in range(sz):
4220 v[i] = args[i].as_ast()
4222
4223 if is_re(args[0]):
4224 if z3_debug():
4225 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4226 v = (Ast * sz)()
4227 for i in range(sz):
4228 v[i] = args[i].as_ast()
4230
4231 if z3_debug():
4232 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4233 r = args[0]
4234 for i in range(sz - 1):
4235 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4236 return r
4237
4238
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
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_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
◆ Cond()
| Cond | ( | p, | |
| t1, | |||
| t2, | |||
| ctx = None ) |
Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
>>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
Definition at line 9048 of file z3py.py.
9048def Cond(p, t1, t2, ctx=None):
9049 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
9050
9051 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
9052 """
9053 p = _to_probe(p, ctx)
9054 t1 = _to_tactic(t1, ctx)
9055 t2 = _to_tactic(t2, ctx)
9057
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...
Referenced by If().
◆ Const()
| Const | ( | name, | |
| sort ) |
Create a constant of the given sort.
>>> Const('x', IntSort())
x
Definition at line 1499 of file z3py.py.
1499def Const(name, sort):
1500 """Create a constant of the given sort.
1501
1502 >>> Const('x', IntSort())
1503 x
1504 """
1505 if z3_debug():
1506 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1507 ctx = sort.ctx
1509
1510
Referenced by Consts().
◆ Consts()
| Consts | ( | names, | |
| sort ) |
Create several constants of the given sort.
`names` is a string containing the names of all constants to be created.
Blank spaces separate the names of different constants.
>>> x, y, z = Consts('x y z', IntSort())
>>> x + y + z
x + y + z
Definition at line 1511 of file z3py.py.
1511def Consts(names, sort):
1512 """Create several constants of the given sort.
1513
1514 `names` is a string containing the names of all constants to be created.
1515 Blank spaces separate the names of different constants.
1516
1517 >>> x, y, z = Consts('x y z', IntSort())
1518 >>> x + y + z
1519 x + y + z
1520 """
1521 if isinstance(names, str):
1522 names = names.split(" ")
1523 return [Const(name, sort) for name in names]
1524
1525
◆ Contains()
| Contains | ( | a, | |
| b ) |
Check if 'a' contains 'b'
>>> s1 = Contains("abc", "ab")
>>> simplify(s1)
True
>>> s2 = Contains("abc", "bc")
>>> simplify(s2)
True
>>> x, y, z = Strings('x y z')
>>> s3 = Contains(Concat(x,y,z), y)
>>> simplify(s3)
True
Definition at line 11350 of file z3py.py.
11350def Contains(a, b):
11351 """Check if 'a' contains 'b'
11352 >>> s1 = Contains("abc", "ab")
11353 >>> simplify(s1)
11354 True
11355 >>> s2 = Contains("abc", "bc")
11356 >>> simplify(s2)
11357 True
11358 >>> x, y, z = Strings('x y z')
11359 >>> s3 = Contains(Concat(x,y,z), y)
11360 >>> simplify(s3)
11361 True
11362 """
11363 ctx = _get_ctx2(a, b)
11364 a = _coerce_seq(a, ctx)
11365 b = _coerce_seq(b, ctx)
11367
11368
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
◆ CreateDatatypes()
| CreateDatatypes | ( | * | ds | ) |
Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
In the following example we define a Tree-List using two mutually recursive datatypes.
>>> TreeList = Datatype('TreeList')
>>> Tree = Datatype('Tree')
>>> # Tree has two constructors: leaf and node
>>> Tree.declare('leaf', ('val', IntSort()))
>>> # a node contains a list of trees
>>> Tree.declare('node', ('children', TreeList))
>>> TreeList.declare('nil')
>>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
>>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
>>> Tree.val(Tree.leaf(10))
val(leaf(10))
>>> simplify(Tree.val(Tree.leaf(10)))
10
>>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
>>> n1
node(cons(leaf(10), cons(leaf(20), nil)))
>>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
>>> simplify(n2 == n1)
False
>>> simplify(TreeList.car(Tree.children(n2)) == n1)
True
Definition at line 5292 of file z3py.py.
5292def CreateDatatypes(*ds):
5293 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5294
5295 In the following example we define a Tree-List using two mutually recursive datatypes.
5296
5297 >>> TreeList = Datatype('TreeList')
5298 >>> Tree = Datatype('Tree')
5299 >>> # Tree has two constructors: leaf and node
5300 >>> Tree.declare('leaf', ('val', IntSort()))
5301 >>> # a node contains a list of trees
5302 >>> Tree.declare('node', ('children', TreeList))
5303 >>> TreeList.declare('nil')
5304 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5305 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5306 >>> Tree.val(Tree.leaf(10))
5307 val(leaf(10))
5308 >>> simplify(Tree.val(Tree.leaf(10)))
5309 10
5310 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5311 >>> n1
5312 node(cons(leaf(10), cons(leaf(20), nil)))
5313 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5314 >>> simplify(n2 == n1)
5315 False
5316 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5317 True
5318 """
5319 ds = _get_args(ds)
5320 if z3_debug():
5321 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5322 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5323 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5324 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5325 ctx = ds[0].ctx
5326 num = len(ds)
5327 names = (Symbol * num)()
5328 out = (Sort * num)()
5329 clists = (ConstructorList * num)()
5330 to_delete = []
5331 for i in range(num):
5332 d = ds[i]
5333 names[i] = to_symbol(d.name, ctx)
5334 num_cs = len(d.constructors)
5335 cs = (Constructor * num_cs)()
5336 for j in range(num_cs):
5337 c = d.constructors[j]
5338 cname = to_symbol(c[0], ctx)
5339 rname = to_symbol(c[1], ctx)
5340 fs = c[2]
5341 num_fs = len(fs)
5342 fnames = (Symbol * num_fs)()
5343 sorts = (Sort * num_fs)()
5344 refs = (ctypes.c_uint * num_fs)()
5345 for k in range(num_fs):
5346 fname = fs[k][0]
5347 ftype = fs[k][1]
5348 fnames[k] = to_symbol(fname, ctx)
5349 if isinstance(ftype, Datatype):
5350 if z3_debug():
5351 _z3_assert(
5352 ds.count(ftype) == 1,
5353 "One and only one occurrence of each datatype is expected",
5354 )
5355 sorts[k] = None
5356 refs[k] = ds.index(ftype)
5357 else:
5358 if z3_debug():
5359 _z3_assert(is_sort(ftype), "Z3 sort expected")
5360 sorts[k] = ftype.ast
5361 refs[k] = 0
5362 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5363 to_delete.append(ScopedConstructor(cs[j], ctx))
5364 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5365 to_delete.append(ScopedConstructorList(clists[i], ctx))
5366 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5367 result = []
5368 # Create a field for every constructor, recognizer and accessor
5369 for i in range(num):
5370 dref = DatatypeSortRef(out[i], ctx)
5371 num_cs = dref.num_constructors()
5372 for j in range(num_cs):
5373 cref = dref.constructor(j)
5374 cref_name = cref.name()
5375 cref_arity = cref.arity()
5376 if cref.arity() == 0:
5377 cref = cref()
5378 setattr(dref, cref_name, cref)
5379 rref = dref.recognizer(j)
5380 setattr(dref, "is_" + cref_name, rref)
5381 for k in range(cref_arity):
5382 aref = dref.accessor(j, k)
5383 setattr(dref, aref.name(), aref)
5384 result.append(dref)
5385 return tuple(result)
5386
5387
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_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
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 const sorts[], unsigned sort_refs[])
Create a constructor.
Referenced by Datatype.create().
◆ DatatypeSort()
| DatatypeSort | ( | name, | |
| params = None, | |||
| ctx = None ) |
Create a reference to a sort that was declared, or will be declared, as a recursive datatype.
Args:
name: name of the datatype sort
params: optional list/tuple of sort parameters for parametric datatypes
ctx: Z3 context (optional)
Example:
>>> # Non-parametric datatype
>>> TreeRef = DatatypeSort('Tree')
>>> # Parametric datatype with one parameter
>>> ListIntRef = DatatypeSort('List', [IntSort()])
>>> # Parametric datatype with multiple parameters
>>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])
Definition at line 5492 of file z3py.py.
5492def DatatypeSort(name, params=None, ctx=None):
5493 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype.
5494
5495 Args:
5496 name: name of the datatype sort
5497 params: optional list/tuple of sort parameters for parametric datatypes
5498 ctx: Z3 context (optional)
5499
5500 Example:
5501 >>> # Non-parametric datatype
5502 >>> TreeRef = DatatypeSort('Tree')
5503 >>> # Parametric datatype with one parameter
5504 >>> ListIntRef = DatatypeSort('List', [IntSort()])
5505 >>> # Parametric datatype with multiple parameters
5506 >>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])
5507 """
5508 ctx = _get_ctx(ctx)
5509 if params is None or len(params) == 0:
5510 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), 0, (Sort * 0)()), ctx)
5511 else:
5512 _params = (Sort * len(params))()
5513 for i in range(len(params)):
5514 _params[i] = params[i].ast
5515 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), len(params), _params), ctx)
5516
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name, unsigned num_params, Z3_sort const params[])
create a forward reference to a recursive datatype being declared. The forward reference can be used ...
◆ DeclareSort()
| SortRef DeclareSort | ( | name, | |
| ctx = None ) |
Create a new uninterpreted sort named `name`.
If `ctx=None`, then the new sort is declared in the global Z3Py context.
>>> A = DeclareSort('A')
>>> a = Const('a', A)
>>> b = Const('b', A)
>>> a.sort() == A
True
>>> b.sort() == A
True
>>> a == b
a == b
Definition at line 713 of file z3py.py.
713def DeclareSort(name, ctx= None) -> SortRef:
714 """Create a new uninterpreted sort named `name`.
715
716 If `ctx=None`, then the new sort is declared in the global Z3Py context.
717
718 >>> A = DeclareSort('A')
719 >>> a = Const('a', A)
720 >>> b = Const('b', A)
721 >>> a.sort() == A
722 True
723 >>> b.sort() == A
724 True
725 >>> a == b
726 a == b
727 """
728 ctx = _get_ctx(ctx)
730
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
◆ DeclareTypeVar()
| DeclareTypeVar | ( | name, | |
| ctx = None ) |
Create a new type variable named `name`. If `ctx=None`, then the new sort is declared in the global Z3Py context.
Definition at line 741 of file z3py.py.
741def DeclareTypeVar(name, ctx=None):
742 """Create a new type variable named `name`.
743
744 If `ctx=None`, then the new sort is declared in the global Z3Py context.
745
746 """
747 ctx = _get_ctx(ctx)
749
750
Z3_sort Z3_API Z3_mk_type_variable(Z3_context c, Z3_symbol s)
Create a type variable.
◆ Default()
| Default | ( | a | ) |
Return a default value for array expression. >>> b = K(IntSort(), 1) >>> prove(Default(b) == 1) proved
Definition at line 4913 of file z3py.py.
4913def Default(a):
4914 """ Return a default value for array expression.
4915 >>> b = K(IntSort(), 1)
4916 >>> prove(Default(b) == 1)
4917 proved
4918 """
4919 if z3_debug():
4920 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4921 return a.default()
4922
4923
◆ describe_probes()
| describe_probes | ( | ) |
Display a (tabular) description of all available probes in Z3.
Definition at line 8969 of file z3py.py.
8969def describe_probes():
8970 """Display a (tabular) description of all available probes in Z3."""
8971 if in_html_mode():
8972 even = True
8973 print('<table border="1" cellpadding="2" cellspacing="0">')
8974 for p in probes():
8975 if even:
8976 print('<tr style="background-color:#CFCFCF">')
8977 even = False
8978 else:
8979 print("<tr>")
8980 even = True
8981 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8982 print("</table>")
8983 else:
8984 for p in probes():
8985 print("%s : %s" % (p, probe_description(p)))
8986
8987
◆ describe_tactics()
| describe_tactics | ( | ) |
Display a (tabular) description of all available tactics in Z3.
Definition at line 8763 of file z3py.py.
8763def describe_tactics():
8764 """Display a (tabular) description of all available tactics in Z3."""
8765 if in_html_mode():
8766 even = True
8767 print('<table border="1" cellpadding="2" cellspacing="0">')
8768 for t in tactics():
8769 if even:
8770 print('<tr style="background-color:#CFCFCF">')
8771 even = False
8772 else:
8773 print("<tr>")
8774 even = True
8775 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8776 print("</table>")
8777 else:
8778 for t in tactics():
8779 print("%s : %s" % (t, tactic_description(t)))
8780
8781
◆ deserialize()
| deserialize | ( | st | ) |
inverse function to the serialize method on ExprRef. It is made available to make it easier for users to serialize expressions back and forth between strings. Solvers can be serialized using the 'sexpr()' method.
Definition at line 1166 of file z3py.py.
1166def deserialize(st):
1167 """inverse function to the serialize method on ExprRef.
1168 It is made available to make it easier for users to serialize expressions back and forth between
1169 strings. Solvers can be serialized using the 'sexpr()' method.
1170 """
1171 s = Solver()
1172 s.from_string(st)
1173 if len(s.assertions()) != 1:
1174 raise Z3Exception("single assertion expected")
1175 fml = s.assertions()[0]
1176 if fml.num_args() != 1:
1177 raise Z3Exception("dummy function 'F' expected")
1178 return fml.arg(0)
1179
◆ Diff()
| Diff | ( | a, | |
| b, | |||
| ctx = None ) |
Create the difference regular expression
Definition at line 11655 of file z3py.py.
11655def Diff(a, b, ctx=None):
11656 """Create the difference regular expression
11657 """
11658 if z3_debug():
11659 _z3_assert(is_expr(a), "expression expected")
11660 _z3_assert(is_expr(b), "expression expected")
11662
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.
◆ disable_trace()
| disable_trace | ( | msg | ) |
Definition at line 87 of file z3py.py.
87def disable_trace(msg):
88 Z3_disable_trace(msg)
89
90
void Z3_API Z3_disable_trace(Z3_string tag)
Disable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
◆ DisjointSum()
| DisjointSum | ( | name, | |
| sorts, | |||
| ctx = None ) |
Create a named tagged union sort base on a set of underlying sorts
Example:
>>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
Definition at line 5529 of file z3py.py.
5529def DisjointSum(name, sorts, ctx=None):
5530 """Create a named tagged union sort base on a set of underlying sorts
5531 Example:
5532 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5533 """
5534 sum = Datatype(name, ctx)
5535 for i in range(len(sorts)):
5536 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5537 sum = sum.create()
5538 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5539
5540
◆ Distinct()
| Distinct | ( | * | args | ) |
Create a Z3 distinct expression.
>>> x = Int('x')
>>> y = Int('y')
>>> Distinct(x, y)
x != y
>>> z = Int('z')
>>> Distinct(x, y, z)
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z))
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z), blast_distinct=True)
And(Not(x == y), Not(x == z), Not(y == z))
Definition at line 1466 of file z3py.py.
1466def Distinct(*args):
1467 """Create a Z3 distinct expression.
1468
1469 >>> x = Int('x')
1470 >>> y = Int('y')
1471 >>> Distinct(x, y)
1472 x != y
1473 >>> z = Int('z')
1474 >>> Distinct(x, y, z)
1475 Distinct(x, y, z)
1476 >>> simplify(Distinct(x, y, z))
1477 Distinct(x, y, z)
1478 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1479 And(Not(x == y), Not(x == z), Not(y == z))
1480 """
1481 args = _get_args(args)
1482 ctx = _ctx_from_ast_arg_list(args)
1483 if z3_debug():
1484 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1485 args = _coerce_expr_list(args, ctx)
1486 _args, sz = _to_ast_array(args)
1488
1489
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]).
◆ Empty()
| Empty | ( | s | ) |
Create the empty sequence of the given sort
>>> e = Empty(StringSort())
>>> e2 = StringVal("")
>>> print(e.eq(e2))
True
>>> e3 = Empty(SeqSort(IntSort()))
>>> print(e3)
Empty(Seq(Int))
>>> e4 = Empty(ReSort(SeqSort(IntSort())))
>>> print(e4)
Empty(ReSort(Seq(Int)))
Definition at line 11280 of file z3py.py.
11280def Empty(s):
11281 """Create the empty sequence of the given sort
11282 >>> e = Empty(StringSort())
11283 >>> e2 = StringVal("")
11284 >>> print(e.eq(e2))
11285 True
11286 >>> e3 = Empty(SeqSort(IntSort()))
11287 >>> print(e3)
11288 Empty(Seq(Int))
11289 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11290 >>> print(e4)
11291 Empty(ReSort(Seq(Int)))
11292 """
11293 if isinstance(s, SeqSortRef):
11295 if isinstance(s, ReSortRef):
11297 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11298
11299
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
◆ EmptySet()
| EmptySet | ( | s | ) |
◆ enable_trace()
| enable_trace | ( | msg | ) |
Definition at line 83 of file z3py.py.
83def enable_trace(msg):
84 Z3_enable_trace(msg)
85
86
void Z3_API Z3_enable_trace(Z3_string tag)
Enable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
◆ ensure_prop_closures()
| ensure_prop_closures | ( | ) |
◆ EnumSort()
| EnumSort | ( | name, | |
| values, | |||
| ctx = None ) |
Return a new enumeration sort named `name` containing the given values.
The result is a pair (sort, list of constants).
Example:
>>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
Definition at line 5541 of file z3py.py.
5541def EnumSort(name, values, ctx=None):
5542 """Return a new enumeration sort named `name` containing the given values.
5543
5544 The result is a pair (sort, list of constants).
5545 Example:
5546 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5547 """
5548 if z3_debug():
5549 _z3_assert(isinstance(name, str), "Name must be a string")
5550 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
5551 _z3_assert(len(values) > 0, "At least one value expected")
5552 ctx = _get_ctx(ctx)
5553 num = len(values)
5554 _val_names = (Symbol * num)()
5555 for i in range(num):
5556 _val_names[i] = to_symbol(values[i], ctx)
5557 _values = (FuncDecl * num)()
5558 _testers = (FuncDecl * num)()
5559 name = to_symbol(name, ctx)
5560 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5561 V = []
5562 for i in range(num):
5563 V.append(FuncDeclRef(_values[i], ctx))
5564 V = [a() for a in V]
5565 return S, V
5566
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.
◆ eq()
Return `True` if `a` and `b` are structurally identical AST nodes.
>>> x = Int('x')
>>> y = Int('y')
>>> eq(x, y)
False
>>> eq(x + 1, x + 1)
True
>>> eq(x + 1, 1 + x)
False
>>> eq(simplify(x + 1), simplify(1 + x))
True
Definition at line 486 of file z3py.py.
486def eq(a : AstRef, b : AstRef) -> bool:
487 """Return `True` if `a` and `b` are structurally identical AST nodes.
488
489 >>> x = Int('x')
490 >>> y = Int('y')
491 >>> eq(x, y)
492 False
493 >>> eq(x + 1, x + 1)
494 True
495 >>> eq(x + 1, 1 + x)
496 False
497 >>> eq(simplify(x + 1), simplify(1 + x))
498 True
499 """
500 if z3_debug():
501 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
502 return a.eq(b)
503
504
◆ Exists()
| Exists | ( | vs, | |
| body, | |||
| weight = 1, | |||
| qid = "", | |||
| skid = "", | |||
| patterns = [], | |||
| no_patterns = [] ) |
Create a Z3 exists formula.
The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> x = Int('x')
>>> y = Int('y')
>>> q = Exists([x, y], f(x, y) >= x, skid="foo")
>>> q
Exists([x, y], f(x, y) >= x)
>>> is_quantifier(q)
True
>>> r = Tactic('nnf')(q).as_expr()
>>> is_quantifier(r)
False
Definition at line 2342 of file z3py.py.
2342def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2343 """Create a Z3 exists formula.
2344
2345 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2346
2347
2348 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2349 >>> x = Int('x')
2350 >>> y = Int('y')
2351 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2352 >>> q
2353 Exists([x, y], f(x, y) >= x)
2354 >>> is_quantifier(q)
2355 True
2356 >>> r = Tactic('nnf')(q).as_expr()
2357 >>> is_quantifier(r)
2358 False
2359 """
2360 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2361
2362
◆ Ext()
| Ext | ( | a, | |
| b ) |
Return extensionality index for one-dimensional arrays.
>> a, b = Consts('a b', SetSort(IntSort()))
>> Ext(a, b)
Ext(a, b)
Definition at line 5002 of file z3py.py.
5002def Ext(a, b):
5003 """Return extensionality index for one-dimensional arrays.
5004 >> a, b = Consts('a b', SetSort(IntSort()))
5005 >> Ext(a, b)
5006 Ext(a, b)
5007 """
5008 ctx = a.ctx
5009 if z3_debug():
5010 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
5012
5013
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...
◆ Extract()
| Extract | ( | high, | |
| low, | |||
| a ) |
Create a Z3 bit-vector extraction expression or sequence extraction expression.
Extract is overloaded to work with both bit-vectors and sequences:
**Bit-vector extraction**: Extract(high, low, bitvector)
Extracts bits from position `high` down to position `low` (both inclusive).
- high: int - the highest bit position to extract (0-indexed from right)
- low: int - the lowest bit position to extract (0-indexed from right)
- bitvector: BitVecRef - the bit-vector to extract from
Returns a new bit-vector containing bits [high:low]
**Sequence extraction**: Extract(sequence, offset, length)
Extracts a subsequence starting at the given offset with the specified length.
The functions SubString and SubSeq are redirected to this form of Extract.
- sequence: SeqRef or str - the sequence to extract from
- offset: int - the starting position (0-indexed)
- length: int - the number of elements to extract
Returns a new sequence containing the extracted subsequence
>>> # Bit-vector extraction examples
>>> x = BitVec('x', 8)
>>> Extract(6, 2, x) # Extract bits 6 down to 2 (5 bits total)
Extract(6, 2, x)
>>> Extract(6, 2, x).sort() # Result is a 5-bit vector
BitVec(5)
>>> Extract(7, 0, x) # Extract all 8 bits
Extract(7, 0, x)
>>> Extract(3, 3, x) # Extract single bit at position 3
Extract(3, 3, x)
>>> # Sequence extraction examples
>>> s = StringVal("hello")
>>> Extract(s, 1, 3) # Extract 3 characters starting at position 1
str.substr("hello", 1, 3)
>>> simplify(Extract(StringVal("abcd"), 2, 1)) # Extract 1 character at position 2
"c"
>>> simplify(Extract(StringVal("abcd"), 0, 2)) # Extract first 2 characters
"ab"
Definition at line 4239 of file z3py.py.
4239def Extract(high, low, a):
4240 """Create a Z3 bit-vector extraction expression or sequence extraction expression.
4241
4242 Extract is overloaded to work with both bit-vectors and sequences:
4243
4244 **Bit-vector extraction**: Extract(high, low, bitvector)
4245 Extracts bits from position `high` down to position `low` (both inclusive).
4246 - high: int - the highest bit position to extract (0-indexed from right)
4247 - low: int - the lowest bit position to extract (0-indexed from right)
4248 - bitvector: BitVecRef - the bit-vector to extract from
4249 Returns a new bit-vector containing bits [high:low]
4250
4251 **Sequence extraction**: Extract(sequence, offset, length)
4252 Extracts a subsequence starting at the given offset with the specified length.
4253 The functions SubString and SubSeq are redirected to this form of Extract.
4254 - sequence: SeqRef or str - the sequence to extract from
4255 - offset: int - the starting position (0-indexed)
4256 - length: int - the number of elements to extract
4257 Returns a new sequence containing the extracted subsequence
4258
4259 >>> # Bit-vector extraction examples
4260 >>> x = BitVec('x', 8)
4261 >>> Extract(6, 2, x) # Extract bits 6 down to 2 (5 bits total)
4262 Extract(6, 2, x)
4263 >>> Extract(6, 2, x).sort() # Result is a 5-bit vector
4264 BitVec(5)
4265 >>> Extract(7, 0, x) # Extract all 8 bits
4266 Extract(7, 0, x)
4267 >>> Extract(3, 3, x) # Extract single bit at position 3
4268 Extract(3, 3, x)
4269
4270 >>> # Sequence extraction examples
4271 >>> s = StringVal("hello")
4272 >>> Extract(s, 1, 3) # Extract 3 characters starting at position 1
4273 str.substr("hello", 1, 3)
4274 >>> simplify(Extract(StringVal("abcd"), 2, 1)) # Extract 1 character at position 2
4275 "c"
4276 >>> simplify(Extract(StringVal("abcd"), 0, 2)) # Extract first 2 characters
4277 "ab"
4278 """
4279 if isinstance(high, str):
4280 high = StringVal(high)
4281 if is_seq(high):
4282 s = high
4283 offset, length = _coerce_exprs(low, a, s.ctx)
4284 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4285 if z3_debug():
4286 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4287 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4288 "First and second arguments must be non negative integers")
4289 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4291
4292
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_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.
◆ FailIf()
| FailIf | ( | p, | |
| ctx = None ) |
Return a tactic that fails if the probe `p` evaluates to true.
Otherwise, it returns the input goal unmodified.
In the following example, the tactic applies 'simplify' if and only if there are
more than 2 constraints in the goal.
>>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
>>> x, y = Ints('x y')
>>> g = Goal()
>>> g.add(x > 0)
>>> g.add(y > 0)
>>> t(g)
[[x > 0, y > 0]]
>>> g.add(x == y + 1)
>>> t(g)
[[Not(x <= 0), Not(y <= 0), x == 1 + y]]
Definition at line 9006 of file z3py.py.
9006def FailIf(p, ctx=None):
9007 """Return a tactic that fails if the probe `p` evaluates to true.
9008 Otherwise, it returns the input goal unmodified.
9009
9010 In the following example, the tactic applies 'simplify' if and only if there are
9011 more than 2 constraints in the goal.
9012
9013 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
9014 >>> x, y = Ints('x y')
9015 >>> g = Goal()
9016 >>> g.add(x > 0)
9017 >>> g.add(y > 0)
9018 >>> t(g)
9019 [[x > 0, y > 0]]
9020 >>> g.add(x == y + 1)
9021 >>> t(g)
9022 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9023 """
9024 p = _to_probe(p, ctx)
9026
9027
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.
◆ FiniteDomainSort()
| FiniteDomainSort | ( | name, | |
| sz, | |||
| ctx = None ) |
Create a named finite domain sort of a given size sz
Definition at line 7937 of file z3py.py.
7937def FiniteDomainSort(name, sz, ctx=None):
7938 """Create a named finite domain sort of a given size sz"""
7939 if not isinstance(name, Symbol):
7940 name = to_symbol(name)
7941 ctx = _get_ctx(ctx)
7943
7944
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.
◆ FiniteDomainVal()
| FiniteDomainVal | ( | val, | |
| sort, | |||
| ctx = None ) |
Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
>>> s = FiniteDomainSort('S', 256)
>>> FiniteDomainVal(255, s)
255
>>> FiniteDomainVal('100', s)
100
Definition at line 8007 of file z3py.py.
8007def FiniteDomainVal(val, sort, ctx=None):
8008 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
8009
8010 >>> s = FiniteDomainSort('S', 256)
8011 >>> FiniteDomainVal(255, s)
8012 255
8013 >>> FiniteDomainVal('100', s)
8014 100
8015 """
8016 if z3_debug():
8017 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
8018 ctx = sort.ctx
8020
8021
◆ Float128()
| Float128 | ( | ctx = None | ) |
Floating-point 128-bit (quadruple) sort.
Definition at line 9734 of file z3py.py.
9734def Float128(ctx=None):
9735 """Floating-point 128-bit (quadruple) sort."""
9736 ctx = _get_ctx(ctx)
9738
9739
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
◆ Float16()
| Float16 | ( | ctx = None | ) |
◆ Float32()
| Float32 | ( | ctx = None | ) |
◆ Float64()
| Float64 | ( | ctx = None | ) |
◆ FloatDouble()
| FloatDouble | ( | ctx = None | ) |
◆ FloatHalf()
| FloatHalf | ( | ctx = None | ) |
◆ FloatQuadruple()
| FloatQuadruple | ( | ctx = None | ) |
Floating-point 128-bit (quadruple) sort.
Definition at line 9740 of file z3py.py.
9740def FloatQuadruple(ctx=None):
9741 """Floating-point 128-bit (quadruple) sort."""
9742 ctx = _get_ctx(ctx)
9744
9745
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
◆ FloatSingle()
| FloatSingle | ( | ctx = None | ) |
◆ ForAll()
| ForAll | ( | vs, | |
| body, | |||
| weight = 1, | |||
| qid = "", | |||
| skid = "", | |||
| patterns = [], | |||
| no_patterns = [] ) |
Create a Z3 forall formula.
The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> x = Int('x')
>>> y = Int('y')
>>> ForAll([x, y], f(x, y) >= x)
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, weight=10)
ForAll([x, y], f(x, y) >= x)
Definition at line 2324 of file z3py.py.
2324def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2325 """Create a Z3 forall formula.
2326
2327 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2328
2329 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2330 >>> x = Int('x')
2331 >>> y = Int('y')
2332 >>> ForAll([x, y], f(x, y) >= x)
2333 ForAll([x, y], f(x, y) >= x)
2334 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2335 ForAll([x, y], f(x, y) >= x)
2336 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2337 ForAll([x, y], f(x, y) >= x)
2338 """
2339 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2340
2341
◆ FP()
| FP | ( | name, | |
| fpsort, | |||
| ctx = None ) |
Return a floating-point constant named `name`.
`fpsort` is the floating-point sort.
If `ctx=None`, then the global context is used.
>>> x = FP('x', FPSort(8, 24))
>>> is_fp(x)
True
>>> x.ebits()
8
>>> x.sort()
FPSort(8, 24)
>>> word = FPSort(8, 24)
>>> x2 = FP('x', word)
>>> eq(x, x2)
True
Definition at line 10376 of file z3py.py.
10376def FP(name, fpsort, ctx=None):
10377 """Return a floating-point constant named `name`.
10378 `fpsort` is the floating-point sort.
10379 If `ctx=None`, then the global context is used.
10380
10381 >>> x = FP('x', FPSort(8, 24))
10382 >>> is_fp(x)
10383 True
10384 >>> x.ebits()
10385 8
10386 >>> x.sort()
10387 FPSort(8, 24)
10388 >>> word = FPSort(8, 24)
10389 >>> x2 = FP('x', word)
10390 >>> eq(x, x2)
10391 True
10392 """
10393 if isinstance(fpsort, FPSortRef) and ctx is None:
10394 ctx = fpsort.ctx
10395 else:
10396 ctx = _get_ctx(ctx)
10398
10399
◆ fpAbs()
| fpAbs | ( | a, | |
| ctx = None ) |
Create a Z3 floating-point absolute value expression. >>> s = FPSort(8, 24) >>> rm = RNE() >>> x = FPVal(1.0, s) >>> fpAbs(x) fpAbs(1) >>> y = FPVal(-20.0, s) >>> y -1.25*(2**4) >>> fpAbs(y) fpAbs(-1.25*(2**4)) >>> fpAbs(-1.25*(2**4)) fpAbs(-1.25*(2**4)) >>> fpAbs(x).sort() FPSort(8, 24)
Definition at line 10419 of file z3py.py.
10419def fpAbs(a, ctx=None):
10420 """Create a Z3 floating-point absolute value expression.
10421
10422 >>> s = FPSort(8, 24)
10423 >>> rm = RNE()
10424 >>> x = FPVal(1.0, s)
10425 >>> fpAbs(x)
10426 fpAbs(1)
10427 >>> y = FPVal(-20.0, s)
10428 >>> y
10429 -1.25*(2**4)
10430 >>> fpAbs(y)
10431 fpAbs(-1.25*(2**4))
10432 >>> fpAbs(-1.25*(2**4))
10433 fpAbs(-1.25*(2**4))
10434 >>> fpAbs(x).sort()
10435 FPSort(8, 24)
10436 """
10437 ctx = _get_ctx(ctx)
10438 [a] = _coerce_fp_expr_list([a], ctx)
10440
10441
◆ fpAdd()
| fpAdd | ( | rm, | |
| a, | |||
| b, | |||
| ctx = None ) |
Create a Z3 floating-point addition expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpAdd(rm, x, y)
x + y
>>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
fpAdd(RTZ(), x, y)
>>> fpAdd(rm, x, y).sort()
FPSort(8, 24)
Definition at line 10510 of file z3py.py.
10510def fpAdd(rm, a, b, ctx=None):
10511 """Create a Z3 floating-point addition expression.
10512
10513 >>> s = FPSort(8, 24)
10514 >>> rm = RNE()
10515 >>> x = FP('x', s)
10516 >>> y = FP('y', s)
10517 >>> fpAdd(rm, x, y)
10518 x + y
10519 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10520 fpAdd(RTZ(), x, y)
10521 >>> fpAdd(rm, x, y).sort()
10522 FPSort(8, 24)
10523 """
10524 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10525
10526
◆ fpBVToFP()
| fpBVToFP | ( | v, | |
| sort, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression that represents the conversion from a bit-vector term to a floating-point term. >>> x_bv = BitVecVal(0x3F800000, 32) >>> x_fp = fpBVToFP(x_bv, Float32()) >>> x_fp fpToFP(1065353216) >>> simplify(x_fp) 1
Definition at line 10832 of file z3py.py.
10832def fpBVToFP(v, sort, ctx=None):
10833 """Create a Z3 floating-point conversion expression that represents the
10834 conversion from a bit-vector term to a floating-point term.
10835
10836 >>> x_bv = BitVecVal(0x3F800000, 32)
10837 >>> x_fp = fpBVToFP(x_bv, Float32())
10838 >>> x_fp
10839 fpToFP(1065353216)
10840 >>> simplify(x_fp)
10841 1
10842 """
10843 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10844 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10845 ctx = _get_ctx(ctx)
10847
10848
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.
◆ fpDiv()
| fpDiv | ( | rm, | |
| a, | |||
| b, | |||
| ctx = None ) |
Create a Z3 floating-point division expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpDiv(rm, x, y)
x / y
>>> fpDiv(rm, x, y).sort()
FPSort(8, 24)
Definition at line 10557 of file z3py.py.
10557def fpDiv(rm, a, b, ctx=None):
10558 """Create a Z3 floating-point division expression.
10559
10560 >>> s = FPSort(8, 24)
10561 >>> rm = RNE()
10562 >>> x = FP('x', s)
10563 >>> y = FP('y', s)
10564 >>> fpDiv(rm, x, y)
10565 x / y
10566 >>> fpDiv(rm, x, y).sort()
10567 FPSort(8, 24)
10568 """
10569 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10570
10571
◆ fpEQ()
| fpEQ | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `fpEQ(other, self)`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpEQ(x, y)
fpEQ(x, y)
>>> fpEQ(x, y).sexpr()
'(fp.eq x y)'
Definition at line 10740 of file z3py.py.
10740def fpEQ(a, b, ctx=None):
10741 """Create the Z3 floating-point expression `fpEQ(other, self)`.
10742
10743 >>> x, y = FPs('x y', FPSort(8, 24))
10744 >>> fpEQ(x, y)
10745 fpEQ(x, y)
10746 >>> fpEQ(x, y).sexpr()
10747 '(fp.eq x y)'
10748 """
10749 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10750
10751
◆ fpFMA()
| fpFMA | ( | rm, | |
| a, | |||
| b, | |||
| c, | |||
| ctx = None ) |
◆ fpFP()
| fpFP | ( | sgn, | |
| exp, | |||
| sig, | |||
| ctx = None ) |
Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp. >>> s = FPSort(8, 24) >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23)) >>> print(x) fpFP(1, 127, 4194304) >>> xv = FPVal(-1.5, s) >>> print(xv) -1.5 >>> slvr = Solver() >>> slvr.add(fpEQ(x, xv)) >>> slvr.check() sat >>> xv = FPVal(+1.5, s) >>> print(xv) 1.5 >>> slvr = Solver() >>> slvr.add(fpEQ(x, xv)) >>> slvr.check() unsat
Definition at line 10764 of file z3py.py.
10764def fpFP(sgn, exp, sig, ctx=None):
10765 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10766
10767 >>> s = FPSort(8, 24)
10768 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10769 >>> print(x)
10770 fpFP(1, 127, 4194304)
10771 >>> xv = FPVal(-1.5, s)
10772 >>> print(xv)
10773 -1.5
10774 >>> slvr = Solver()
10775 >>> slvr.add(fpEQ(x, xv))
10776 >>> slvr.check()
10777 sat
10778 >>> xv = FPVal(+1.5, s)
10779 >>> print(xv)
10780 1.5
10781 >>> slvr = Solver()
10782 >>> slvr.add(fpEQ(x, xv))
10783 >>> slvr.check()
10784 unsat
10785 """
10786 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10787 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10788 ctx = _get_ctx(ctx)
10789 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10790 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10791
10792
◆ fpFPToFP()
| fpFPToFP | ( | rm, | |
| v, | |||
| sort, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression that represents the conversion from a floating-point term to a floating-point term of different precision. >>> x_sgl = FPVal(1.0, Float32()) >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64()) >>> x_dbl fpToFP(RNE(), 1) >>> simplify(x_dbl) 1 >>> x_dbl.sort() FPSort(11, 53)
Definition at line 10849 of file z3py.py.
10849def fpFPToFP(rm, v, sort, ctx=None):
10850 """Create a Z3 floating-point conversion expression that represents the
10851 conversion from a floating-point term to a floating-point term of different precision.
10852
10853 >>> x_sgl = FPVal(1.0, Float32())
10854 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10855 >>> x_dbl
10856 fpToFP(RNE(), 1)
10857 >>> simplify(x_dbl)
10858 1
10859 >>> x_dbl.sort()
10860 FPSort(11, 53)
10861 """
10862 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10863 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10864 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10865 ctx = _get_ctx(ctx)
10867
10868
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.
◆ fpGEQ()
| fpGEQ | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `other >= self`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpGEQ(x, y)
x >= y
>>> (x >= y).sexpr()
'(fp.geq x y)'
Definition at line 10728 of file z3py.py.
10728def fpGEQ(a, b, ctx=None):
10729 """Create the Z3 floating-point expression `other >= self`.
10730
10731 >>> x, y = FPs('x y', FPSort(8, 24))
10732 >>> fpGEQ(x, y)
10733 x >= y
10734 >>> (x >= y).sexpr()
10735 '(fp.geq x y)'
10736 """
10737 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10738
10739
◆ fpGT()
| fpGT | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `other > self`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpGT(x, y)
x > y
>>> (x > y).sexpr()
'(fp.gt x y)'
Definition at line 10716 of file z3py.py.
10716def fpGT(a, b, ctx=None):
10717 """Create the Z3 floating-point expression `other > self`.
10718
10719 >>> x, y = FPs('x y', FPSort(8, 24))
10720 >>> fpGT(x, y)
10721 x > y
10722 >>> (x > y).sexpr()
10723 '(fp.gt x y)'
10724 """
10725 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10726
10727
◆ fpInfinity()
| fpInfinity | ( | s, | |
| negative ) |
Create a Z3 floating-point +oo or -oo term.
Definition at line 10304 of file z3py.py.
10304def fpInfinity(s, negative):
10305 """Create a Z3 floating-point +oo or -oo term."""
10306 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10307 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10309
10310
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
◆ fpIsInf()
| fpIsInf | ( | a, | |
| ctx = None ) |
Create a Z3 floating-point isInfinite expression.
>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> fpIsInf(x)
fpIsInf(x)
Definition at line 10646 of file z3py.py.
10646def fpIsInf(a, ctx=None):
10647 """Create a Z3 floating-point isInfinite expression.
10648
10649 >>> s = FPSort(8, 24)
10650 >>> x = FP('x', s)
10651 >>> fpIsInf(x)
10652 fpIsInf(x)
10653 """
10654 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10655
10656
◆ fpIsNaN()
| fpIsNaN | ( | a, | |
| ctx = None ) |
Create a Z3 floating-point isNaN expression.
>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpIsNaN(x)
fpIsNaN(x)
Definition at line 10634 of file z3py.py.
10634def fpIsNaN(a, ctx=None):
10635 """Create a Z3 floating-point isNaN expression.
10636
10637 >>> s = FPSort(8, 24)
10638 >>> x = FP('x', s)
10639 >>> y = FP('y', s)
10640 >>> fpIsNaN(x)
10641 fpIsNaN(x)
10642 """
10643 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10644
10645
◆ fpIsNegative()
| fpIsNegative | ( | a, | |
| ctx = None ) |
◆ fpIsNormal()
| fpIsNormal | ( | a, | |
| ctx = None ) |
◆ fpIsPositive()
| fpIsPositive | ( | a, | |
| ctx = None ) |
◆ fpIsSubnormal()
| fpIsSubnormal | ( | a, | |
| ctx = None ) |
◆ fpIsZero()
| fpIsZero | ( | a, | |
| ctx = None ) |
◆ fpLEQ()
| fpLEQ | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `other <= self`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpLEQ(x, y)
x <= y
>>> (x <= y).sexpr()
'(fp.leq x y)'
Definition at line 10704 of file z3py.py.
10704def fpLEQ(a, b, ctx=None):
10705 """Create the Z3 floating-point expression `other <= self`.
10706
10707 >>> x, y = FPs('x y', FPSort(8, 24))
10708 >>> fpLEQ(x, y)
10709 x <= y
10710 >>> (x <= y).sexpr()
10711 '(fp.leq x y)'
10712 """
10713 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10714
10715
◆ fpLT()
| fpLT | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `other < self`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpLT(x, y)
x < y
>>> (x < y).sexpr()
'(fp.lt x y)'
Definition at line 10692 of file z3py.py.
10692def fpLT(a, b, ctx=None):
10693 """Create the Z3 floating-point expression `other < self`.
10694
10695 >>> x, y = FPs('x y', FPSort(8, 24))
10696 >>> fpLT(x, y)
10697 x < y
10698 >>> (x < y).sexpr()
10699 '(fp.lt x y)'
10700 """
10701 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10702
10703
◆ fpMax()
| fpMax | ( | a, | |
| b, | |||
| ctx = None ) |
Create a Z3 floating-point maximum expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpMax(x, y)
fpMax(x, y)
>>> fpMax(x, y).sort()
FPSort(8, 24)
Definition at line 10601 of file z3py.py.
10601def fpMax(a, b, ctx=None):
10602 """Create a Z3 floating-point maximum expression.
10603
10604 >>> s = FPSort(8, 24)
10605 >>> rm = RNE()
10606 >>> x = FP('x', s)
10607 >>> y = FP('y', s)
10608 >>> fpMax(x, y)
10609 fpMax(x, y)
10610 >>> fpMax(x, y).sort()
10611 FPSort(8, 24)
10612 """
10613 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10614
10615
◆ fpMin()
| fpMin | ( | a, | |
| b, | |||
| ctx = None ) |
Create a Z3 floating-point minimum expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpMin(x, y)
fpMin(x, y)
>>> fpMin(x, y).sort()
FPSort(8, 24)
Definition at line 10586 of file z3py.py.
10586def fpMin(a, b, ctx=None):
10587 """Create a Z3 floating-point minimum expression.
10588
10589 >>> s = FPSort(8, 24)
10590 >>> rm = RNE()
10591 >>> x = FP('x', s)
10592 >>> y = FP('y', s)
10593 >>> fpMin(x, y)
10594 fpMin(x, y)
10595 >>> fpMin(x, y).sort()
10596 FPSort(8, 24)
10597 """
10598 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10599
10600
◆ fpMinusInfinity()
| fpMinusInfinity | ( | s | ) |
◆ fpMinusZero()
| fpMinusZero | ( | s | ) |
Create a Z3 floating-point -0.0 term.
Definition at line 10317 of file z3py.py.
10317def fpMinusZero(s):
10318 """Create a Z3 floating-point -0.0 term."""
10319 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10321
10322
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
◆ fpMul()
| fpMul | ( | rm, | |
| a, | |||
| b, | |||
| ctx = None ) |
Create a Z3 floating-point multiplication expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpMul(rm, x, y)
x * y
>>> fpMul(rm, x, y).sort()
FPSort(8, 24)
Definition at line 10542 of file z3py.py.
10542def fpMul(rm, a, b, ctx=None):
10543 """Create a Z3 floating-point multiplication expression.
10544
10545 >>> s = FPSort(8, 24)
10546 >>> rm = RNE()
10547 >>> x = FP('x', s)
10548 >>> y = FP('y', s)
10549 >>> fpMul(rm, x, y)
10550 x * y
10551 >>> fpMul(rm, x, y).sort()
10552 FPSort(8, 24)
10553 """
10554 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10555
10556
◆ fpNaN()
| fpNaN | ( | s | ) |
Create a Z3 floating-point NaN term. >>> s = FPSort(8, 24) >>> set_fpa_pretty(True) >>> fpNaN(s) NaN >>> pb = get_fpa_pretty() >>> set_fpa_pretty(False) >>> fpNaN(s) fpNaN(FPSort(8, 24)) >>> set_fpa_pretty(pb)
Definition at line 10264 of file z3py.py.
10264def fpNaN(s):
10265 """Create a Z3 floating-point NaN term.
10266
10267 >>> s = FPSort(8, 24)
10268 >>> set_fpa_pretty(True)
10269 >>> fpNaN(s)
10270 NaN
10271 >>> pb = get_fpa_pretty()
10272 >>> set_fpa_pretty(False)
10273 >>> fpNaN(s)
10274 fpNaN(FPSort(8, 24))
10275 >>> set_fpa_pretty(pb)
10276 """
10277 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10279
10280
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
◆ fpNeg()
| fpNeg | ( | a, | |
| ctx = None ) |
Create a Z3 floating-point addition expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> fpNeg(x)
-x
>>> fpNeg(x).sort()
FPSort(8, 24)
Definition at line 10442 of file z3py.py.
10442def fpNeg(a, ctx=None):
10443 """Create a Z3 floating-point addition expression.
10444
10445 >>> s = FPSort(8, 24)
10446 >>> rm = RNE()
10447 >>> x = FP('x', s)
10448 >>> fpNeg(x)
10449 -x
10450 >>> fpNeg(x).sort()
10451 FPSort(8, 24)
10452 """
10453 ctx = _get_ctx(ctx)
10454 [a] = _coerce_fp_expr_list([a], ctx)
10456
10457
◆ fpNEQ()
| fpNEQ | ( | a, | |
| b, | |||
| ctx = None ) |
Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpNEQ(x, y)
Not(fpEQ(x, y))
>>> (x != y).sexpr()
'(distinct x y)'
Definition at line 10752 of file z3py.py.
10752def fpNEQ(a, b, ctx=None):
10753 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10754
10755 >>> x, y = FPs('x y', FPSort(8, 24))
10756 >>> fpNEQ(x, y)
10757 Not(fpEQ(x, y))
10758 >>> (x != y).sexpr()
10759 '(distinct x y)'
10760 """
10761 return Not(fpEQ(a, b, ctx))
10762
10763
◆ fpPlusInfinity()
| fpPlusInfinity | ( | s | ) |
Create a Z3 floating-point +oo term. >>> s = FPSort(8, 24) >>> pb = get_fpa_pretty() >>> set_fpa_pretty(True) >>> fpPlusInfinity(s) +oo >>> set_fpa_pretty(False) >>> fpPlusInfinity(s) fpPlusInfinity(FPSort(8, 24)) >>> set_fpa_pretty(pb)
Definition at line 10281 of file z3py.py.
10281def fpPlusInfinity(s):
10282 """Create a Z3 floating-point +oo term.
10283
10284 >>> s = FPSort(8, 24)
10285 >>> pb = get_fpa_pretty()
10286 >>> set_fpa_pretty(True)
10287 >>> fpPlusInfinity(s)
10288 +oo
10289 >>> set_fpa_pretty(False)
10290 >>> fpPlusInfinity(s)
10291 fpPlusInfinity(FPSort(8, 24))
10292 >>> set_fpa_pretty(pb)
10293 """
10294 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10296
10297
◆ fpPlusZero()
| fpPlusZero | ( | s | ) |
◆ fpRealToFP()
| fpRealToFP | ( | rm, | |
| v, | |||
| sort, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression that represents the conversion from a real term to a floating-point term. >>> x_r = RealVal(1.5) >>> x_fp = fpRealToFP(RNE(), x_r, Float32()) >>> x_fp fpToFP(RNE(), 3/2) >>> simplify(x_fp) 1.5
Definition at line 10869 of file z3py.py.
10869def fpRealToFP(rm, v, sort, ctx=None):
10870 """Create a Z3 floating-point conversion expression that represents the
10871 conversion from a real term to a floating-point term.
10872
10873 >>> x_r = RealVal(1.5)
10874 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10875 >>> x_fp
10876 fpToFP(RNE(), 3/2)
10877 >>> simplify(x_fp)
10878 1.5
10879 """
10880 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10881 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10882 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10883 ctx = _get_ctx(ctx)
10885
10886
Z3_ast Z3_API Z3_mk_fpa_to_fp_real(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a term of real sort into a term of FloatingPoint sort.
◆ fpRem()
| fpRem | ( | a, | |
| b, | |||
| ctx = None ) |
Create a Z3 floating-point remainder expression.
>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpRem(x, y)
fpRem(x, y)
>>> fpRem(x, y).sort()
FPSort(8, 24)
Definition at line 10572 of file z3py.py.
10572def fpRem(a, b, ctx=None):
10573 """Create a Z3 floating-point remainder expression.
10574
10575 >>> s = FPSort(8, 24)
10576 >>> x = FP('x', s)
10577 >>> y = FP('y', s)
10578 >>> fpRem(x, y)
10579 fpRem(x, y)
10580 >>> fpRem(x, y).sort()
10581 FPSort(8, 24)
10582 """
10583 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10584
10585
◆ fpRoundToIntegral()
| fpRoundToIntegral | ( | rm, | |
| a, | |||
| ctx = None ) |
◆ FPs()
| FPs | ( | names, | |
| fpsort, | |||
| ctx = None ) |
Return an array of floating-point constants.
>>> x, y, z = FPs('x y z', FPSort(8, 24))
>>> x.sort()
FPSort(8, 24)
>>> x.sbits()
24
>>> x.ebits()
8
>>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
(x + y) * z
Definition at line 10400 of file z3py.py.
10400def FPs(names, fpsort, ctx=None):
10401 """Return an array of floating-point constants.
10402
10403 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10404 >>> x.sort()
10405 FPSort(8, 24)
10406 >>> x.sbits()
10407 24
10408 >>> x.ebits()
10409 8
10410 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10411 (x + y) * z
10412 """
10413 ctx = _get_ctx(ctx)
10414 if isinstance(names, str):
10415 names = names.split(" ")
10416 return [FP(name, fpsort, ctx) for name in names]
10417
10418
◆ fpSignedToFP()
| fpSignedToFP | ( | rm, | |
| v, | |||
| sort, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression that represents the conversion from a signed bit-vector term (encoding an integer) to a floating-point term. >>> x_signed = BitVecVal(-5, BitVecSort(32)) >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32()) >>> x_fp fpToFP(RNE(), 4294967291) >>> simplify(x_fp) -1.25*(2**2)
Definition at line 10887 of file z3py.py.
10887def fpSignedToFP(rm, v, sort, ctx=None):
10888 """Create a Z3 floating-point conversion expression that represents the
10889 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10890
10891 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10892 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10893 >>> x_fp
10894 fpToFP(RNE(), 4294967291)
10895 >>> simplify(x_fp)
10896 -1.25*(2**2)
10897 """
10898 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10899 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10900 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10901 ctx = _get_ctx(ctx)
10903
10904
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.
◆ FPSort()
| FPSort | ( | ebits, | |
| sbits, | |||
| ctx = None ) |
Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
>>> Single = FPSort(8, 24)
>>> Double = FPSort(11, 53)
>>> Single
FPSort(8, 24)
>>> x = Const('x', Single)
>>> eq(x, FP('x', FPSort(8, 24)))
True
Definition at line 10205 of file z3py.py.
10205def FPSort(ebits, sbits, ctx=None):
10206 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10207
10208 >>> Single = FPSort(8, 24)
10209 >>> Double = FPSort(11, 53)
10210 >>> Single
10211 FPSort(8, 24)
10212 >>> x = Const('x', Single)
10213 >>> eq(x, FP('x', FPSort(8, 24)))
10214 True
10215 """
10216 ctx = _get_ctx(ctx)
10218
10219
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
◆ fpSqrt()
| fpSqrt | ( | rm, | |
| a, | |||
| ctx = None ) |
◆ fpSub()
| fpSub | ( | rm, | |
| a, | |||
| b, | |||
| ctx = None ) |
Create a Z3 floating-point subtraction expression.
>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpSub(rm, x, y)
x - y
>>> fpSub(rm, x, y).sort()
FPSort(8, 24)
Definition at line 10527 of file z3py.py.
10527def fpSub(rm, a, b, ctx=None):
10528 """Create a Z3 floating-point subtraction expression.
10529
10530 >>> s = FPSort(8, 24)
10531 >>> rm = RNE()
10532 >>> x = FP('x', s)
10533 >>> y = FP('y', s)
10534 >>> fpSub(rm, x, y)
10535 x - y
10536 >>> fpSub(rm, x, y).sort()
10537 FPSort(8, 24)
10538 """
10539 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10540
10541
◆ fpToFP()
| fpToFP | ( | a1, | |
| a2 = None, | |||
| a3 = None, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression from other term sorts to floating-point. From a bit-vector term in IEEE 754-2008 format: >>> x = FPVal(1.0, Float32()) >>> x_bv = fpToIEEEBV(x) >>> simplify(fpToFP(x_bv, Float32())) 1 From a floating-point term with different precision: >>> x = FPVal(1.0, Float32()) >>> x_db = fpToFP(RNE(), x, Float64()) >>> x_db.sort() FPSort(11, 53) From a real term: >>> x_r = RealVal(1.5) >>> simplify(fpToFP(RNE(), x_r, Float32())) 1.5 From a signed bit-vector term: >>> x_signed = BitVecVal(-5, BitVecSort(32)) >>> simplify(fpToFP(RNE(), x_signed, Float32())) -1.25*(2**2)
Definition at line 10793 of file z3py.py.
10793def fpToFP(a1, a2=None, a3=None, ctx=None):
10794 """Create a Z3 floating-point conversion expression from other term sorts
10795 to floating-point.
10796
10797 From a bit-vector term in IEEE 754-2008 format:
10798 >>> x = FPVal(1.0, Float32())
10799 >>> x_bv = fpToIEEEBV(x)
10800 >>> simplify(fpToFP(x_bv, Float32()))
10801 1
10802
10803 From a floating-point term with different precision:
10804 >>> x = FPVal(1.0, Float32())
10805 >>> x_db = fpToFP(RNE(), x, Float64())
10806 >>> x_db.sort()
10807 FPSort(11, 53)
10808
10809 From a real term:
10810 >>> x_r = RealVal(1.5)
10811 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10812 1.5
10813
10814 From a signed bit-vector term:
10815 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10816 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10817 -1.25*(2**2)
10818 """
10819 ctx = _get_ctx(ctx)
10820 if is_bv(a1) and is_fp_sort(a2):
10822 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10824 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10826 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10828 else:
10829 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10830
10831
◆ fpToFPUnsigned()
| fpToFPUnsigned | ( | rm, | |
| x, | |||
| s, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression.
Definition at line 10923 of file z3py.py.
10923def fpToFPUnsigned(rm, x, s, ctx=None):
10924 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10925 if z3_debug():
10926 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10927 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10928 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10929 ctx = _get_ctx(ctx)
10931
10932
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.
◆ fpToIEEEBV()
| fpToIEEEBV | ( | x, | |
| ctx = None ) |
\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
The size of the resulting bit-vector is automatically determined.
Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
knows only one NaN and it will always produce the same bit-vector representation of
that NaN.
>>> x = FP('x', FPSort(8, 24))
>>> y = fpToIEEEBV(x)
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False
Definition at line 10997 of file z3py.py.
10997def fpToIEEEBV(x, ctx=None):
10998 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10999
11000 The size of the resulting bit-vector is automatically determined.
11001
11002 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
11003 knows only one NaN and it will always produce the same bit-vector representation of
11004 that NaN.
11005
11006 >>> x = FP('x', FPSort(8, 24))
11007 >>> y = fpToIEEEBV(x)
11008 >>> print(is_fp(x))
11009 True
11010 >>> print(is_bv(y))
11011 True
11012 >>> print(is_fp(y))
11013 False
11014 >>> print(is_bv(x))
11015 False
11016 """
11017 if z3_debug():
11018 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
11019 ctx = _get_ctx(ctx)
11021
11022
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.
◆ fpToReal()
| fpToReal | ( | x, | |
| ctx = None ) |
Create a Z3 floating-point conversion expression, from floating-point expression to real.
>>> x = FP('x', FPSort(8, 24))
>>> y = fpToReal(x)
>>> print(is_fp(x))
True
>>> print(is_real(y))
True
>>> print(is_fp(y))
False
>>> print(is_real(x))
False
Definition at line 10977 of file z3py.py.
10977def fpToReal(x, ctx=None):
10978 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10979
10980 >>> x = FP('x', FPSort(8, 24))
10981 >>> y = fpToReal(x)
10982 >>> print(is_fp(x))
10983 True
10984 >>> print(is_real(y))
10985 True
10986 >>> print(is_fp(y))
10987 False
10988 >>> print(is_real(x))
10989 False
10990 """
10991 if z3_debug():
10992 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10993 ctx = _get_ctx(ctx)
10995
10996
Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a real-numbered term.
◆ fpToSBV()
| fpToSBV | ( | rm, | |
| x, | |||
| s, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
>>> x = FP('x', FPSort(8, 24))
>>> y = fpToSBV(RTZ(), x, BitVecSort(32))
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False
Definition at line 10933 of file z3py.py.
10933def fpToSBV(rm, x, s, ctx=None):
10934 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10935
10936 >>> x = FP('x', FPSort(8, 24))
10937 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10938 >>> print(is_fp(x))
10939 True
10940 >>> print(is_bv(y))
10941 True
10942 >>> print(is_fp(y))
10943 False
10944 >>> print(is_bv(x))
10945 False
10946 """
10947 if z3_debug():
10948 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10949 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10950 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10951 ctx = _get_ctx(ctx)
10953
10954
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.
◆ fpToUBV()
| fpToUBV | ( | rm, | |
| x, | |||
| s, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
>>> x = FP('x', FPSort(8, 24))
>>> y = fpToUBV(RTZ(), x, BitVecSort(32))
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False
Definition at line 10955 of file z3py.py.
10955def fpToUBV(rm, x, s, ctx=None):
10956 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10957
10958 >>> x = FP('x', FPSort(8, 24))
10959 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10960 >>> print(is_fp(x))
10961 True
10962 >>> print(is_bv(y))
10963 True
10964 >>> print(is_fp(y))
10965 False
10966 >>> print(is_bv(x))
10967 False
10968 """
10969 if z3_debug():
10970 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10971 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10972 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10973 ctx = _get_ctx(ctx)
10975
10976
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.
◆ fpUnsignedToFP()
| fpUnsignedToFP | ( | rm, | |
| v, | |||
| sort, | |||
| ctx = None ) |
Create a Z3 floating-point conversion expression that represents the conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term. >>> x_signed = BitVecVal(-5, BitVecSort(32)) >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32()) >>> x_fp fpToFPUnsigned(RNE(), 4294967291) >>> simplify(x_fp) 1*(2**32)
Definition at line 10905 of file z3py.py.
10905def fpUnsignedToFP(rm, v, sort, ctx=None):
10906 """Create a Z3 floating-point conversion expression that represents the
10907 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10908
10909 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10910 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10911 >>> x_fp
10912 fpToFPUnsigned(RNE(), 4294967291)
10913 >>> simplify(x_fp)
10914 1*(2**32)
10915 """
10916 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10917 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10918 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10919 ctx = _get_ctx(ctx)
10921
10922
◆ FPVal()
| FPVal | ( | sig, | |
| exp = None, | |||
| fps = None, | |||
| ctx = None ) |
Return a floating-point value of value `val` and sort `fps`.
If `ctx=None`, then the global context is used.
>>> v = FPVal(20.0, FPSort(8, 24))
>>> v
1.25*(2**4)
>>> print("0x%.8x" % v.exponent_as_long(False))
0x00000004
>>> v = FPVal(2.25, FPSort(8, 24))
>>> v
1.125*(2**1)
>>> v = FPVal(-2.25, FPSort(8, 24))
>>> v
-1.125*(2**1)
>>> FPVal(-0.0, FPSort(8, 24))
-0.0
>>> FPVal(0.0, FPSort(8, 24))
+0.0
>>> FPVal(+0.0, FPSort(8, 24))
+0.0
Definition at line 10330 of file z3py.py.
10330def FPVal(sig, exp=None, fps=None, ctx=None):
10331 """Return a floating-point value of value `val` and sort `fps`.
10332 If `ctx=None`, then the global context is used.
10333
10334 >>> v = FPVal(20.0, FPSort(8, 24))
10335 >>> v
10336 1.25*(2**4)
10337 >>> print("0x%.8x" % v.exponent_as_long(False))
10338 0x00000004
10339 >>> v = FPVal(2.25, FPSort(8, 24))
10340 >>> v
10341 1.125*(2**1)
10342 >>> v = FPVal(-2.25, FPSort(8, 24))
10343 >>> v
10344 -1.125*(2**1)
10345 >>> FPVal(-0.0, FPSort(8, 24))
10346 -0.0
10347 >>> FPVal(0.0, FPSort(8, 24))
10348 +0.0
10349 >>> FPVal(+0.0, FPSort(8, 24))
10350 +0.0
10351 """
10352 ctx = _get_ctx(ctx)
10353 if is_fp_sort(exp):
10354 fps = exp
10355 exp = None
10356 elif fps is None:
10357 fps = _dflt_fps(ctx)
10358 _z3_assert(is_fp_sort(fps), "sort mismatch")
10359 if exp is None:
10360 exp = 0
10361 val = _to_float_str(sig)
10362 if val == "NaN" or val == "nan":
10363 return fpNaN(fps)
10364 elif val == "-0.0":
10365 return fpMinusZero(fps)
10366 elif val == "0.0" or val == "+0.0":
10367 return fpPlusZero(fps)
10368 elif val == "+oo" or val == "+inf" or val == "+Inf":
10369 return fpPlusInfinity(fps)
10370 elif val == "-oo" or val == "-inf" or val == "-Inf":
10371 return fpMinusInfinity(fps)
10372 else:
10374
10375
◆ fpZero()
| fpZero | ( | s, | |
| negative ) |
Create a Z3 floating-point +0.0 or -0.0 term.
Definition at line 10323 of file z3py.py.
10323def fpZero(s, negative):
10324 """Create a Z3 floating-point +0.0 or -0.0 term."""
10325 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10326 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10328
10329
◆ FreshBool()
| FreshBool | ( | prefix = "b", | |
| ctx = None ) |
Return a fresh Boolean constant in the given context using the given prefix. If `ctx=None`, then the global context is used. >>> b1 = FreshBool() >>> b2 = FreshBool() >>> eq(b1, b2) False
Definition at line 1863 of file z3py.py.
1863def FreshBool(prefix="b", ctx=None):
1864 """Return a fresh Boolean constant in the given context using the given prefix.
1865
1866 If `ctx=None`, then the global context is used.
1867
1868 >>> b1 = FreshBool()
1869 >>> b2 = FreshBool()
1870 >>> eq(b1, b2)
1871 False
1872 """
1873 ctx = _get_ctx(ctx)
1875
1876
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
◆ FreshConst()
| FreshConst | ( | sort, | |
| prefix = "c" ) |
Create a fresh constant of a specified sort
Definition at line 1526 of file z3py.py.
1526def FreshConst(sort, prefix="c"):
1527 """Create a fresh constant of a specified sort"""
1528 if z3_debug():
1529 _z3_assert(is_sort(sort), f"Z3 sort expected, got {type(sort)}")
1530 ctx = _get_ctx(sort.ctx)
1532
1533
◆ FreshFunction()
| FreshFunction | ( | * | sig | ) |
Create a new fresh Z3 uninterpreted function with the given sorts.
Definition at line 926 of file z3py.py.
926def FreshFunction(*sig):
927 """Create a new fresh Z3 uninterpreted function with the given sorts.
928 """
929 sig = _get_args(sig)
930 if z3_debug():
931 _z3_assert(len(sig) > 0, "At least two arguments expected")
932 arity = len(sig) - 1
933 rng = sig[arity]
934 if z3_debug():
935 _z3_assert(is_sort(rng), "Z3 sort expected")
936 dom = (z3.Sort * arity)()
937 for i in range(arity):
938 if z3_debug():
939 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
940 dom[i] = sig[i].ast
941 ctx = rng.ctx
943
944
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.
◆ FreshInt()
| FreshInt | ( | prefix = "x", | |
| ctx = None ) |
Return a fresh integer constant in the given context using the given prefix. >>> x = FreshInt() >>> y = FreshInt() >>> eq(x, y) False >>> x.sort() Int
Definition at line 3391 of file z3py.py.
3391def FreshInt(prefix="x", ctx=None):
3392 """Return a fresh integer constant in the given context using the given prefix.
3393
3394 >>> x = FreshInt()
3395 >>> y = FreshInt()
3396 >>> eq(x, y)
3397 False
3398 >>> x.sort()
3399 Int
3400 """
3401 ctx = _get_ctx(ctx)
3403
3404
◆ FreshReal()
| FreshReal | ( | prefix = "b", | |
| ctx = None ) |
Return a fresh real constant in the given context using the given prefix. >>> x = FreshReal() >>> y = FreshReal() >>> eq(x, y) False >>> x.sort() Real
Definition at line 3448 of file z3py.py.
3448def FreshReal(prefix="b", ctx=None):
3449 """Return a fresh real constant in the given context using the given prefix.
3450
3451 >>> x = FreshReal()
3452 >>> y = FreshReal()
3453 >>> eq(x, y)
3454 False
3455 >>> x.sort()
3456 Real
3457 """
3458 ctx = _get_ctx(ctx)
3460
3461
◆ Full()
| Full | ( | s | ) |
Create the regular expression that accepts the universal language >>> e = Full(ReSort(SeqSort(IntSort()))) >>> print(e) Full(ReSort(Seq(Int))) >>> e1 = Full(ReSort(StringSort())) >>> print(e1) Full(ReSort(String))
Definition at line 11300 of file z3py.py.
11300def Full(s):
11301 """Create the regular expression that accepts the universal language
11302 >>> e = Full(ReSort(SeqSort(IntSort())))
11303 >>> print(e)
11304 Full(ReSort(Seq(Int)))
11305 >>> e1 = Full(ReSort(StringSort()))
11306 >>> print(e1)
11307 Full(ReSort(String))
11308 """
11309 if isinstance(s, ReSortRef):
11311 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11312
11313
11314
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
◆ FullSet()
| FullSet | ( | s | ) |
◆ Function()
| Function | ( | name, | |
| * | sig ) |
Create a new Z3 uninterpreted function with the given sorts.
>>> f = Function('f', IntSort(), IntSort())
>>> f(f(0))
f(f(0))
Definition at line 903 of file z3py.py.
903def Function(name, *sig):
904 """Create a new Z3 uninterpreted function with the given sorts.
905
906 >>> f = Function('f', IntSort(), IntSort())
907 >>> f(f(0))
908 f(f(0))
909 """
910 sig = _get_args(sig)
911 if z3_debug():
912 _z3_assert(len(sig) > 0, "At least two arguments expected")
913 arity = len(sig) - 1
914 rng = sig[arity]
915 if z3_debug():
916 _z3_assert(is_sort(rng), "Z3 sort expected")
917 dom = (Sort * arity)()
918 for i in range(arity):
919 if z3_debug():
920 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
921 dom[i] = sig[i].ast
922 ctx = rng.ctx
924
925
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.
◆ get_as_array_func()
| get_as_array_func | ( | n | ) |
Return the function declaration f associated with a Z3 expression of the form (_ as-array f).
Definition at line 6880 of file z3py.py.
6880def get_as_array_func(n):
6881 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6882 if z3_debug():
6883 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6885
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a)
Return the function declaration f associated with a (_ as_array f) node.
Referenced by ModelRef.get_interp().
◆ get_ctx()
| Context get_ctx | ( | ctx | ) |
◆ get_default_fp_sort()
| get_default_fp_sort | ( | ctx = None | ) |
◆ get_default_rounding_mode()
| get_default_rounding_mode | ( | ctx = None | ) |
Retrieves the global default rounding mode.
Definition at line 9584 of file z3py.py.
9584def get_default_rounding_mode(ctx=None):
9585 """Retrieves the global default rounding mode."""
9586 global _dflt_rounding_mode
9587 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9588 return RTZ(ctx)
9589 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9590 return RTN(ctx)
9591 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9592 return RTP(ctx)
9593 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9594 return RNE(ctx)
9595 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9596 return RNA(ctx)
9597
9598
◆ get_full_version()
| get_full_version | ( | ) |
◆ get_map_func()
| get_map_func | ( | a | ) |
Return the function declaration associated with a Z3 map array expression.
>>> f = Function('f', IntSort(), IntSort())
>>> b = Array('b', IntSort(), IntSort())
>>> a = Map(f, b)
>>> eq(f, get_map_func(a))
True
>>> get_map_func(a)
f
>>> get_map_func(a)(0)
f(0)
Definition at line 4810 of file z3py.py.
4810def get_map_func(a):
4811 """Return the function declaration associated with a Z3 map array expression.
4812
4813 >>> f = Function('f', IntSort(), IntSort())
4814 >>> b = Array('b', IntSort(), IntSort())
4815 >>> a = Map(f, b)
4816 >>> eq(f, get_map_func(a))
4817 True
4818 >>> get_map_func(a)
4819 f
4820 >>> get_map_func(a)(0)
4821 f(0)
4822 """
4823 if z3_debug():
4824 _z3_assert(is_map(a), "Z3 array map expression expected.")
4825 return FuncDeclRef(
4826 Z3_to_func_decl(
4827 a.ctx_ref(),
4828 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4829 ),
4830 ctx=a.ctx,
4831 )
4832
4833
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
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.
◆ get_param()
| get_param | ( | name | ) |
Return the value of a Z3 global (or module) parameter
>>> get_param('nlsat.reorder')
'true'
Definition at line 317 of file z3py.py.
317def get_param(name):
318 """Return the value of a Z3 global (or module) parameter
319
320 >>> get_param('nlsat.reorder')
321 'true'
322 """
323 ptr = (ctypes.c_char_p * 1)()
325 r = z3core._to_pystr(ptr[0])
326 return r
327 raise Z3Exception("failed to retrieve value for '%s'" % name)
328
bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.
◆ get_var_index()
| get_var_index | ( | a | ) |
Return the de-Bruijn index of the Z3 bounded variable `a`.
>>> x = Int('x')
>>> y = Int('y')
>>> is_var(x)
False
>>> is_const(x)
True
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> # Z3 replaces x and y with bound variables when ForAll is executed.
>>> q = ForAll([x, y], f(x, y) == x + y)
>>> q.body()
f(Var(1), Var(0)) == Var(1) + Var(0)
>>> b = q.body()
>>> b.arg(0)
f(Var(1), Var(0))
>>> v1 = b.arg(0).arg(0)
>>> v2 = b.arg(0).arg(1)
>>> v1
Var(1)
>>> v2
Var(0)
>>> get_var_index(v1)
1
>>> get_var_index(v2)
0
Definition at line 1397 of file z3py.py.
1397def get_var_index(a):
1398 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1399
1400 >>> x = Int('x')
1401 >>> y = Int('y')
1402 >>> is_var(x)
1403 False
1404 >>> is_const(x)
1405 True
1406 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1407 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1408 >>> q = ForAll([x, y], f(x, y) == x + y)
1409 >>> q.body()
1410 f(Var(1), Var(0)) == Var(1) + Var(0)
1411 >>> b = q.body()
1412 >>> b.arg(0)
1413 f(Var(1), Var(0))
1414 >>> v1 = b.arg(0).arg(0)
1415 >>> v2 = b.arg(0).arg(1)
1416 >>> v1
1417 Var(1)
1418 >>> v2
1419 Var(0)
1420 >>> get_var_index(v1)
1421 1
1422 >>> get_var_index(v2)
1423 0
1424 """
1425 if z3_debug():
1426 _z3_assert(is_var(a), "Z3 bound variable expected")
1428
1429
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.
◆ get_version()
| get_version | ( | ) |
Definition at line 100 of file z3py.py.
100def get_version():
101 major = ctypes.c_uint(0)
102 minor = ctypes.c_uint(0)
103 build = ctypes.c_uint(0)
104 rev = ctypes.c_uint(0)
105 Z3_get_version(major, minor, build, rev)
106 return (major.value, minor.value, build.value, rev.value)
107
108
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
◆ get_version_string()
| get_version_string | ( | ) |
Definition at line 91 of file z3py.py.
91def get_version_string():
92 major = ctypes.c_uint(0)
93 minor = ctypes.c_uint(0)
94 build = ctypes.c_uint(0)
95 rev = ctypes.c_uint(0)
96 Z3_get_version(major, minor, build, rev)
97 return "%s.%s.%s" % (major.value, minor.value, build.value)
98
99
◆ help_simplify()
| help_simplify | ( | ) |
Return a string describing all options available for Z3 `simplify` procedure.
Definition at line 9090 of file z3py.py.
9090def help_simplify():
9091 """Return a string describing all options available for Z3 `simplify` procedure."""
9092 print(Z3_simplify_get_help(main_ctx().ref()))
9093
9094
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.
◆ If()
| If | ( | a, | |
| b, | |||
| c, | |||
| ctx = None ) |
Create a Z3 if-then-else expression.
>>> x = Int('x')
>>> y = Int('y')
>>> max = If(x > y, x, y)
>>> max
If(x > y, x, y)
>>> simplify(max)
If(x <= y, y, x)
Definition at line 1443 of file z3py.py.
1443def If(a, b, c, ctx=None):
1444 """Create a Z3 if-then-else expression.
1445
1446 >>> x = Int('x')
1447 >>> y = Int('y')
1448 >>> max = If(x > y, x, y)
1449 >>> max
1450 If(x > y, x, y)
1451 >>> simplify(max)
1452 If(x <= y, y, x)
1453 """
1454 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1455 return Cond(a, b, c, ctx)
1456 else:
1457 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1458 s = BoolSort(ctx)
1459 a = s.cast(a)
1460 b, c = _coerce_exprs(b, c, ctx)
1461 if z3_debug():
1462 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1464
1465
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).
Referenced by BoolRef.__add__(), ArithRef.__mul__(), BoolRef.__mul__(), and ToReal().
◆ Implies()
| Implies | ( | a, | |
| b, | |||
| ctx = None ) |
Create a Z3 implies expression.
>>> p, q = Bools('p q')
>>> Implies(p, q)
Implies(p, q)
Definition at line 1877 of file z3py.py.
1877def Implies(a, b, ctx=None):
1878 """Create a Z3 implies expression.
1879
1880 >>> p, q = Bools('p q')
1881 >>> Implies(p, q)
1882 Implies(p, q)
1883 """
1884 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1885 s = BoolSort(ctx)
1886 a = s.cast(a)
1887 b = s.cast(b)
1889
1890
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
◆ IndexOf()
| IndexOf | ( | s, | |
| substr, | |||
| offset = None ) |
Retrieve the index of substring within a string starting at a specified offset.
>>> simplify(IndexOf("abcabc", "bc", 0))
1
>>> simplify(IndexOf("abcabc", "bc", 2))
4
Definition at line 11384 of file z3py.py.
11384def IndexOf(s, substr, offset=None):
11385 """Retrieve the index of substring within a string starting at a specified offset.
11386 >>> simplify(IndexOf("abcabc", "bc", 0))
11387 1
11388 >>> simplify(IndexOf("abcabc", "bc", 2))
11389 4
11390 """
11391 if offset is None:
11392 offset = IntVal(0)
11393 ctx = None
11394 if is_expr(offset):
11395 ctx = offset.ctx
11396 ctx = _get_ctx2(s, substr, ctx)
11397 s = _coerce_seq(s, ctx)
11398 substr = _coerce_seq(substr, ctx)
11399 if _is_int(offset):
11400 offset = IntVal(offset, ctx)
11401 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11402
11403
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...
◆ InRe()
| InRe | ( | s, | |
| re ) |
Create regular expression membership test
>>> re = Union(Re("a"),Re("b"))
>>> print (simplify(InRe("a", re)))
True
>>> print (simplify(InRe("b", re)))
True
>>> print (simplify(InRe("c", re)))
False
Definition at line 11523 of file z3py.py.
11523def InRe(s, re):
11524 """Create regular expression membership test
11525 >>> re = Union(Re("a"),Re("b"))
11526 >>> print (simplify(InRe("a", re)))
11527 True
11528 >>> print (simplify(InRe("b", re)))
11529 True
11530 >>> print (simplify(InRe("c", re)))
11531 False
11532 """
11533 s = _coerce_seq(s, re.ctx)
11535
11536
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.
◆ Int()
| Int | ( | name, | |
| ctx = None ) |
Return an integer constant named `name`. If `ctx=None`, then the global context is used.
>>> x = Int('x')
>>> is_int(x)
True
>>> is_int(x + 1)
True
Definition at line 3352 of file z3py.py.
3352def Int(name, ctx=None):
3353 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3354
3355 >>> x = Int('x')
3356 >>> is_int(x)
3357 True
3358 >>> is_int(x + 1)
3359 True
3360 """
3361 ctx = _get_ctx(ctx)
3363
3364
Referenced by Ints(), and IntVector().
◆ Int2BV()
| Int2BV | ( | a, | |
| num_bits ) |
Return the z3 expression Int2BV(a, num_bits). It is a bit-vector of width num_bits and represents the modulo of a by 2^num_bits
Definition at line 4107 of file z3py.py.
4107def Int2BV(a, num_bits):
4108 """Return the z3 expression Int2BV(a, num_bits).
4109 It is a bit-vector of width num_bits and represents the
4110 modulo of a by 2^num_bits
4111 """
4112 ctx = a.ctx
4114
4115
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.
◆ Intersect()
| Intersect | ( | * | args | ) |
Create intersection of regular expressions.
>>> re = Intersect(Re("a"), Re("b"), Re("c"))
Definition at line 11557 of file z3py.py.
11557def Intersect(*args):
11558 """Create intersection of regular expressions.
11559 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11560 """
11561 args = _get_args(args)
11562 sz = len(args)
11563 if z3_debug():
11564 _z3_assert(sz > 0, "At least one argument expected.")
11565 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11566 if sz == 1:
11567 return args[0]
11568 ctx = args[0].ctx
11569 v = (Ast * sz)()
11570 for i in range(sz):
11571 v[i] = args[i].as_ast()
11573
11574
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
◆ Ints()
| Ints | ( | names, | |
| ctx = None ) |
Return a tuple of Integer constants.
>>> x, y, z = Ints('x y z')
>>> Sum(x, y, z)
x + y + z
Definition at line 3365 of file z3py.py.
3365def Ints(names, ctx=None):
3366 """Return a tuple of Integer constants.
3367
3368 >>> x, y, z = Ints('x y z')
3369 >>> Sum(x, y, z)
3370 x + y + z
3371 """
3372 ctx = _get_ctx(ctx)
3373 if isinstance(names, str):
3374 names = names.split(" ")
3375 return [Int(name, ctx) for name in names]
3376
3377
◆ IntSort()
| IntSort | ( | ctx = None | ) |
Return the integer sort in the given context. If `ctx=None`, then the global context is used.
>>> IntSort()
Int
>>> x = Const('x', IntSort())
>>> is_int(x)
True
>>> x.sort() == IntSort()
True
>>> x.sort() == BoolSort()
False
Definition at line 3246 of file z3py.py.
3246def IntSort(ctx=None):
3247 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3248
3249 >>> IntSort()
3250 Int
3251 >>> x = Const('x', IntSort())
3252 >>> is_int(x)
3253 True
3254 >>> x.sort() == IntSort()
3255 True
3256 >>> x.sort() == BoolSort()
3257 False
3258 """
3259 ctx = _get_ctx(ctx)
3261
3262
Referenced by FreshInt(), Int(), and IntVal().
◆ IntToStr()
| IntToStr | ( | s | ) |
◆ IntVal()
| IntVal | ( | val, | |
| ctx = None ) |
Return a Z3 integer value. If `ctx=None`, then the global context is used.
>>> IntVal(1)
1
>>> IntVal("100")
100
Definition at line 3292 of file z3py.py.
3292def IntVal(val, ctx=None):
3293 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3294
3295 >>> IntVal(1)
3296 1
3297 >>> IntVal("100")
3298 100
3299 """
3300 ctx = _get_ctx(ctx)
3302
3303
Referenced by BoolRef.__mul__(), and _py2expr().
◆ IntVector()
| IntVector | ( | prefix, | |
| sz, | |||
| ctx = None ) |
Return a list of integer constants of size `sz`.
>>> X = IntVector('x', 3)
>>> X
[x__0, x__1, x__2]
>>> Sum(X)
x__0 + x__1 + x__2
Definition at line 3378 of file z3py.py.
3378def IntVector(prefix, sz, ctx=None):
3379 """Return a list of integer constants of size `sz`.
3380
3381 >>> X = IntVector('x', 3)
3382 >>> X
3383 [x__0, x__1, x__2]
3384 >>> Sum(X)
3385 x__0 + x__1 + x__2
3386 """
3387 ctx = _get_ctx(ctx)
3388 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3389
3390
◆ is_add()
| bool is_add | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b + c.
>>> x, y = Ints('x y')
>>> is_add(x + y)
True
>>> is_add(x - y)
False
Definition at line 2894 of file z3py.py.
2894def is_add(a : Any) -> bool:
2895 """Return `True` if `a` is an expression of the form b + c.
2896
2897 >>> x, y = Ints('x y')
2898 >>> is_add(x + y)
2899 True
2900 >>> is_add(x - y)
2901 False
2902 """
2903 return is_app_of(a, Z3_OP_ADD)
2904
2905
◆ is_algebraic_value()
| is_algebraic_value | ( | a | ) |
Return `True` if `a` is an algebraic value of sort Real.
>>> is_algebraic_value(RealVal("3/5"))
False
>>> n = simplify(Sqrt(2))
>>> n
1.4142135623?
>>> is_algebraic_value(n)
True
Definition at line 2880 of file z3py.py.
2880def is_algebraic_value(a):
2881 """Return `True` if `a` is an algebraic value of sort Real.
2882
2883 >>> is_algebraic_value(RealVal("3/5"))
2884 False
2885 >>> n = simplify(Sqrt(2))
2886 >>> n
2887 1.4142135623?
2888 >>> is_algebraic_value(n)
2889 True
2890 """
2891 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2892
2893
◆ is_and()
| bool is_and | ( | Any | a | ) |
Return `True` if `a` is a Z3 and expression.
>>> p, q = Bools('p q')
>>> is_and(And(p, q))
True
>>> is_and(Or(p, q))
False
Definition at line 1713 of file z3py.py.
1713def is_and(a : Any) -> bool:
1714 """Return `True` if `a` is a Z3 and expression.
1715
1716 >>> p, q = Bools('p q')
1717 >>> is_and(And(p, q))
1718 True
1719 >>> is_and(Or(p, q))
1720 False
1721 """
1722 return is_app_of(a, Z3_OP_AND)
1723
1724
◆ is_app()
| is_app | ( | a | ) |
Return `True` if `a` is a Z3 function application.
Note that, constants are function applications with 0 arguments.
>>> a = Int('a')
>>> is_app(a)
True
>>> is_app(a + 1)
True
>>> is_app(IntSort())
False
>>> is_app(1)
False
>>> is_app(IntVal(1))
True
>>> x = Int('x')
>>> is_app(ForAll(x, x >= 0))
False
Definition at line 1327 of file z3py.py.
1327def is_app(a):
1328 """Return `True` if `a` is a Z3 function application.
1329
1330 Note that, constants are function applications with 0 arguments.
1331
1332 >>> a = Int('a')
1333 >>> is_app(a)
1334 True
1335 >>> is_app(a + 1)
1336 True
1337 >>> is_app(IntSort())
1338 False
1339 >>> is_app(1)
1340 False
1341 >>> is_app(IntVal(1))
1342 True
1343 >>> x = Int('x')
1344 >>> is_app(ForAll(x, x >= 0))
1345 False
1346 """
1347 if not isinstance(a, ExprRef):
1348 return False
1349 k = _ast_kind(a.ctx, a)
1350 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1351
1352
Referenced by _mk_quantifier(), ExprRef.arg(), ExprRef.children(), ExprRef.decl(), is_app_of(), is_const(), ExprRef.kind(), Lambda(), ExprRef.num_args(), and RecAddDefinition().
◆ is_app_of()
| is_app_of | ( | a, | |
| k ) |
Return `True` if `a` is an application of the given kind `k`.
>>> x = Int('x')
>>> n = x + 1
>>> is_app_of(n, Z3_OP_ADD)
True
>>> is_app_of(n, Z3_OP_MUL)
False
Definition at line 1430 of file z3py.py.
1430def is_app_of(a, k):
1431 """Return `True` if `a` is an application of the given kind `k`.
1432
1433 >>> x = Int('x')
1434 >>> n = x + 1
1435 >>> is_app_of(n, Z3_OP_ADD)
1436 True
1437 >>> is_app_of(n, Z3_OP_MUL)
1438 False
1439 """
1440 return is_app(a) and a.kind() == k
1441
1442
Referenced by is_add(), is_and(), is_const_array(), is_default(), is_distinct(), is_div(), is_eq(), is_false(), is_ge(), is_gt(), is_idiv(), is_implies(), is_is_int(), is_K(), is_le(), is_lt(), is_map(), is_mod(), is_mul(), is_not(), is_or(), is_select(), is_store(), is_sub(), is_to_int(), is_to_real(), and is_true().
◆ is_arith()
| is_arith | ( | a | ) |
Return `True` if `a` is an arithmetical expression.
>>> x = Int('x')
>>> is_arith(x)
True
>>> is_arith(x + 1)
True
>>> is_arith(1)
False
>>> is_arith(IntVal(1))
True
>>> y = Real('y')
>>> is_arith(y)
True
>>> is_arith(y + 1)
True
Definition at line 2767 of file z3py.py.
2767def is_arith(a):
2768 """Return `True` if `a` is an arithmetical expression.
2769
2770 >>> x = Int('x')
2771 >>> is_arith(x)
2772 True
2773 >>> is_arith(x + 1)
2774 True
2775 >>> is_arith(1)
2776 False
2777 >>> is_arith(IntVal(1))
2778 True
2779 >>> y = Real('y')
2780 >>> is_arith(y)
2781 True
2782 >>> is_arith(y + 1)
2783 True
2784 """
2785 return isinstance(a, ArithRef)
2786
2787
Referenced by is_algebraic_value(), is_int(), is_int_value(), is_rational_value(), and is_real().
◆ is_arith_sort()
| bool is_arith_sort | ( | Any | s | ) |
Return `True` if s is an arithmetical sort (type).
>>> is_arith_sort(IntSort())
True
>>> is_arith_sort(RealSort())
True
>>> is_arith_sort(BoolSort())
False
>>> n = Int('x') + 1
>>> is_arith_sort(n.sort())
True
Definition at line 2466 of file z3py.py.
2466def is_arith_sort(s : Any) -> bool:
2467 """Return `True` if s is an arithmetical sort (type).
2468
2469 >>> is_arith_sort(IntSort())
2470 True
2471 >>> is_arith_sort(RealSort())
2472 True
2473 >>> is_arith_sort(BoolSort())
2474 False
2475 >>> n = Int('x') + 1
2476 >>> is_arith_sort(n.sort())
2477 True
2478 """
2479 return isinstance(s, ArithSortRef)
2480
2481
Referenced by ArithSortRef.subsort().
◆ is_array()
| bool is_array | ( | Any | a | ) |
Return `True` if `a` is a Z3 array expression.
>>> a = Array('a', IntSort(), IntSort())
>>> is_array(a)
True
>>> is_array(Store(a, 0, 1))
True
>>> is_array(a[0])
False
Definition at line 4745 of file z3py.py.
4745def is_array(a : Any) -> bool:
4746 """Return `True` if `a` is a Z3 array expression.
4747
4748 >>> a = Array('a', IntSort(), IntSort())
4749 >>> is_array(a)
4750 True
4751 >>> is_array(Store(a, 0, 1))
4752 True
4753 >>> is_array(a[0])
4754 False
4755 """
4756 return isinstance(a, ArrayRef)
4757
4758
◆ is_array_sort()
◆ is_as_array()
| is_as_array | ( | n | ) |
Return true if n is a Z3 expression of the form (_ as-array f).
Definition at line 6875 of file z3py.py.
6875def is_as_array(n):
6876 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6878
6879
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a)
The (_ as-array f) AST node is a construct for assigning interpretations for arrays in Z3....
Referenced by get_as_array_func(), and ModelRef.get_interp().
◆ is_ast()
| bool is_ast | ( | Any | a | ) |
Return `True` if `a` is an AST node.
>>> is_ast(10)
False
>>> is_ast(IntVal(10))
True
>>> is_ast(Int('x'))
True
>>> is_ast(BoolSort())
True
>>> is_ast(Function('f', IntSort(), IntSort()))
True
>>> is_ast("x")
False
>>> is_ast(Solver())
False
Definition at line 465 of file z3py.py.
465def is_ast(a : Any) -> bool:
466 """Return `True` if `a` is an AST node.
467
468 >>> is_ast(10)
469 False
470 >>> is_ast(IntVal(10))
471 True
472 >>> is_ast(Int('x'))
473 True
474 >>> is_ast(BoolSort())
475 True
476 >>> is_ast(Function('f', IntSort(), IntSort()))
477 True
478 >>> is_ast("x")
479 False
480 >>> is_ast(Solver())
481 False
482 """
483 return isinstance(a, AstRef)
484
485
Referenced by _ast_kind(), _ctx_from_ast_arg_list(), AstRef.eq(), and eq().
◆ is_bool()
| bool is_bool | ( | Any | a | ) |
Return `True` if `a` is a Z3 Boolean expression.
>>> p = Bool('p')
>>> is_bool(p)
True
>>> q = Bool('q')
>>> is_bool(And(p, q))
True
>>> x = Real('x')
>>> is_bool(x)
False
>>> is_bool(x == 0)
True
Definition at line 1663 of file z3py.py.
1663def is_bool(a : Any) -> bool:
1664 """Return `True` if `a` is a Z3 Boolean expression.
1665
1666 >>> p = Bool('p')
1667 >>> is_bool(p)
1668 True
1669 >>> q = Bool('q')
1670 >>> is_bool(And(p, q))
1671 True
1672 >>> x = Real('x')
1673 >>> is_bool(x)
1674 False
1675 >>> is_bool(x == 0)
1676 True
1677 """
1678 return isinstance(a, BoolRef)
1679
1680
Referenced by _mk_quantifier().
◆ is_bv()
| is_bv | ( | a | ) |
Return `True` if `a` is a Z3 bit-vector expression.
>>> b = BitVec('b', 32)
>>> is_bv(b)
True
>>> is_bv(b + 10)
True
>>> is_bv(Int('x'))
False
Definition at line 4055 of file z3py.py.
4055def is_bv(a):
4056 """Return `True` if `a` is a Z3 bit-vector expression.
4057
4058 >>> b = BitVec('b', 32)
4059 >>> is_bv(b)
4060 True
4061 >>> is_bv(b + 10)
4062 True
4063 >>> is_bv(Int('x'))
4064 False
4065 """
4066 return isinstance(a, BitVecRef)
4067
4068
Referenced by _check_bv_args(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), Concat(), Extract(), is_bv_value(), RepeatBitVec(), SignExt(), and ZeroExt().
◆ is_bv_sort()
| is_bv_sort | ( | s | ) |
Return True if `s` is a Z3 bit-vector sort. >>> is_bv_sort(BitVecSort(32)) True >>> is_bv_sort(IntSort()) False
Definition at line 3582 of file z3py.py.
3582def is_bv_sort(s):
3583 """Return True if `s` is a Z3 bit-vector sort.
3584
3585 >>> is_bv_sort(BitVecSort(32))
3586 True
3587 >>> is_bv_sort(IntSort())
3588 False
3589 """
3590 return isinstance(s, BitVecSortRef)
3591
3592
Referenced by BitVecVal(), and BitVecSortRef.subsort().
◆ is_bv_value()
| is_bv_value | ( | a | ) |
Return `True` if `a` is a Z3 bit-vector numeral value.
>>> b = BitVec('b', 32)
>>> is_bv_value(b)
False
>>> b = BitVecVal(10, 32)
>>> b
10
>>> is_bv_value(b)
True
Definition at line 4069 of file z3py.py.
4069def is_bv_value(a):
4070 """Return `True` if `a` is a Z3 bit-vector numeral value.
4071
4072 >>> b = BitVec('b', 32)
4073 >>> is_bv_value(b)
4074 False
4075 >>> b = BitVecVal(10, 32)
4076 >>> b
4077 10
4078 >>> is_bv_value(b)
4079 True
4080 """
4081 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4082
4083
◆ is_const()
| is_const | ( | a | ) |
Return `True` if `a` is Z3 constant/variable expression.
>>> a = Int('a')
>>> is_const(a)
True
>>> is_const(a + 1)
False
>>> is_const(1)
False
>>> is_const(IntVal(1))
True
>>> x = Int('x')
>>> is_const(ForAll(x, x >= 0))
False
Definition at line 1353 of file z3py.py.
1353def is_const(a):
1354 """Return `True` if `a` is Z3 constant/variable expression.
1355
1356 >>> a = Int('a')
1357 >>> is_const(a)
1358 True
1359 >>> is_const(a + 1)
1360 False
1361 >>> is_const(1)
1362 False
1363 >>> is_const(IntVal(1))
1364 True
1365 >>> x = Int('x')
1366 >>> is_const(ForAll(x, x >= 0))
1367 False
1368 """
1369 return is_app(a) and a.num_args() == 0
1370
1371
Referenced by ModelRef.__getitem__(), _mk_quantifier(), Solver.assert_and_track(), and ModelRef.get_interp().
◆ is_const_array()
| is_const_array | ( | a | ) |
Return `True` if `a` is a Z3 constant array.
>>> a = K(IntSort(), 10)
>>> is_const_array(a)
True
>>> a = Array('a', IntSort(), IntSort())
>>> is_const_array(a)
False
Definition at line 4759 of file z3py.py.
4759def is_const_array(a):
4760 """Return `True` if `a` is a Z3 constant array.
4761
4762 >>> a = K(IntSort(), 10)
4763 >>> is_const_array(a)
4764 True
4765 >>> a = Array('a', IntSort(), IntSort())
4766 >>> is_const_array(a)
4767 False
4768 """
4769 return is_app_of(a, Z3_OP_CONST_ARRAY)
4770
4771
◆ is_default()
| is_default | ( | a | ) |
Return `True` if `a` is a Z3 default array expression. >>> d = Default(K(IntSort(), 10)) >>> is_default(d) True
Definition at line 4801 of file z3py.py.
4801def is_default(a):
4802 """Return `True` if `a` is a Z3 default array expression.
4803 >>> d = Default(K(IntSort(), 10))
4804 >>> is_default(d)
4805 True
4806 """
4807 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4808
4809
◆ is_distinct()
| bool is_distinct | ( | Any | a | ) |
Return `True` if `a` is a Z3 distinct expression.
>>> x, y, z = Ints('x y z')
>>> is_distinct(x == y)
False
>>> is_distinct(Distinct(x, y, z))
True
Definition at line 1771 of file z3py.py.
1771def is_distinct(a : Any) -> bool:
1772 """Return `True` if `a` is a Z3 distinct expression.
1773
1774 >>> x, y, z = Ints('x y z')
1775 >>> is_distinct(x == y)
1776 False
1777 >>> is_distinct(Distinct(x, y, z))
1778 True
1779 """
1780 return is_app_of(a, Z3_OP_DISTINCT)
1781
1782
◆ is_div()
| bool is_div | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b / c.
>>> x, y = Reals('x y')
>>> is_div(x / y)
True
>>> is_div(x + y)
False
>>> x, y = Ints('x y')
>>> is_div(x / y)
False
>>> is_idiv(x / y)
True
Definition at line 2930 of file z3py.py.
2930def is_div(a : Any) -> bool:
2931 """Return `True` if `a` is an expression of the form b / c.
2932
2933 >>> x, y = Reals('x y')
2934 >>> is_div(x / y)
2935 True
2936 >>> is_div(x + y)
2937 False
2938 >>> x, y = Ints('x y')
2939 >>> is_div(x / y)
2940 False
2941 >>> is_idiv(x / y)
2942 True
2943 """
2944 return is_app_of(a, Z3_OP_DIV)
2945
2946
◆ is_eq()
| bool is_eq | ( | Any | a | ) |
Return `True` if `a` is a Z3 equality expression.
>>> x, y = Ints('x y')
>>> is_eq(x == y)
True
Definition at line 1761 of file z3py.py.
1761def is_eq(a : Any) -> bool:
1762 """Return `True` if `a` is a Z3 equality expression.
1763
1764 >>> x, y = Ints('x y')
1765 >>> is_eq(x == y)
1766 True
1767 """
1768 return is_app_of(a, Z3_OP_EQ)
1769
1770
Referenced by AstRef.__bool__().
◆ is_expr()
| is_expr | ( | a | ) |
Return `True` if `a` is a Z3 expression.
>>> a = Int('a')
>>> is_expr(a)
True
>>> is_expr(a + 1)
True
>>> is_expr(IntSort())
False
>>> is_expr(1)
False
>>> is_expr(IntVal(1))
True
>>> x = Int('x')
>>> is_expr(ForAll(x, x >= 0))
True
>>> is_expr(FPVal(1.0))
True
Definition at line 1304 of file z3py.py.
1304def is_expr(a):
1305 """Return `True` if `a` is a Z3 expression.
1306
1307 >>> a = Int('a')
1308 >>> is_expr(a)
1309 True
1310 >>> is_expr(a + 1)
1311 True
1312 >>> is_expr(IntSort())
1313 False
1314 >>> is_expr(1)
1315 False
1316 >>> is_expr(IntVal(1))
1317 True
1318 >>> x = Int('x')
1319 >>> is_expr(ForAll(x, x >= 0))
1320 True
1321 >>> is_expr(FPVal(1.0))
1322 True
1323 """
1324 return isinstance(a, ExprRef)
1325
1326
Referenced by _coerce_expr_list(), _coerce_expr_merge(), _coerce_exprs(), _mk_quantifier(), _py2expr(), ArithSortRef.cast(), BitVecSortRef.cast(), SortRef.cast(), Cbrt(), Concat(), is_var(), K(), MultiPattern(), Sqrt(), and ModelRef.update_value().
◆ is_false()
| bool is_false | ( | Any | a | ) |
Return `True` if `a` is the Z3 false expression.
>>> p = Bool('p')
>>> is_false(p)
False
>>> is_false(False)
False
>>> is_false(BoolVal(False))
True
Definition at line 1699 of file z3py.py.
1699def is_false(a : Any) -> bool:
1700 """Return `True` if `a` is the Z3 false expression.
1701
1702 >>> p = Bool('p')
1703 >>> is_false(p)
1704 False
1705 >>> is_false(False)
1706 False
1707 >>> is_false(BoolVal(False))
1708 True
1709 """
1710 return is_app_of(a, Z3_OP_FALSE)
1711
1712
Referenced by AstRef.__bool__(), and BoolRef.py_value().
◆ is_finite_domain()
| is_finite_domain | ( | a | ) |
Return `True` if `a` is a Z3 finite-domain expression.
>>> s = FiniteDomainSort('S', 100)
>>> b = Const('b', s)
>>> is_finite_domain(b)
True
>>> is_finite_domain(Int('x'))
False
Definition at line 7968 of file z3py.py.
7968def is_finite_domain(a):
7969 """Return `True` if `a` is a Z3 finite-domain expression.
7970
7971 >>> s = FiniteDomainSort('S', 100)
7972 >>> b = Const('b', s)
7973 >>> is_finite_domain(b)
7974 True
7975 >>> is_finite_domain(Int('x'))
7976 False
7977 """
7978 return isinstance(a, FiniteDomainRef)
7979
7980
◆ is_finite_domain_sort()
| is_finite_domain_sort | ( | s | ) |
Return True if `s` is a Z3 finite-domain sort.
>>> is_finite_domain_sort(FiniteDomainSort('S', 100))
True
>>> is_finite_domain_sort(IntSort())
False
Definition at line 7945 of file z3py.py.
7945def is_finite_domain_sort(s):
7946 """Return True if `s` is a Z3 finite-domain sort.
7947
7948 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7949 True
7950 >>> is_finite_domain_sort(IntSort())
7951 False
7952 """
7953 return isinstance(s, FiniteDomainSortRef)
7954
7955
◆ is_finite_domain_value()
| is_finite_domain_value | ( | a | ) |
Return `True` if `a` is a Z3 finite-domain value.
>>> s = FiniteDomainSort('S', 100)
>>> b = Const('b', s)
>>> is_finite_domain_value(b)
False
>>> b = FiniteDomainVal(10, s)
>>> b
10
>>> is_finite_domain_value(b)
True
Definition at line 8022 of file z3py.py.
8022def is_finite_domain_value(a):
8023 """Return `True` if `a` is a Z3 finite-domain value.
8024
8025 >>> s = FiniteDomainSort('S', 100)
8026 >>> b = Const('b', s)
8027 >>> is_finite_domain_value(b)
8028 False
8029 >>> b = FiniteDomainVal(10, s)
8030 >>> b
8031 10
8032 >>> is_finite_domain_value(b)
8033 True
8034 """
8035 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
8036
8037
◆ is_fp()
| is_fp | ( | a | ) |
Return `True` if `a` is a Z3 floating-point expression.
>>> b = FP('b', FPSort(8, 24))
>>> is_fp(b)
True
>>> is_fp(b + 1.0)
True
>>> is_fp(Int('x'))
False
Definition at line 10176 of file z3py.py.
10176def is_fp(a):
10177 """Return `True` if `a` is a Z3 floating-point expression.
10178
10179 >>> b = FP('b', FPSort(8, 24))
10180 >>> is_fp(b)
10181 True
10182 >>> is_fp(b + 1.0)
10183 True
10184 >>> is_fp(Int('x'))
10185 False
10186 """
10187 return isinstance(a, FPRef)
10188
10189
◆ is_fp_sort()
| is_fp_sort | ( | s | ) |
Return True if `s` is a Z3 floating-point sort. >>> is_fp_sort(FPSort(8, 24)) True >>> is_fp_sort(IntSort()) False
Definition at line 9750 of file z3py.py.
9750def is_fp_sort(s):
9751 """Return True if `s` is a Z3 floating-point sort.
9752
9753 >>> is_fp_sort(FPSort(8, 24))
9754 True
9755 >>> is_fp_sort(IntSort())
9756 False
9757 """
9758 return isinstance(s, FPSortRef)
9759
9760
◆ is_fp_value()
| is_fp_value | ( | a | ) |
Return `True` if `a` is a Z3 floating-point numeral value.
>>> b = FP('b', FPSort(8, 24))
>>> is_fp_value(b)
False
>>> b = FPVal(1.0, FPSort(8, 24))
>>> b
1
>>> is_fp_value(b)
True
Definition at line 10190 of file z3py.py.
10190def is_fp_value(a):
10191 """Return `True` if `a` is a Z3 floating-point numeral value.
10192
10193 >>> b = FP('b', FPSort(8, 24))
10194 >>> is_fp_value(b)
10195 False
10196 >>> b = FPVal(1.0, FPSort(8, 24))
10197 >>> b
10198 1
10199 >>> is_fp_value(b)
10200 True
10201 """
10202 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10203
10204
◆ is_fprm()
| is_fprm | ( | a | ) |
Return `True` if `a` is a Z3 floating-point rounding mode expression. >>> rm = RNE() >>> is_fprm(rm) True >>> rm = 1.0 >>> is_fprm(rm) False
Definition at line 10010 of file z3py.py.
10010def is_fprm(a):
10011 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
10012
10013 >>> rm = RNE()
10014 >>> is_fprm(rm)
10015 True
10016 >>> rm = 1.0
10017 >>> is_fprm(rm)
10018 False
10019 """
10020 return isinstance(a, FPRMRef)
10021
10022
◆ is_fprm_sort()
| is_fprm_sort | ( | s | ) |
Return True if `s` is a Z3 floating-point rounding mode sort. >>> is_fprm_sort(FPSort(8, 24)) False >>> is_fprm_sort(RNE().sort()) True
Definition at line 9761 of file z3py.py.
9761def is_fprm_sort(s):
9762 """Return True if `s` is a Z3 floating-point rounding mode sort.
9763
9764 >>> is_fprm_sort(FPSort(8, 24))
9765 False
9766 >>> is_fprm_sort(RNE().sort())
9767 True
9768 """
9769 return isinstance(s, FPRMSortRef)
9770
9771# FP Expressions
9772
9773
◆ is_fprm_value()
| is_fprm_value | ( | a | ) |
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.
Definition at line 10023 of file z3py.py.
10023def is_fprm_value(a):
10024 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
10025 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
10026
10027# FP Numerals
10028
10029
◆ is_func_decl()
| is_func_decl | ( | a | ) |
Return `True` if `a` is a Z3 function declaration.
>>> f = Function('f', IntSort(), IntSort())
>>> is_func_decl(f)
True
>>> x = Real('x')
>>> is_func_decl(x)
False
Definition at line 890 of file z3py.py.
890def is_func_decl(a):
891 """Return `True` if `a` is a Z3 function declaration.
892
893 >>> f = Function('f', IntSort(), IntSort())
894 >>> is_func_decl(f)
895 True
896 >>> x = Real('x')
897 >>> is_func_decl(x)
898 False
899 """
900 return isinstance(a, FuncDeclRef)
901
902
Referenced by Map(), and ModelRef.update_value().
◆ is_ge()
| bool is_ge | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b >= c.
>>> x, y = Ints('x y')
>>> is_ge(x >= y)
True
>>> is_ge(x == y)
False
Definition at line 2995 of file z3py.py.
2995def is_ge(a : Any) -> bool:
2996 """Return `True` if `a` is an expression of the form b >= c.
2997
2998 >>> x, y = Ints('x y')
2999 >>> is_ge(x >= y)
3000 True
3001 >>> is_ge(x == y)
3002 False
3003 """
3004 return is_app_of(a, Z3_OP_GE)
3005
3006
◆ is_gt()
| bool is_gt | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b > c.
>>> x, y = Ints('x y')
>>> is_gt(x > y)
True
>>> is_gt(x == y)
False
Definition at line 3007 of file z3py.py.
3007def is_gt(a : Any) -> bool:
3008 """Return `True` if `a` is an expression of the form b > c.
3009
3010 >>> x, y = Ints('x y')
3011 >>> is_gt(x > y)
3012 True
3013 >>> is_gt(x == y)
3014 False
3015 """
3016 return is_app_of(a, Z3_OP_GT)
3017
3018
◆ is_idiv()
| bool is_idiv | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b div c.
>>> x, y = Ints('x y')
>>> is_idiv(x / y)
True
>>> is_idiv(x + y)
False
Definition at line 2947 of file z3py.py.
2947def is_idiv(a : Any) -> bool:
2948 """Return `True` if `a` is an expression of the form b div c.
2949
2950 >>> x, y = Ints('x y')
2951 >>> is_idiv(x / y)
2952 True
2953 >>> is_idiv(x + y)
2954 False
2955 """
2956 return is_app_of(a, Z3_OP_IDIV)
2957
2958
◆ is_implies()
| bool is_implies | ( | Any | a | ) |
Return `True` if `a` is a Z3 implication expression.
>>> p, q = Bools('p q')
>>> is_implies(Implies(p, q))
True
>>> is_implies(And(p, q))
False
Definition at line 1737 of file z3py.py.
1737def is_implies(a : Any) -> bool:
1738 """Return `True` if `a` is a Z3 implication expression.
1739
1740 >>> p, q = Bools('p q')
1741 >>> is_implies(Implies(p, q))
1742 True
1743 >>> is_implies(And(p, q))
1744 False
1745 """
1746 return is_app_of(a, Z3_OP_IMPLIES)
1747
1748
◆ is_int()
| bool is_int | ( | a | ) |
Return `True` if `a` is an integer expression.
>>> x = Int('x')
>>> is_int(x + 1)
True
>>> is_int(1)
False
>>> is_int(IntVal(1))
True
>>> y = Real('y')
>>> is_int(y)
False
>>> is_int(y + 1)
False
Definition at line 2788 of file z3py.py.
2788def is_int(a) -> bool:
2789 """Return `True` if `a` is an integer expression.
2790
2791 >>> x = Int('x')
2792 >>> is_int(x + 1)
2793 True
2794 >>> is_int(1)
2795 False
2796 >>> is_int(IntVal(1))
2797 True
2798 >>> y = Real('y')
2799 >>> is_int(y)
2800 False
2801 >>> is_int(y + 1)
2802 False
2803 """
2804 return is_arith(a) and a.is_int()
2805
2806
◆ is_int_value()
| is_int_value | ( | a | ) |
Return `True` if `a` is an integer value of sort Int.
>>> is_int_value(IntVal(1))
True
>>> is_int_value(1)
False
>>> is_int_value(Int('x'))
False
>>> n = Int('x') + 1
>>> n
x + 1
>>> n.arg(1)
1
>>> is_int_value(n.arg(1))
True
>>> is_int_value(RealVal("1/3"))
False
>>> is_int_value(RealVal(1))
False
Definition at line 2834 of file z3py.py.
2834def is_int_value(a):
2835 """Return `True` if `a` is an integer value of sort Int.
2836
2837 >>> is_int_value(IntVal(1))
2838 True
2839 >>> is_int_value(1)
2840 False
2841 >>> is_int_value(Int('x'))
2842 False
2843 >>> n = Int('x') + 1
2844 >>> n
2845 x + 1
2846 >>> n.arg(1)
2847 1
2848 >>> is_int_value(n.arg(1))
2849 True
2850 >>> is_int_value(RealVal("1/3"))
2851 False
2852 >>> is_int_value(RealVal(1))
2853 False
2854 """
2855 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2856
2857
◆ is_is_int()
| bool is_is_int | ( | Any | a | ) |
Return `True` if `a` is an expression of the form IsInt(b).
>>> x = Real('x')
>>> is_is_int(IsInt(x))
True
>>> is_is_int(x)
False
Definition at line 3019 of file z3py.py.
3019def is_is_int(a : Any) -> bool:
3020 """Return `True` if `a` is an expression of the form IsInt(b).
3021
3022 >>> x = Real('x')
3023 >>> is_is_int(IsInt(x))
3024 True
3025 >>> is_is_int(x)
3026 False
3027 """
3028 return is_app_of(a, Z3_OP_IS_INT)
3029
3030
◆ is_K()
| is_K | ( | a | ) |
Return `True` if `a` is a Z3 constant array.
>>> a = K(IntSort(), 10)
>>> is_K(a)
True
>>> a = Array('a', IntSort(), IntSort())
>>> is_K(a)
False
Definition at line 4772 of file z3py.py.
4772def is_K(a):
4773 """Return `True` if `a` is a Z3 constant array.
4774
4775 >>> a = K(IntSort(), 10)
4776 >>> is_K(a)
4777 True
4778 >>> a = Array('a', IntSort(), IntSort())
4779 >>> is_K(a)
4780 False
4781 """
4782 return is_app_of(a, Z3_OP_CONST_ARRAY)
4783
4784
◆ is_le()
| bool is_le | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b <= c.
>>> x, y = Ints('x y')
>>> is_le(x <= y)
True
>>> is_le(x < y)
False
Definition at line 2971 of file z3py.py.
2971def is_le(a : Any) -> bool:
2972 """Return `True` if `a` is an expression of the form b <= c.
2973
2974 >>> x, y = Ints('x y')
2975 >>> is_le(x <= y)
2976 True
2977 >>> is_le(x < y)
2978 False
2979 """
2980 return is_app_of(a, Z3_OP_LE)
2981
2982
◆ is_lt()
| bool is_lt | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b < c.
>>> x, y = Ints('x y')
>>> is_lt(x < y)
True
>>> is_lt(x == y)
False
Definition at line 2983 of file z3py.py.
2983def is_lt(a : Any) -> bool:
2984 """Return `True` if `a` is an expression of the form b < c.
2985
2986 >>> x, y = Ints('x y')
2987 >>> is_lt(x < y)
2988 True
2989 >>> is_lt(x == y)
2990 False
2991 """
2992 return is_app_of(a, Z3_OP_LT)
2993
2994
◆ is_map()
| is_map | ( | a | ) |
Return `True` if `a` is a Z3 map array expression.
>>> f = Function('f', IntSort(), IntSort())
>>> b = Array('b', IntSort(), IntSort())
>>> a = Map(f, b)
>>> a
Map(f, b)
>>> is_map(a)
True
>>> is_map(b)
False
Definition at line 4785 of file z3py.py.
4785def is_map(a):
4786 """Return `True` if `a` is a Z3 map array expression.
4787
4788 >>> f = Function('f', IntSort(), IntSort())
4789 >>> b = Array('b', IntSort(), IntSort())
4790 >>> a = Map(f, b)
4791 >>> a
4792 Map(f, b)
4793 >>> is_map(a)
4794 True
4795 >>> is_map(b)
4796 False
4797 """
4798 return is_app_of(a, Z3_OP_ARRAY_MAP)
4799
4800
Referenced by get_map_func().
◆ is_mod()
| bool is_mod | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b % c.
>>> x, y = Ints('x y')
>>> is_mod(x % y)
True
>>> is_mod(x + y)
False
Definition at line 2959 of file z3py.py.
2959def is_mod(a : Any) -> bool:
2960 """Return `True` if `a` is an expression of the form b % c.
2961
2962 >>> x, y = Ints('x y')
2963 >>> is_mod(x % y)
2964 True
2965 >>> is_mod(x + y)
2966 False
2967 """
2968 return is_app_of(a, Z3_OP_MOD)
2969
2970
◆ is_mul()
| bool is_mul | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b * c.
>>> x, y = Ints('x y')
>>> is_mul(x * y)
True
>>> is_mul(x - y)
False
Definition at line 2906 of file z3py.py.
2906def is_mul(a : Any) -> bool:
2907 """Return `True` if `a` is an expression of the form b * c.
2908
2909 >>> x, y = Ints('x y')
2910 >>> is_mul(x * y)
2911 True
2912 >>> is_mul(x - y)
2913 False
2914 """
2915 return is_app_of(a, Z3_OP_MUL)
2916
2917
◆ is_not()
| bool is_not | ( | Any | a | ) |
Return `True` if `a` is a Z3 not expression.
>>> p = Bool('p')
>>> is_not(p)
False
>>> is_not(Not(p))
True
Definition at line 1749 of file z3py.py.
1749def is_not(a : Any) -> bool:
1750 """Return `True` if `a` is a Z3 not expression.
1751
1752 >>> p = Bool('p')
1753 >>> is_not(p)
1754 False
1755 >>> is_not(Not(p))
1756 True
1757 """
1758 return is_app_of(a, Z3_OP_NOT)
1759
1760
Referenced by mk_not().
◆ is_or()
| bool is_or | ( | Any | a | ) |
Return `True` if `a` is a Z3 or expression.
>>> p, q = Bools('p q')
>>> is_or(Or(p, q))
True
>>> is_or(And(p, q))
False
Definition at line 1725 of file z3py.py.
1725def is_or(a : Any) -> bool:
1726 """Return `True` if `a` is a Z3 or expression.
1727
1728 >>> p, q = Bools('p q')
1729 >>> is_or(Or(p, q))
1730 True
1731 >>> is_or(And(p, q))
1732 False
1733 """
1734 return is_app_of(a, Z3_OP_OR)
1735
1736
◆ is_pattern()
| is_pattern | ( | a | ) |
Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
>>> f = Function('f', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
>>> q
ForAll(x, f(x) == 0)
>>> q.num_patterns()
1
>>> is_pattern(q.pattern(0))
True
>>> q.pattern(0)
f(Var(0))
Definition at line 2025 of file z3py.py.
2025def is_pattern(a):
2026 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
2027
2028 >>> f = Function('f', IntSort(), IntSort())
2029 >>> x = Int('x')
2030 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2031 >>> q
2032 ForAll(x, f(x) == 0)
2033 >>> q.num_patterns()
2034 1
2035 >>> is_pattern(q.pattern(0))
2036 True
2037 >>> q.pattern(0)
2038 f(Var(0))
2039 """
2040 return isinstance(a, PatternRef)
2041
2042
Referenced by _mk_quantifier(), and _to_pattern().
◆ is_probe()
| is_probe | ( | p | ) |
Return `True` if `p` is a Z3 probe.
>>> is_probe(Int('x'))
False
>>> is_probe(Probe('memory'))
True
Definition at line 8931 of file z3py.py.
8931def is_probe(p):
8932 """Return `True` if `p` is a Z3 probe.
8933
8934 >>> is_probe(Int('x'))
8935 False
8936 >>> is_probe(Probe('memory'))
8937 True
8938 """
8939 return isinstance(p, Probe)
8940
8941
Referenced by _ctx_from_ast_arg_list(), _has_probe(), and Not().
◆ is_quantifier()
| is_quantifier | ( | a | ) |
Return `True` if `a` is a Z3 quantifier.
>>> f = Function('f', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) == 0)
>>> is_quantifier(q)
True
>>> is_quantifier(f(x))
False
Definition at line 2275 of file z3py.py.
2275def is_quantifier(a):
2276 """Return `True` if `a` is a Z3 quantifier.
2277
2278 >>> f = Function('f', IntSort(), IntSort())
2279 >>> x = Int('x')
2280 >>> q = ForAll(x, f(x) == 0)
2281 >>> is_quantifier(q)
2282 True
2283 >>> is_quantifier(f(x))
2284 False
2285 """
2286 return isinstance(a, QuantifierRef)
2287
2288
◆ is_rational_value()
| is_rational_value | ( | a | ) |
Return `True` if `a` is rational value of sort Real.
>>> is_rational_value(RealVal(1))
True
>>> is_rational_value(RealVal("3/5"))
True
>>> is_rational_value(IntVal(1))
False
>>> is_rational_value(1)
False
>>> n = Real('x') + 1
>>> n.arg(1)
1
>>> is_rational_value(n.arg(1))
True
>>> is_rational_value(Real('x'))
False
Definition at line 2858 of file z3py.py.
2858def is_rational_value(a):
2859 """Return `True` if `a` is rational value of sort Real.
2860
2861 >>> is_rational_value(RealVal(1))
2862 True
2863 >>> is_rational_value(RealVal("3/5"))
2864 True
2865 >>> is_rational_value(IntVal(1))
2866 False
2867 >>> is_rational_value(1)
2868 False
2869 >>> n = Real('x') + 1
2870 >>> n.arg(1)
2871 1
2872 >>> is_rational_value(n.arg(1))
2873 True
2874 >>> is_rational_value(Real('x'))
2875 False
2876 """
2877 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2878
2879
◆ is_re()
| is_re | ( | s | ) |
◆ is_real()
| is_real | ( | a | ) |
Return `True` if `a` is a real expression.
>>> x = Int('x')
>>> is_real(x + 1)
False
>>> y = Real('y')
>>> is_real(y)
True
>>> is_real(y + 1)
True
>>> is_real(1)
False
>>> is_real(RealVal(1))
True
Definition at line 2807 of file z3py.py.
2807def is_real(a):
2808 """Return `True` if `a` is a real expression.
2809
2810 >>> x = Int('x')
2811 >>> is_real(x + 1)
2812 False
2813 >>> y = Real('y')
2814 >>> is_real(y)
2815 True
2816 >>> is_real(y + 1)
2817 True
2818 >>> is_real(1)
2819 False
2820 >>> is_real(RealVal(1))
2821 True
2822 """
2823 return is_arith(a) and a.is_real()
2824
2825
◆ is_select()
| is_select | ( | a | ) |
Return `True` if `a` is a Z3 array select application.
>>> a = Array('a', IntSort(), IntSort())
>>> is_select(a)
False
>>> i = Int('i')
>>> is_select(a[i])
True
Definition at line 5020 of file z3py.py.
5020def is_select(a):
5021 """Return `True` if `a` is a Z3 array select application.
5022
5023 >>> a = Array('a', IntSort(), IntSort())
5024 >>> is_select(a)
5025 False
5026 >>> i = Int('i')
5027 >>> is_select(a[i])
5028 True
5029 """
5030 return is_app_of(a, Z3_OP_SELECT)
5031
5032
◆ is_seq()
| is_seq | ( | a | ) |
Return `True` if `a` is a Z3 sequence expression.
>>> print (is_seq(Unit(IntVal(0))))
True
>>> print (is_seq(StringVal("abc")))
True
Definition at line 11201 of file z3py.py.
11201def is_seq(a):
11202 """Return `True` if `a` is a Z3 sequence expression.
11203 >>> print (is_seq(Unit(IntVal(0))))
11204 True
11205 >>> print (is_seq(StringVal("abc")))
11206 True
11207 """
11208 return isinstance(a, SeqRef)
11209
11210
◆ is_sort()
| bool is_sort | ( | Any | s | ) |
Return `True` if `s` is a Z3 sort.
>>> is_sort(IntSort())
True
>>> is_sort(Int('x'))
False
>>> is_expr(Int('x'))
True
Definition at line 665 of file z3py.py.
665def is_sort(s : Any) -> bool:
666 """Return `True` if `s` is a Z3 sort.
667
668 >>> is_sort(IntSort())
669 True
670 >>> is_sort(Int('x'))
671 False
672 >>> is_expr(Int('x'))
673 True
674 """
675 return isinstance(s, SortRef)
676
677
Referenced by _valid_accessor(), ArraySort(), CreateDatatypes(), FreshConst(), FreshFunction(), Function(), K(), RecFunction(), and Var().
◆ is_store()
| is_store | ( | a | ) |
Return `True` if `a` is a Z3 array store application.
>>> a = Array('a', IntSort(), IntSort())
>>> is_store(a)
False
>>> is_store(Store(a, 0, 1))
True
Definition at line 5033 of file z3py.py.
5033def is_store(a):
5034 """Return `True` if `a` is a Z3 array store application.
5035
5036 >>> a = Array('a', IntSort(), IntSort())
5037 >>> is_store(a)
5038 False
5039 >>> is_store(Store(a, 0, 1))
5040 True
5041 """
5042 return is_app_of(a, Z3_OP_STORE)
5043
◆ is_string()
| bool is_string | ( | Any | a | ) |
Return `True` if `a` is a Z3 string expression.
>>> print (is_string(StringVal("ab")))
True
Definition at line 11211 of file z3py.py.
11211def is_string(a: Any) -> bool:
11212 """Return `True` if `a` is a Z3 string expression.
11213 >>> print (is_string(StringVal("ab")))
11214 True
11215 """
11216 return isinstance(a, SeqRef) and a.is_string()
11217
11218
◆ is_string_value()
| bool is_string_value | ( | Any | a | ) |
return 'True' if 'a' is a Z3 string constant expression.
>>> print (is_string_value(StringVal("a")))
True
>>> print (is_string_value(StringVal("a") + StringVal("b")))
False
Definition at line 11219 of file z3py.py.
11219def is_string_value(a: Any) -> bool:
11220 """return 'True' if 'a' is a Z3 string constant expression.
11221 >>> print (is_string_value(StringVal("a")))
11222 True
11223 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11224 False
11225 """
11226 return isinstance(a, SeqRef) and a.is_string_value()
11227
◆ is_sub()
| bool is_sub | ( | Any | a | ) |
Return `True` if `a` is an expression of the form b - c.
>>> x, y = Ints('x y')
>>> is_sub(x - y)
True
>>> is_sub(x + y)
False
Definition at line 2918 of file z3py.py.
2918def is_sub(a : Any) -> bool:
2919 """Return `True` if `a` is an expression of the form b - c.
2920
2921 >>> x, y = Ints('x y')
2922 >>> is_sub(x - y)
2923 True
2924 >>> is_sub(x + y)
2925 False
2926 """
2927 return is_app_of(a, Z3_OP_SUB)
2928
2929
◆ is_to_int()
| bool is_to_int | ( | Any | a | ) |
Return `True` if `a` is an expression of the form ToInt(b).
>>> x = Real('x')
>>> n = ToInt(x)
>>> n
ToInt(x)
>>> is_to_int(n)
True
>>> is_to_int(x)
False
Definition at line 3046 of file z3py.py.
3046def is_to_int(a : Any) -> bool:
3047 """Return `True` if `a` is an expression of the form ToInt(b).
3048
3049 >>> x = Real('x')
3050 >>> n = ToInt(x)
3051 >>> n
3052 ToInt(x)
3053 >>> is_to_int(n)
3054 True
3055 >>> is_to_int(x)
3056 False
3057 """
3058 return is_app_of(a, Z3_OP_TO_INT)
3059
3060
◆ is_to_real()
| bool is_to_real | ( | Any | a | ) |
Return `True` if `a` is an expression of the form ToReal(b).
>>> x = Int('x')
>>> n = ToReal(x)
>>> n
ToReal(x)
>>> is_to_real(n)
True
>>> is_to_real(x)
False
Definition at line 3031 of file z3py.py.
3031def is_to_real(a : Any) -> bool:
3032 """Return `True` if `a` is an expression of the form ToReal(b).
3033
3034 >>> x = Int('x')
3035 >>> n = ToReal(x)
3036 >>> n
3037 ToReal(x)
3038 >>> is_to_real(n)
3039 True
3040 >>> is_to_real(x)
3041 False
3042 """
3043 return is_app_of(a, Z3_OP_TO_REAL)
3044
3045
◆ is_true()
| bool is_true | ( | Any | a | ) |
Return `True` if `a` is the Z3 true expression.
>>> p = Bool('p')
>>> is_true(p)
False
>>> is_true(simplify(p == p))
True
>>> x = Real('x')
>>> is_true(x == 0)
False
>>> # True is a Python Boolean expression
>>> is_true(True)
False
Definition at line 1681 of file z3py.py.
1681def is_true(a : Any) -> bool:
1682 """Return `True` if `a` is the Z3 true expression.
1683
1684 >>> p = Bool('p')
1685 >>> is_true(p)
1686 False
1687 >>> is_true(simplify(p == p))
1688 True
1689 >>> x = Real('x')
1690 >>> is_true(x == 0)
1691 False
1692 >>> # True is a Python Boolean expression
1693 >>> is_true(True)
1694 False
1695 """
1696 return is_app_of(a, Z3_OP_TRUE)
1697
1698
Referenced by AstRef.__bool__(), and BoolRef.py_value().
◆ is_var()
| is_var | ( | a | ) |
Return `True` if `a` is variable.
Z3 uses de-Bruijn indices for representing bound variables in
quantifiers.
>>> x = Int('x')
>>> is_var(x)
False
>>> is_const(x)
True
>>> f = Function('f', IntSort(), IntSort())
>>> # Z3 replaces x with bound variables when ForAll is executed.
>>> q = ForAll(x, f(x) == x)
>>> b = q.body()
>>> b
f(Var(0)) == Var(0)
>>> b.arg(1)
Var(0)
>>> is_var(b.arg(1))
True
Definition at line 1372 of file z3py.py.
1372def is_var(a):
1373 """Return `True` if `a` is variable.
1374
1375 Z3 uses de-Bruijn indices for representing bound variables in
1376 quantifiers.
1377
1378 >>> x = Int('x')
1379 >>> is_var(x)
1380 False
1381 >>> is_const(x)
1382 True
1383 >>> f = Function('f', IntSort(), IntSort())
1384 >>> # Z3 replaces x with bound variables when ForAll is executed.
1385 >>> q = ForAll(x, f(x) == x)
1386 >>> b = q.body()
1387 >>> b
1388 f(Var(0)) == Var(0)
1389 >>> b.arg(1)
1390 Var(0)
1391 >>> is_var(b.arg(1))
1392 True
1393 """
1394 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1395
1396
Referenced by get_var_index().
◆ IsInt()
| IsInt | ( | a | ) |
Return the Z3 predicate IsInt(a).
>>> x = Real('x')
>>> IsInt(x + "1/2")
IsInt(x + 1/2)
>>> solve(IsInt(x + "1/2"), x > 0, x < 1)
[x = 1/2]
>>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
no solution
Definition at line 3500 of file z3py.py.
3500def IsInt(a):
3501 """ Return the Z3 predicate IsInt(a).
3502
3503 >>> x = Real('x')
3504 >>> IsInt(x + "1/2")
3505 IsInt(x + 1/2)
3506 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3507 [x = 1/2]
3508 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3509 no solution
3510 """
3511 if z3_debug():
3512 _z3_assert(a.is_real(), "Z3 real expression expected.")
3513 ctx = a.ctx
3515
3516
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
◆ IsMember()
| IsMember | ( | e, | |
| s ) |
Check if e is a member of set s
>>> a = Const('a', SetSort(IntSort()))
>>> IsMember(1, a)
a[1]
Definition at line 5143 of file z3py.py.
5143def IsMember(e, s):
5144 """ Check if e is a member of set s
5145 >>> a = Const('a', SetSort(IntSort()))
5146 >>> IsMember(1, a)
5147 a[1]
5148 """
5149 ctx = _ctx_from_ast_arg_list([s, e])
5150 e = _py2expr(e, ctx)
5152
5153
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
◆ IsSubset()
| IsSubset | ( | a, | |
| b ) |
Check if a is a subset of b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> IsSubset(a, b)
subset(a, b)
Definition at line 5154 of file z3py.py.
5154def IsSubset(a, b):
5155 """ Check if a is a subset of b
5156 >>> a = Const('a', SetSort(IntSort()))
5157 >>> b = Const('b', SetSort(IntSort()))
5158 >>> IsSubset(a, b)
5159 subset(a, b)
5160 """
5161 ctx = _ctx_from_ast_arg_list([a, b])
5163
5164
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
◆ K()
| K | ( | dom, | |
| v ) |
Return a Z3 constant array expression.
>>> a = K(IntSort(), 10)
>>> a
K(Int, 10)
>>> a.sort()
Array(Int, Int)
>>> i = Int('i')
>>> a[i]
K(Int, 10)[i]
>>> simplify(a[i])
10
Definition at line 4980 of file z3py.py.
4980def K(dom, v):
4981 """Return a Z3 constant array expression.
4982
4983 >>> a = K(IntSort(), 10)
4984 >>> a
4985 K(Int, 10)
4986 >>> a.sort()
4987 Array(Int, Int)
4988 >>> i = Int('i')
4989 >>> a[i]
4990 K(Int, 10)[i]
4991 >>> simplify(a[i])
4992 10
4993 """
4994 if z3_debug():
4995 _z3_assert(is_sort(dom), "Z3 sort expected")
4996 ctx = dom.ctx
4997 if not is_expr(v):
4998 v = _py2expr(v, ctx)
5000
5001
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
Referenced by ModelRef.get_interp().
◆ Lambda()
| Lambda | ( | vs, | |
| body ) |
Create a Z3 lambda expression.
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> mem0 = Array('mem0', IntSort(), IntSort())
>>> lo, hi, e, i = Ints('lo hi e i')
>>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
>>> mem1
Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
Definition at line 2363 of file z3py.py.
2363def Lambda(vs, body):
2364 """Create a Z3 lambda expression.
2365
2366 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2367 >>> mem0 = Array('mem0', IntSort(), IntSort())
2368 >>> lo, hi, e, i = Ints('lo hi e i')
2369 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2370 >>> mem1
2371 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2372 """
2373 ctx = body.ctx
2374 if is_app(vs):
2375 vs = [vs]
2376 num_vars = len(vs)
2377 _vs = (Ast * num_vars)()
2378 for i in range(num_vars):
2379 # TODO: Check if is constant
2380 _vs[i] = vs[i].as_ast()
2382
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.
◆ LastIndexOf()
| LastIndexOf | ( | s, | |
| substr ) |
Retrieve the last index of substring within a string
Definition at line 11404 of file z3py.py.
11404def LastIndexOf(s, substr):
11405 """Retrieve the last index of substring within a string"""
11406 ctx = None
11407 ctx = _get_ctx2(s, substr, ctx)
11408 s = _coerce_seq(s, ctx)
11409 substr = _coerce_seq(substr, ctx)
11411
11412
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 -...
◆ Length()
| Length | ( | s | ) |
Obtain the length of a sequence 's'
>>> l = Length(StringVal("abc"))
>>> simplify(l)
3
Definition at line 11413 of file z3py.py.
11413def Length(s):
11414 """Obtain the length of a sequence 's'
11415 >>> l = Length(StringVal("abc"))
11416 >>> simplify(l)
11417 3
11418 """
11419 s = _coerce_seq(s)
11421
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
◆ LinearOrder()
| LinearOrder | ( | a, | |
| index ) |
◆ Loop()
| Loop | ( | re, | |
| lo, | |||
| hi = 0 ) |
Create the regular expression accepting between a lower and upper bound repetitions
>>> re = Loop(Re("a"), 1, 3)
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("aaaa", re)))
False
>>> print(simplify(InRe("", re)))
False
Definition at line 11625 of file z3py.py.
11625def Loop(re, lo, hi=0):
11626 """Create the regular expression accepting between a lower and upper bound repetitions
11627 >>> re = Loop(Re("a"), 1, 3)
11628 >>> print(simplify(InRe("aa", re)))
11629 True
11630 >>> print(simplify(InRe("aaaa", re)))
11631 False
11632 >>> print(simplify(InRe("", re)))
11633 False
11634 """
11635 if z3_debug():
11636 _z3_assert(is_expr(re), "expression expected")
11638
11639
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...
◆ LShR()
| LShR | ( | a, | |
| b ) |
Create the Z3 expression logical right shift.
Use the operator >> for the arithmetical right shift.
>>> x, y = BitVecs('x y', 32)
>>> LShR(x, y)
LShR(x, y)
>>> (x >> y).sexpr()
'(bvashr x y)'
>>> LShR(x, y).sexpr()
'(bvlshr x y)'
>>> BitVecVal(4, 3)
4
>>> BitVecVal(4, 3).as_signed_long()
-4
>>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
-2
>>> simplify(BitVecVal(4, 3) >> 1)
6
>>> simplify(LShR(BitVecVal(4, 3), 1))
2
>>> simplify(BitVecVal(2, 3) >> 1)
1
>>> simplify(LShR(BitVecVal(2, 3), 1))
1
Definition at line 4433 of file z3py.py.
4433def LShR(a, b):
4434 """Create the Z3 expression logical right shift.
4435
4436 Use the operator >> for the arithmetical right shift.
4437
4438 >>> x, y = BitVecs('x y', 32)
4439 >>> LShR(x, y)
4440 LShR(x, y)
4441 >>> (x >> y).sexpr()
4442 '(bvashr x y)'
4443 >>> LShR(x, y).sexpr()
4444 '(bvlshr x y)'
4445 >>> BitVecVal(4, 3)
4446 4
4447 >>> BitVecVal(4, 3).as_signed_long()
4448 -4
4449 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4450 -2
4451 >>> simplify(BitVecVal(4, 3) >> 1)
4452 6
4453 >>> simplify(LShR(BitVecVal(4, 3), 1))
4454 2
4455 >>> simplify(BitVecVal(2, 3) >> 1)
4456 1
4457 >>> simplify(LShR(BitVecVal(2, 3), 1))
4458 1
4459 """
4460 _check_bv_args(a, b)
4461 a, b = _coerce_exprs(a, b)
4463
4464
◆ main_ctx()
| Context main_ctx | ( | ) |
Return a reference to the global Z3 context.
>>> x = Real('x')
>>> x.ctx == main_ctx()
True
>>> c = Context()
>>> c == main_ctx()
False
>>> x2 = Real('x', c)
>>> x2.ctx == c
True
>>> eq(x, x2)
False
Definition at line 249 of file z3py.py.
249def main_ctx() -> Context:
250 """Return a reference to the global Z3 context.
251
252 >>> x = Real('x')
253 >>> x.ctx == main_ctx()
254 True
255 >>> c = Context()
256 >>> c == main_ctx()
257 False
258 >>> x2 = Real('x', c)
259 >>> x2.ctx == c
260 True
261 >>> eq(x, x2)
262 False
263 """
264 global _main_ctx
265 if _main_ctx is None:
266 _main_ctx = Context()
267 return _main_ctx
268
269
Referenced by _get_ctx().
◆ Map()
| Map | ( | f, | |
| * | args ) |
Return a Z3 map array expression.
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> a1 = Array('a1', IntSort(), IntSort())
>>> a2 = Array('a2', IntSort(), IntSort())
>>> b = Map(f, a1, a2)
>>> b
Map(f, a1, a2)
>>> prove(b[0] == f(a1[0], a2[0]))
proved
Definition at line 4957 of file z3py.py.
4957def Map(f, *args):
4958 """Return a Z3 map array expression.
4959
4960 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4961 >>> a1 = Array('a1', IntSort(), IntSort())
4962 >>> a2 = Array('a2', IntSort(), IntSort())
4963 >>> b = Map(f, a1, a2)
4964 >>> b
4965 Map(f, a1, a2)
4966 >>> prove(b[0] == f(a1[0], a2[0]))
4967 proved
4968 """
4969 args = _get_args(args)
4970 if z3_debug():
4971 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4972 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4973 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4974 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4975 _args, sz = _to_ast_array(args)
4976 ctx = f.ctx
4978
4979
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const *args)
Map f on the argument arrays.
◆ mk_not()
| mk_not | ( | a | ) |
◆ Model()
| Model | ( | ctx = None, | |
| eval = {} ) |
Definition at line 6867 of file z3py.py.
6867def Model(ctx=None, eval = {}):
6868 ctx = _get_ctx(ctx)
6869 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
6870 for k, v in eval.items():
6871 mdl.update_value(k, v)
6872 return mdl
6873
6874
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
◆ MultiPattern()
| MultiPattern | ( | * | args | ) |
Create a Z3 multi-pattern using the given expressions `*args`
>>> f = Function('f', IntSort(), IntSort())
>>> g = Function('g', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
>>> q
ForAll(x, f(x) != g(x))
>>> q.num_patterns()
1
>>> is_pattern(q.pattern(0))
True
>>> q.pattern(0)
MultiPattern(f(Var(0)), g(Var(0)))
Definition at line 2043 of file z3py.py.
2043def MultiPattern(*args):
2044 """Create a Z3 multi-pattern using the given expressions `*args`
2045
2046 >>> f = Function('f', IntSort(), IntSort())
2047 >>> g = Function('g', IntSort(), IntSort())
2048 >>> x = Int('x')
2049 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
2050 >>> q
2051 ForAll(x, f(x) != g(x))
2052 >>> q.num_patterns()
2053 1
2054 >>> is_pattern(q.pattern(0))
2055 True
2056 >>> q.pattern(0)
2057 MultiPattern(f(Var(0)), g(Var(0)))
2058 """
2059 if z3_debug():
2060 _z3_assert(len(args) > 0, "At least one argument expected")
2061 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2062 ctx = args[0].ctx
2063 args, sz = _to_ast_array(args)
2065
2066
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.
Referenced by _to_pattern().
◆ Not()
| Not | ( | a, | |
| ctx = None ) |
Create a Z3 not expression or probe.
>>> p = Bool('p')
>>> Not(Not(p))
Not(Not(p))
>>> simplify(Not(Not(p)))
p
Definition at line 1907 of file z3py.py.
1907def Not(a, ctx=None):
1908 """Create a Z3 not expression or probe.
1909
1910 >>> p = Bool('p')
1911 >>> Not(Not(p))
1912 Not(Not(p))
1913 >>> simplify(Not(Not(p)))
1914 p
1915 """
1916 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1917 if is_probe(a):
1918 # Not is also used to build probes
1920 else:
1921 s = BoolSort(ctx)
1922 a = s.cast(a)
1924
1925
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.
Referenced by BoolRef.__invert__(), and mk_not().
◆ on_clause_eh()
| on_clause_eh | ( | ctx, | |
| p, | |||
| n, | |||
| dep, | |||
| clause ) |
Definition at line 11715 of file z3py.py.
11715def on_clause_eh(ctx, p, n, dep, clause):
11716 onc = _my_hacky_class
11717 p = _to_expr_ref(to_Ast(p), onc.ctx)
11718 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11719 deps = [dep[i] for i in range(n)]
11720 onc.on_clause(p, deps, clause)
11721
◆ open_log()
| open_log | ( | fname | ) |
Log interaction to a file. This function must be invoked immediately after init().
Definition at line 122 of file z3py.py.
122def open_log(fname):
123 """Log interaction to a file. This function must be invoked immediately after init(). """
124 Z3_open_log(fname)
125
126
◆ Option()
| Option | ( | re | ) |
Create the regular expression that optionally accepts the argument.
>>> re = Option(Re("a"))
>>> print(simplify(InRe("a", re)))
True
>>> print(simplify(InRe("", re)))
True
>>> print(simplify(InRe("aa", re)))
False
Definition at line 11590 of file z3py.py.
11590def Option(re):
11591 """Create the regular expression that optionally accepts the argument.
11592 >>> re = Option(Re("a"))
11593 >>> print(simplify(InRe("a", re)))
11594 True
11595 >>> print(simplify(InRe("", re)))
11596 True
11597 >>> print(simplify(InRe("aa", re)))
11598 False
11599 """
11600 if z3_debug():
11601 _z3_assert(is_expr(re), "expression expected")
11603
11604
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
◆ Or()
| Or | ( | * | args | ) |
Create a Z3 or-expression or or-probe.
>>> p, q, r = Bools('p q r')
>>> Or(p, q, r)
Or(p, q, r)
>>> P = BoolVector('p', 5)
>>> Or(P)
Or(p__0, p__1, p__2, p__3, p__4)
Definition at line 1974 of file z3py.py.
1974def Or(*args):
1975 """Create a Z3 or-expression or or-probe.
1976
1977 >>> p, q, r = Bools('p q r')
1978 >>> Or(p, q, r)
1979 Or(p, q, r)
1980 >>> P = BoolVector('p', 5)
1981 >>> Or(P)
1982 Or(p__0, p__1, p__2, p__3, p__4)
1983 """
1984 last_arg = None
1985 if len(args) > 0:
1986 last_arg = args[len(args) - 1]
1987 if isinstance(last_arg, Context):
1988 ctx = args[len(args) - 1]
1989 args = args[:len(args) - 1]
1990 elif len(args) == 1 and isinstance(args[0], AstVector):
1991 ctx = args[0].ctx
1992 args = [a for a in args[0]]
1993 else:
1994 ctx = None
1995 args = _get_args(args)
1996 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1997 if z3_debug():
1998 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1999 if _has_probe(args):
2000 return _probe_or(args, ctx)
2001 else:
2002 args = _coerce_expr_list(args, ctx)
2003 _args, sz = _to_ast_array(args)
2005
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].
Referenced by BoolRef.__or__().
◆ OrElse()
| OrElse | ( | * | ts, |
| ** | ks ) |
Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
>>> x = Int('x')
>>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
>>> # Tactic split-clause fails if there is no clause in the given goal.
>>> t(x == 0)
[[x == 0]]
>>> t(Or(x == 0, x == 1))
[[x == 0], [x == 1]]
Definition at line 8624 of file z3py.py.
8624def OrElse(*ts, **ks):
8625 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8626
8627 >>> x = Int('x')
8628 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8629 >>> # Tactic split-clause fails if there is no clause in the given goal.
8630 >>> t(x == 0)
8631 [[x == 0]]
8632 >>> t(Or(x == 0, x == 1))
8633 [[x == 0], [x == 1]]
8634 """
8635 if z3_debug():
8636 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8637 ctx = ks.get("ctx", None)
8638 num = len(ts)
8639 r = ts[0]
8640 for i in range(num - 1):
8641 r = _or_else(r, ts[i + 1], ctx)
8642 return r
8643
8644
◆ ParAndThen()
| ParAndThen | ( | t1, | |
| t2, | |||
| ctx = None ) |
◆ ParOr()
| ParOr | ( | * | ts, |
| ** | ks ) |
Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
>>> x = Int('x')
>>> t = ParOr(Tactic('simplify'), Tactic('fail'))
>>> t(x + 1 == 2)
[[x == 1]]
Definition at line 8645 of file z3py.py.
8645def ParOr(*ts, **ks):
8646 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8647
8648 >>> x = Int('x')
8649 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8650 >>> t(x + 1 == 2)
8651 [[x == 1]]
8652 """
8653 if z3_debug():
8654 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8655 ctx = _get_ctx(ks.get("ctx", None))
8656 ts = [_to_tactic(t, ctx) for t in ts]
8657 sz = len(ts)
8658 _args = (TacticObj * sz)()
8659 for i in range(sz):
8660 _args[i] = ts[i].tactic
8662
8663
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.
◆ parse_smt2_file()
| parse_smt2_file | ( | f, | |
| sorts = {}, | |||
| decls = {}, | |||
| ctx = None ) |
Parse a file in SMT 2.0 format using the given sorts and decls. This function is similar to parse_smt2_string().
Definition at line 9560 of file z3py.py.
9560def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9561 """Parse a file in SMT 2.0 format using the given sorts and decls.
9562
9563 This function is similar to parse_smt2_string().
9564 """
9565 ctx = _get_ctx(ctx)
9566 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9567 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9568 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9569
9570
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.
◆ parse_smt2_string()
| parse_smt2_string | ( | s, | |
| sorts = {}, | |||
| decls = {}, | |||
| ctx = None ) |
Parse a string in SMT 2.0 format using the given sorts and decls.
The arguments sorts and decls are Python dictionaries used to initialize
the symbol table used for the SMT 2.0 parser.
>>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
[x > 0, x < 10]
>>> x, y = Ints('x y')
>>> f = Function('f', IntSort(), IntSort())
>>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
[x + f(y) > 0]
>>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
[a > 0]
Definition at line 9539 of file z3py.py.
9539def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9540 """Parse a string in SMT 2.0 format using the given sorts and decls.
9541
9542 The arguments sorts and decls are Python dictionaries used to initialize
9543 the symbol table used for the SMT 2.0 parser.
9544
9545 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9546 [x > 0, x < 10]
9547 >>> x, y = Ints('x y')
9548 >>> f = Function('f', IntSort(), IntSort())
9549 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9550 [x + f(y) > 0]
9551 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9552 [a > 0]
9553 """
9554 ctx = _get_ctx(ctx)
9555 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9556 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9557 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9558
9559
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.
◆ ParThen()
| ParThen | ( | t1, | |
| t2, | |||
| ctx = None ) |
Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
The subgoals are processed in parallel.
>>> x, y = Ints('x y')
>>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
>>> t(And(Or(x == 1, x == 2), y == x + 1))
[[x == 1, y == 2], [x == 2, y == 3]]
Definition at line 8664 of file z3py.py.
8664def ParThen(t1, t2, ctx=None):
8665 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8666 The subgoals are processed in parallel.
8667
8668 >>> x, y = Ints('x y')
8669 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8670 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8671 [[x == 1, y == 2], [x == 2, y == 3]]
8672 """
8673 t1 = _to_tactic(t1, ctx)
8674 t2 = _to_tactic(t2, ctx)
8675 if z3_debug():
8676 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8678
8679
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....
◆ PartialOrder()
| PartialOrder | ( | a, | |
| index ) |
◆ PbEq()
| PbEq | ( | args, | |
| k, | |||
| ctx = None ) |
Create a Pseudo-Boolean equality k constraint.
>>> a, b, c = Bools('a b c')
>>> f = PbEq(((a,1),(b,3),(c,2)), 3)
Definition at line 9316 of file z3py.py.
9316def PbEq(args, k, ctx=None):
9317 """Create a Pseudo-Boolean equality k constraint.
9318
9319 >>> a, b, c = Bools('a b c')
9320 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9321 """
9322 _z3_check_cint_overflow(k, "k")
9323 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9325
9326
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.
◆ PbGe()
| PbGe | ( | args, | |
| k ) |
Create a Pseudo-Boolean inequality k constraint.
>>> a, b, c = Bools('a b c')
>>> f = PbGe(((a,1),(b,3),(c,2)), 3)
Definition at line 9305 of file z3py.py.
9305def PbGe(args, k):
9306 """Create a Pseudo-Boolean inequality k constraint.
9307
9308 >>> a, b, c = Bools('a b c')
9309 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9310 """
9311 _z3_check_cint_overflow(k, "k")
9312 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9314
9315
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.
◆ PbLe()
| PbLe | ( | args, | |
| k ) |
Create a Pseudo-Boolean inequality k constraint.
>>> a, b, c = Bools('a b c')
>>> f = PbLe(((a,1),(b,3),(c,2)), 3)
Definition at line 9294 of file z3py.py.
9294def PbLe(args, k):
9295 """Create a Pseudo-Boolean inequality k constraint.
9296
9297 >>> a, b, c = Bools('a b c')
9298 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9299 """
9300 _z3_check_cint_overflow(k, "k")
9301 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9303
9304
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.
◆ PiecewiseLinearOrder()
| PiecewiseLinearOrder | ( | a, | |
| index ) |
◆ Plus()
| Plus | ( | re | ) |
Create the regular expression accepting one or more repetitions of argument.
>>> re = Plus(Re("a"))
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("ab", re)))
False
>>> print(simplify(InRe("", re)))
False
Definition at line 11575 of file z3py.py.
11575def Plus(re):
11576 """Create the regular expression accepting one or more repetitions of argument.
11577 >>> re = Plus(Re("a"))
11578 >>> print(simplify(InRe("aa", re)))
11579 True
11580 >>> print(simplify(InRe("ab", re)))
11581 False
11582 >>> print(simplify(InRe("", re)))
11583 False
11584 """
11585 if z3_debug():
11586 _z3_assert(is_expr(re), "expression expected")
11588
11589
◆ PrefixOf()
| PrefixOf | ( | a, | |
| b ) |
Check if 'a' is a prefix of 'b'
>>> s1 = PrefixOf("ab", "abc")
>>> simplify(s1)
True
>>> s2 = PrefixOf("bc", "abc")
>>> simplify(s2)
False
Definition at line 11320 of file z3py.py.
11320def PrefixOf(a, b):
11321 """Check if 'a' is a prefix of 'b'
11322 >>> s1 = PrefixOf("ab", "abc")
11323 >>> simplify(s1)
11324 True
11325 >>> s2 = PrefixOf("bc", "abc")
11326 >>> simplify(s2)
11327 False
11328 """
11329 ctx = _get_ctx2(a, b)
11330 a = _coerce_seq(a, ctx)
11331 b = _coerce_seq(b, ctx)
11333
11334
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.
◆ probe_description()
| probe_description | ( | name, | |
| ctx = None ) |
Return a short description for the probe named `name`.
>>> d = probe_description('memory')
Definition at line 8960 of file z3py.py.
8960def probe_description(name, ctx=None):
8961 """Return a short description for the probe named `name`.
8962
8963 >>> d = probe_description('memory')
8964 """
8965 ctx = _get_ctx(ctx)
8967
8968
Z3_string Z3_API Z3_probe_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the probe with the given name.
◆ probes()
| probes | ( | ctx = None | ) |
Return a list of all available probes in Z3.
>>> l = probes()
>>> l.count('memory') == 1
True
Definition at line 8949 of file z3py.py.
8949def probes(ctx=None):
8950 """Return a list of all available probes in Z3.
8951
8952 >>> l = probes()
8953 >>> l.count('memory') == 1
8954 True
8955 """
8956 ctx = _get_ctx(ctx)
8958
8959
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.
◆ Product()
| Product | ( | * | args | ) |
Create the product of the Z3 expressions.
>>> a, b, c = Ints('a b c')
>>> Product(a, b, c)
a*b*c
>>> Product([a, b, c])
a*b*c
>>> A = IntVector('a', 5)
>>> Product(A)
a__0*a__1*a__2*a__3*a__4
Definition at line 9201 of file z3py.py.
9201def Product(*args):
9202 """Create the product of the Z3 expressions.
9203
9204 >>> a, b, c = Ints('a b c')
9205 >>> Product(a, b, c)
9206 a*b*c
9207 >>> Product([a, b, c])
9208 a*b*c
9209 >>> A = IntVector('a', 5)
9210 >>> Product(A)
9211 a__0*a__1*a__2*a__3*a__4
9212 """
9213 args = _get_args(args)
9214 if len(args) == 0:
9215 return 1
9216 ctx = _ctx_from_ast_arg_list(args)
9217 if ctx is None:
9218 return _reduce(lambda a, b: a * b, args, 1)
9219 args = _coerce_expr_list(args, ctx)
9220 if is_bv(args[0]):
9221 return _reduce(lambda a, b: a * b, args, 1)
9222 else:
9223 _args, sz = _to_ast_array(args)
9225
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].
◆ PropagateFunction()
| PropagateFunction | ( | name, | |
| * | sig ) |
Create a function that gets tracked by user propagator. Every term headed by this function symbol is tracked. If a term is fixed and the fixed callback is registered a callback is invoked that the term headed by this function is fixed.
Definition at line 11880 of file z3py.py.
11880def PropagateFunction(name, *sig):
11881 """Create a function that gets tracked by user propagator.
11882 Every term headed by this function symbol is tracked.
11883 If a term is fixed and the fixed callback is registered a
11884 callback is invoked that the term headed by this function is fixed.
11885 """
11886 sig = _get_args(sig)
11887 if z3_debug():
11888 _z3_assert(len(sig) > 0, "At least two arguments expected")
11889 arity = len(sig) - 1
11890 rng = sig[arity]
11891 if z3_debug():
11892 _z3_assert(is_sort(rng), "Z3 sort expected")
11893 dom = (Sort * arity)()
11894 for i in range(arity):
11895 if z3_debug():
11896 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11897 dom[i] = sig[i].ast
11898 ctx = rng.ctx
11899 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11900
11901
11902
Z3_func_decl Z3_API Z3_solver_propagate_declare(Z3_context c, Z3_symbol name, unsigned n, Z3_sort *domain, Z3_sort range)
◆ prove()
| prove | ( | claim, | |
| show = False, | |||
| ** | keywords ) |
Try to prove the given claim.
This is a simple function for creating demonstrations. It tries to prove
`claim` by showing the negation is unsatisfiable.
>>> p, q = Bools('p q')
>>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
proved
Definition at line 9388 of file z3py.py.
9388def prove(claim, show=False, **keywords):
9389 """Try to prove the given claim.
9390
9391 This is a simple function for creating demonstrations. It tries to prove
9392 `claim` by showing the negation is unsatisfiable.
9393
9394 >>> p, q = Bools('p q')
9395 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9396 proved
9397 """
9398 if z3_debug():
9399 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9400 s = Solver()
9401 s.set(**keywords)
9402 s.add(Not(claim))
9403 if show:
9404 print(s)
9405 r = s.check()
9406 if r == unsat:
9407 print("proved")
9408 elif r == unknown:
9409 print("failed to prove")
9410 print(s.model())
9411 else:
9412 print("counterexample")
9413 print(s.model())
9414
9415
◆ Q()
| Q | ( | a, | |
| b, | |||
| ctx = None ) |
Return a Z3 rational a/b. If `ctx=None`, then the global context is used. >>> Q(3,5) 3/5 >>> Q(3,5).sort() Real
Definition at line 3339 of file z3py.py.
3339def Q(a, b, ctx=None):
3340 """Return a Z3 rational a/b.
3341
3342 If `ctx=None`, then the global context is used.
3343
3344 >>> Q(3,5)
3345 3/5
3346 >>> Q(3,5).sort()
3347 Real
3348 """
3349 return simplify(RatVal(a, b, ctx=ctx))
3350
3351
◆ Range()
| Range | ( | lo, | |
| hi, | |||
| ctx = None ) |
Create the range regular expression over two sequences of length 1
>>> range = Range("a","z")
>>> print(simplify(InRe("b", range)))
True
>>> print(simplify(InRe("bb", range)))
False
Definition at line 11640 of file z3py.py.
11640def Range(lo, hi, ctx=None):
11641 """Create the range regular expression over two sequences of length 1
11642 >>> range = Range("a","z")
11643 >>> print(simplify(InRe("b", range)))
11644 True
11645 >>> print(simplify(InRe("bb", range)))
11646 False
11647 """
11648 lo = _coerce_seq(lo, ctx)
11649 hi = _coerce_seq(hi, ctx)
11650 if z3_debug():
11651 _z3_assert(is_expr(lo), "expression expected")
11652 _z3_assert(is_expr(hi), "expression expected")
11654
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.
◆ RatVal()
| RatVal | ( | a, | |
| b, | |||
| ctx = None ) |
Return a Z3 rational a/b. If `ctx=None`, then the global context is used. >>> RatVal(3,5) 3/5 >>> RatVal(3,5).sort() Real
Definition at line 3323 of file z3py.py.
3323def RatVal(a, b, ctx=None):
3324 """Return a Z3 rational a/b.
3325
3326 If `ctx=None`, then the global context is used.
3327
3328 >>> RatVal(3,5)
3329 3/5
3330 >>> RatVal(3,5).sort()
3331 Real
3332 """
3333 if z3_debug():
3334 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3335 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3336 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3337
3338
Referenced by Q().
◆ Re()
| Re | ( | s, | |
| ctx = None ) |
The regular expression that accepts sequence 's'
>>> s1 = Re("ab")
>>> s2 = Re(StringVal("ab"))
>>> s3 = Re(Unit(BoolVal(True)))
Definition at line 11484 of file z3py.py.
11484def Re(s, ctx=None):
11485 """The regular expression that accepts sequence 's'
11486 >>> s1 = Re("ab")
11487 >>> s2 = Re(StringVal("ab"))
11488 >>> s3 = Re(Unit(BoolVal(True)))
11489 """
11490 s = _coerce_seq(s, ctx)
11492
11493
11494# Regular expressions
11495
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
◆ Real()
| Real | ( | name, | |
| ctx = None ) |
Return a real constant named `name`. If `ctx=None`, then the global context is used.
>>> x = Real('x')
>>> is_real(x)
True
>>> is_real(x + 1)
True
Definition at line 3405 of file z3py.py.
3405def Real(name, ctx=None):
3406 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3407
3408 >>> x = Real('x')
3409 >>> is_real(x)
3410 True
3411 >>> is_real(x + 1)
3412 True
3413 """
3414 ctx = _get_ctx(ctx)
3416
3417
Referenced by Reals(), and RealVector().
◆ Reals()
| Reals | ( | names, | |
| ctx = None ) |
Return a tuple of real constants.
>>> x, y, z = Reals('x y z')
>>> Sum(x, y, z)
x + y + z
>>> Sum(x, y, z).sort()
Real
Definition at line 3418 of file z3py.py.
3418def Reals(names, ctx=None):
3419 """Return a tuple of real constants.
3420
3421 >>> x, y, z = Reals('x y z')
3422 >>> Sum(x, y, z)
3423 x + y + z
3424 >>> Sum(x, y, z).sort()
3425 Real
3426 """
3427 ctx = _get_ctx(ctx)
3428 if isinstance(names, str):
3429 names = names.split(" ")
3430 return [Real(name, ctx) for name in names]
3431
3432
◆ RealSort()
| RealSort | ( | ctx = None | ) |
Return the real sort in the given context. If `ctx=None`, then the global context is used.
>>> RealSort()
Real
>>> x = Const('x', RealSort())
>>> is_real(x)
True
>>> is_int(x)
False
>>> x.sort() == RealSort()
True
Definition at line 3263 of file z3py.py.
3263def RealSort(ctx=None):
3264 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3265
3266 >>> RealSort()
3267 Real
3268 >>> x = Const('x', RealSort())
3269 >>> is_real(x)
3270 True
3271 >>> is_int(x)
3272 False
3273 >>> x.sort() == RealSort()
3274 True
3275 """
3276 ctx = _get_ctx(ctx)
3278
3279
Referenced by FreshReal(), Real(), RealVal(), and RealVar().
◆ RealVal()
| RealVal | ( | val, | |
| ctx = None ) |
Return a Z3 real value.
`val` may be a Python int, long, float or string representing a number in decimal or rational notation.
If `ctx=None`, then the global context is used.
>>> RealVal(1)
1
>>> RealVal(1).sort()
Real
>>> RealVal("3/5")
3/5
>>> RealVal("1.5")
3/2
Definition at line 3304 of file z3py.py.
3304def RealVal(val, ctx=None):
3305 """Return a Z3 real value.
3306
3307 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3308 If `ctx=None`, then the global context is used.
3309
3310 >>> RealVal(1)
3311 1
3312 >>> RealVal(1).sort()
3313 Real
3314 >>> RealVal("3/5")
3315 3/5
3316 >>> RealVal("1.5")
3317 3/2
3318 """
3319 ctx = _get_ctx(ctx)
3321
3322
Referenced by _coerce_exprs(), _py2expr(), Cbrt(), RatVal(), Sqrt(), and ToReal().
◆ RealVar()
| ExprRef RealVar | ( | int | idx, |
| ctx = None ) |
Create a real free variable. Free variables are used to create quantified formulas. They are also used to create polynomials. >>> RealVar(0) Var(0)
Definition at line 1549 of file z3py.py.
1549def RealVar(idx: int, ctx=None) -> ExprRef:
1550 """
1551 Create a real free variable. Free variables are used to create quantified formulas.
1552 They are also used to create polynomials.
1553
1554 >>> RealVar(0)
1555 Var(0)
1556 """
1557 return Var(idx, RealSort(ctx))
1558
Referenced by RealVarVector().
◆ RealVarVector()
| RealVarVector | ( | int | n, |
| ctx = None ) |
Create a list of Real free variables. The variables have ids: 0, 1, ..., n-1 >>> x0, x1, x2, x3 = RealVarVector(4) >>> x2 Var(2)
Definition at line 1559 of file z3py.py.
1559def RealVarVector(n: int, ctx= None):
1560 """
1561 Create a list of Real free variables.
1562 The variables have ids: 0, 1, ..., n-1
1563
1564 >>> x0, x1, x2, x3 = RealVarVector(4)
1565 >>> x2
1566 Var(2)
1567 """
1568 return [RealVar(i, ctx) for i in range(n)]
1569
◆ RealVector()
| RealVector | ( | prefix, | |
| sz, | |||
| ctx = None ) |
Return a list of real constants of size `sz`.
>>> X = RealVector('x', 3)
>>> X
[x__0, x__1, x__2]
>>> Sum(X)
x__0 + x__1 + x__2
>>> Sum(X).sort()
Real
Definition at line 3433 of file z3py.py.
3433def RealVector(prefix, sz, ctx=None):
3434 """Return a list of real constants of size `sz`.
3435
3436 >>> X = RealVector('x', 3)
3437 >>> X
3438 [x__0, x__1, x__2]
3439 >>> Sum(X)
3440 x__0 + x__1 + x__2
3441 >>> Sum(X).sort()
3442 Real
3443 """
3444 ctx = _get_ctx(ctx)
3445 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3446
3447
◆ RecAddDefinition()
| RecAddDefinition | ( | f, | |
| args, | |||
| body ) |
Set the body of a recursive function.
Recursive definitions can be simplified if they are applied to ground
arguments.
>>> ctx = Context()
>>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
>>> n = Int('n', ctx)
>>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
>>> simplify(fac(5))
120
>>> s = Solver(ctx=ctx)
>>> s.add(fac(n) < 3)
>>> s.check()
sat
>>> s.model().eval(fac(5))
120
Definition at line 967 of file z3py.py.
967def RecAddDefinition(f, args, body):
968 """Set the body of a recursive function.
969 Recursive definitions can be simplified if they are applied to ground
970 arguments.
971 >>> ctx = Context()
972 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
973 >>> n = Int('n', ctx)
974 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
975 >>> simplify(fac(5))
976 120
977 >>> s = Solver(ctx=ctx)
978 >>> s.add(fac(n) < 3)
979 >>> s.check()
980 sat
981 >>> s.model().eval(fac(5))
982 120
983 """
984 if is_app(args):
985 args = [args]
986 ctx = body.ctx
987 args = _get_args(args)
988 n = len(args)
989 _args = (Ast * n)()
990 for i in range(n):
991 _args[i] = args[i].ast
992 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
993
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.
◆ RecFunction()
| RecFunction | ( | name, | |
| * | sig ) |
Create a new Z3 recursive with the given sorts.
Definition at line 949 of file z3py.py.
949def RecFunction(name, *sig):
950 """Create a new Z3 recursive with the given sorts."""
951 sig = _get_args(sig)
952 if z3_debug():
953 _z3_assert(len(sig) > 0, "At least two arguments expected")
954 arity = len(sig) - 1
955 rng = sig[arity]
956 if z3_debug():
957 _z3_assert(is_sort(rng), "Z3 sort expected")
958 dom = (Sort * arity)()
959 for i in range(arity):
960 if z3_debug():
961 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
962 dom[i] = sig[i].ast
963 ctx = rng.ctx
964 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
965
966
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.
◆ Repeat()
| Repeat | ( | t, | |
| max = 4294967295, | |||
| ctx = None ) |
Return a tactic that keeps applying `t` until the goal is not modified anymore
or the maximum number of iterations `max` is reached.
>>> x, y = Ints('x y')
>>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
>>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
>>> r = t(c)
>>> for subgoal in r: print(subgoal)
[x == 0, y == 0, x > y]
[x == 0, y == 1, x > y]
[x == 1, y == 0, x > y]
[x == 1, y == 1, x > y]
>>> t = Then(t, Tactic('propagate-values'))
>>> t(c)
[[x == 1, y == 0]]
Definition at line 8713 of file z3py.py.
8713def Repeat(t, max=4294967295, ctx=None):
8714 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8715 or the maximum number of iterations `max` is reached.
8716
8717 >>> x, y = Ints('x y')
8718 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8719 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8720 >>> r = t(c)
8721 >>> for subgoal in r: print(subgoal)
8722 [x == 0, y == 0, x > y]
8723 [x == 0, y == 1, x > y]
8724 [x == 1, y == 0, x > y]
8725 [x == 1, y == 1, x > y]
8726 >>> t = Then(t, Tactic('propagate-values'))
8727 >>> t(c)
8728 [[x == 1, y == 0]]
8729 """
8730 t = _to_tactic(t, ctx)
8732
8733
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...
◆ RepeatBitVec()
| RepeatBitVec | ( | n, | |
| a ) |
Return an expression representing `n` copies of `a`.
>>> x = BitVec('x', 8)
>>> n = RepeatBitVec(4, x)
>>> n
RepeatBitVec(4, x)
>>> n.size()
32
>>> v0 = BitVecVal(10, 4)
>>> print("%.x" % v0.as_long())
a
>>> v = simplify(RepeatBitVec(4, v0))
>>> v.size()
16
>>> print("%.x" % v.as_long())
aaaa
Definition at line 4555 of file z3py.py.
4555def RepeatBitVec(n, a):
4556 """Return an expression representing `n` copies of `a`.
4557
4558 >>> x = BitVec('x', 8)
4559 >>> n = RepeatBitVec(4, x)
4560 >>> n
4561 RepeatBitVec(4, x)
4562 >>> n.size()
4563 32
4564 >>> v0 = BitVecVal(10, 4)
4565 >>> print("%.x" % v0.as_long())
4566 a
4567 >>> v = simplify(RepeatBitVec(4, v0))
4568 >>> v.size()
4569 16
4570 >>> print("%.x" % v.as_long())
4571 aaaa
4572 """
4573 if z3_debug():
4574 _z3_assert(_is_int(n), "First argument must be an integer")
4575 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4577
4578
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
◆ Replace()
| Replace | ( | s, | |
| src, | |||
| dst ) |
Replace the first occurrence of 'src' by 'dst' in 's'
>>> r = Replace("aaa", "a", "b")
>>> simplify(r)
"baa"
Definition at line 11369 of file z3py.py.
11369def Replace(s, src, dst):
11370 """Replace the first occurrence of 'src' by 'dst' in 's'
11371 >>> r = Replace("aaa", "a", "b")
11372 >>> simplify(r)
11373 "baa"
11374 """
11375 ctx = _get_ctx2(dst, s)
11376 if ctx is None and is_expr(src):
11377 ctx = src.ctx
11378 src = _coerce_seq(src, ctx)
11379 dst = _coerce_seq(dst, ctx)
11380 s = _coerce_seq(s, ctx)
11381 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11382
11383
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.
◆ reset_params()
| None reset_params | ( | ) |
Reset all global (or module) parameters.
Definition at line 305 of file z3py.py.
305def reset_params() -> None:
306 """Reset all global (or module) parameters.
307 """
309
310
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...
◆ ReSort()
| ReSort | ( | s | ) |
Definition at line 11503 of file z3py.py.
11503def ReSort(s):
11504 if is_ast(s):
11506 if s is None or isinstance(s, Context):
11507 ctx = _get_ctx(s)
11509 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11510
11511
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
◆ RNA()
| RNA | ( | ctx = None | ) |
◆ RNE()
| RNE | ( | ctx = None | ) |
◆ RotateLeft()
| RotateLeft | ( | a, | |
| b ) |
Return an expression representing `a` rotated to the left `b` times.
>>> a, b = BitVecs('a b', 16)
>>> RotateLeft(a, b)
RotateLeft(a, b)
>>> simplify(RotateLeft(a, 0))
a
>>> simplify(RotateLeft(a, 16))
a
Definition at line 4465 of file z3py.py.
4465def RotateLeft(a, b):
4466 """Return an expression representing `a` rotated to the left `b` times.
4467
4468 >>> a, b = BitVecs('a b', 16)
4469 >>> RotateLeft(a, b)
4470 RotateLeft(a, b)
4471 >>> simplify(RotateLeft(a, 0))
4472 a
4473 >>> simplify(RotateLeft(a, 16))
4474 a
4475 """
4476 _check_bv_args(a, b)
4477 a, b = _coerce_exprs(a, b)
4479
4480
Z3_ast Z3_API Z3_mk_ext_rotate_left(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the left t2 times.
◆ RotateRight()
| RotateRight | ( | a, | |
| b ) |
Return an expression representing `a` rotated to the right `b` times.
>>> a, b = BitVecs('a b', 16)
>>> RotateRight(a, b)
RotateRight(a, b)
>>> simplify(RotateRight(a, 0))
a
>>> simplify(RotateRight(a, 16))
a
Definition at line 4481 of file z3py.py.
4481def RotateRight(a, b):
4482 """Return an expression representing `a` rotated to the right `b` times.
4483
4484 >>> a, b = BitVecs('a b', 16)
4485 >>> RotateRight(a, b)
4486 RotateRight(a, b)
4487 >>> simplify(RotateRight(a, 0))
4488 a
4489 >>> simplify(RotateRight(a, 16))
4490 a
4491 """
4492 _check_bv_args(a, b)
4493 a, b = _coerce_exprs(a, b)
4495
4496
Z3_ast Z3_API Z3_mk_ext_rotate_right(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the right t2 times.
◆ RoundNearestTiesToAway()
| RoundNearestTiesToAway | ( | ctx = None | ) |
◆ RoundNearestTiesToEven()
| RoundNearestTiesToEven | ( | ctx = None | ) |
◆ RoundTowardNegative()
| RoundTowardNegative | ( | ctx = None | ) |
◆ RoundTowardPositive()
| RoundTowardPositive | ( | ctx = None | ) |
◆ RoundTowardZero()
| RoundTowardZero | ( | ctx = None | ) |
◆ RTN()
| RTN | ( | ctx = None | ) |
◆ RTP()
| RTP | ( | ctx = None | ) |
◆ RTZ()
| RTZ | ( | ctx = None | ) |
◆ Select()
| Select | ( | a, | |
| * | args ) |
Return a Z3 select array expression.
>>> a = Array('a', IntSort(), IntSort())
>>> i = Int('i')
>>> Select(a, i)
a[i]
>>> eq(Select(a, i), a[i])
True
Definition at line 4941 of file z3py.py.
4941def Select(a, *args):
4942 """Return a Z3 select array expression.
4943
4944 >>> a = Array('a', IntSort(), IntSort())
4945 >>> i = Int('i')
4946 >>> Select(a, i)
4947 a[i]
4948 >>> eq(Select(a, i), a[i])
4949 True
4950 """
4951 args = _get_args(args)
4952 if z3_debug():
4953 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4954 return a[args]
4955
4956
◆ SeqFoldLeft()
| SeqFoldLeft | ( | f, | |
| a, | |||
| s ) |
Definition at line 11436 of file z3py.py.
11436def SeqFoldLeft(f, a, s):
11437 ctx = _get_ctx2(f, s)
11438 s = _coerce_seq(s, ctx)
11439 a = _py2expr(a)
11441
Z3_ast Z3_API Z3_mk_seq_foldl(Z3_context c, Z3_ast f, Z3_ast a, Z3_ast s)
Create a fold of the function f over the sequence s with accumulator a.
◆ SeqFoldLeftI()
| SeqFoldLeftI | ( | f, | |
| i, | |||
| a, | |||
| s ) |
Definition at line 11442 of file z3py.py.
11442def SeqFoldLeftI(f, i, a, s):
11443 ctx = _get_ctx2(f, s)
11444 s = _coerce_seq(s, ctx)
11445 a = _py2expr(a)
11446 i = _py2expr(i)
11447 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11448
Z3_ast Z3_API Z3_mk_seq_foldli(Z3_context c, Z3_ast f, Z3_ast i, Z3_ast a, Z3_ast s)
Create a fold with index tracking of the function f over the sequence s with accumulator a starting a...
◆ SeqMap()
| SeqMap | ( | f, | |
| s ) |
Map function 'f' over sequence 's'
Definition at line 11422 of file z3py.py.
11422def SeqMap(f, s):
11423 """Map function 'f' over sequence 's'"""
11424 ctx = _get_ctx2(f, s)
11425 s = _coerce_seq(s, ctx)
11427
Z3_ast Z3_API Z3_mk_seq_map(Z3_context c, Z3_ast f, Z3_ast s)
Create a map of the function f over the sequence s.
◆ SeqMapI()
| SeqMapI | ( | f, | |
| i, | |||
| s ) |
Map function 'f' over sequence 's' at index 'i'
Definition at line 11428 of file z3py.py.
11428def SeqMapI(f, i, s):
11429 """Map function 'f' over sequence 's' at index 'i'"""
11430 ctx = _get_ctx2(f, s)
11431 s = _coerce_seq(s, ctx)
11432 if not is_expr(i):
11433 i = _py2expr(i)
11435
Z3_ast Z3_API Z3_mk_seq_mapi(Z3_context c, Z3_ast f, Z3_ast i, Z3_ast s)
Create a map of the function f over the sequence s starting at index i.
◆ SeqSort()
| SeqSort | ( | s | ) |
Create a sequence sort over elements provided in the argument >>> s = SeqSort(IntSort()) >>> s == Unit(IntVal(1)).sort() True
Definition at line 11069 of file z3py.py.
11069def SeqSort(s):
11070 """Create a sequence sort over elements provided in the argument
11071 >>> s = SeqSort(IntSort())
11072 >>> s == Unit(IntVal(1)).sort()
11073 True
11074 """
11076
11077
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.
◆ set_default_fp_sort()
| set_default_fp_sort | ( | ebits, | |
| sbits, | |||
| ctx = None ) |
◆ set_default_rounding_mode()
| set_default_rounding_mode | ( | rm, | |
| ctx = None ) |
Definition at line 9608 of file z3py.py.
9608def set_default_rounding_mode(rm, ctx=None):
9609 global _dflt_rounding_mode
9610 if is_fprm_value(rm):
9611 _dflt_rounding_mode = rm.kind()
9612 else:
9613 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9614 _dflt_rounding_mode = rm
9615
9616
◆ set_option()
| set_option | ( | * | args, |
| ** | kws ) |
◆ set_param()
| set_param | ( | * | args, |
| ** | kws ) |
Set Z3 global (or module) parameters. >>> set_param(precision=10)
Definition at line 281 of file z3py.py.
281def set_param(*args, **kws):
282 """Set Z3 global (or module) parameters.
283
284 >>> set_param(precision=10)
285 """
286 if z3_debug():
287 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
288 new_kws = {}
289 for k in kws:
290 v = kws[k]
291 if not set_pp_option(k, v):
292 new_kws[k] = v
293 for key in new_kws:
294 value = new_kws[key]
295 Z3_global_param_set(str(key).upper(), _to_param_value(value))
296 prev = None
297 for a in args:
298 if prev is None:
299 prev = a
300 else:
301 Z3_global_param_set(str(prev), _to_param_value(a))
302 prev = None
303
304
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.
Referenced by set_option().
◆ SetAdd()
| SetAdd | ( | s, | |
| e ) |
Add element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetAdd(a, 1)
Store(a, 1, True)
Definition at line 5100 of file z3py.py.
5100def SetAdd(s, e):
5101 """ Add element e to set s
5102 >>> a = Const('a', SetSort(IntSort()))
5103 >>> SetAdd(a, 1)
5104 Store(a, 1, True)
5105 """
5106 ctx = _ctx_from_ast_arg_list([s, e])
5107 e = _py2expr(e, ctx)
5109
5110
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
◆ SetComplement()
| SetComplement | ( | s | ) |
The complement of set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetComplement(a)
complement(a)
Definition at line 5122 of file z3py.py.
5122def SetComplement(s):
5123 """ The complement of set s
5124 >>> a = Const('a', SetSort(IntSort()))
5125 >>> SetComplement(a)
5126 complement(a)
5127 """
5128 ctx = s.ctx
5130
5131
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
◆ SetDel()
| SetDel | ( | s, | |
| e ) |
Remove element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetDel(a, 1)
Store(a, 1, False)
Definition at line 5111 of file z3py.py.
5111def SetDel(s, e):
5112 """ Remove element e to set s
5113 >>> a = Const('a', SetSort(IntSort()))
5114 >>> SetDel(a, 1)
5115 Store(a, 1, False)
5116 """
5117 ctx = _ctx_from_ast_arg_list([s, e])
5118 e = _py2expr(e, ctx)
5120
5121
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
◆ SetDifference()
| SetDifference | ( | a, | |
| b ) |
The set difference of a and b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetDifference(a, b)
setminus(a, b)
Definition at line 5132 of file z3py.py.
5132def SetDifference(a, b):
5133 """ The set difference of a and b
5134 >>> a = Const('a', SetSort(IntSort()))
5135 >>> b = Const('b', SetSort(IntSort()))
5136 >>> SetDifference(a, b)
5137 setminus(a, b)
5138 """
5139 ctx = _ctx_from_ast_arg_list([a, b])
5141
5142
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
◆ SetHasSize()
| SetHasSize | ( | a, | |
| k ) |
◆ SetIntersect()
| SetIntersect | ( | * | args | ) |
Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetIntersect(a, b)
intersection(a, b)
Definition at line 5087 of file z3py.py.
5087def SetIntersect(*args):
5088 """ Take the union of sets
5089 >>> a = Const('a', SetSort(IntSort()))
5090 >>> b = Const('b', SetSort(IntSort()))
5091 >>> SetIntersect(a, b)
5092 intersection(a, b)
5093 """
5094 args = _get_args(args)
5095 ctx = _ctx_from_ast_arg_list(args)
5096 _args, sz = _to_ast_array(args)
5098
5099
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.
◆ SetSort()
| SetSort | ( | s | ) |
◆ SetUnion()
| SetUnion | ( | * | args | ) |
Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetUnion(a, b)
union(a, b)
Definition at line 5074 of file z3py.py.
5074def SetUnion(*args):
5075 """ Take the union of sets
5076 >>> a = Const('a', SetSort(IntSort()))
5077 >>> b = Const('b', SetSort(IntSort()))
5078 >>> SetUnion(a, b)
5079 union(a, b)
5080 """
5081 args = _get_args(args)
5082 ctx = _ctx_from_ast_arg_list(args)
5083 _args, sz = _to_ast_array(args)
5085
5086
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.
◆ SignExt()
| SignExt | ( | n, | |
| a ) |
Return a bit-vector expression with `n` extra sign-bits.
>>> x = BitVec('x', 16)
>>> n = SignExt(8, x)
>>> n.size()
24
>>> n
SignExt(8, x)
>>> n.sort()
BitVec(24)
>>> v0 = BitVecVal(2, 2)
>>> v0
2
>>> v0.size()
2
>>> v = simplify(SignExt(6, v0))
>>> v
254
>>> v.size()
8
>>> print("%.x" % v.as_long())
fe
Definition at line 4497 of file z3py.py.
4497def SignExt(n, a):
4498 """Return a bit-vector expression with `n` extra sign-bits.
4499
4500 >>> x = BitVec('x', 16)
4501 >>> n = SignExt(8, x)
4502 >>> n.size()
4503 24
4504 >>> n
4505 SignExt(8, x)
4506 >>> n.sort()
4507 BitVec(24)
4508 >>> v0 = BitVecVal(2, 2)
4509 >>> v0
4510 2
4511 >>> v0.size()
4512 2
4513 >>> v = simplify(SignExt(6, v0))
4514 >>> v
4515 254
4516 >>> v.size()
4517 8
4518 >>> print("%.x" % v.as_long())
4519 fe
4520 """
4521 if z3_debug():
4522 _z3_assert(_is_int(n), "First argument must be an integer")
4523 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4525
4526
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,...
◆ SimpleSolver()
| SimpleSolver | ( | ctx = None, | |
| logFile = None ) |
Return a simple general purpose solver with limited amount of preprocessing.
>>> s = SimpleSolver()
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.check()
sat
Definition at line 7640 of file z3py.py.
7640def SimpleSolver(ctx=None, logFile=None):
7641 """Return a simple general purpose solver with limited amount of preprocessing.
7642
7643 >>> s = SimpleSolver()
7644 >>> x = Int('x')
7645 >>> s.add(x > 0)
7646 >>> s.check()
7647 sat
7648 """
7649 ctx = _get_ctx(ctx)
7651
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
◆ simplify()
| simplify | ( | a, | |
| * | arguments, | ||
| ** | keywords ) |
Utils.
Simplify the expression `a` using the given options.
This function has many options. Use `help_simplify` to obtain the complete list.
>>> x = Int('x')
>>> y = Int('y')
>>> simplify(x + 1 + y + x + 1)
2 + 2*x + y
>>> simplify((x + 1)*(y + 1), som=True)
1 + x + y + x*y
>>> simplify(Distinct(x, y, 1), blast_distinct=True)
And(Not(x == y), Not(x == 1), Not(y == 1))
>>> simplify(And(x == 0, y == 1), elim_and=True)
Not(Or(Not(x == 0), Not(y == 1)))
Definition at line 9065 of file z3py.py.
9065def simplify(a, *arguments, **keywords):
9066 """Simplify the expression `a` using the given options.
9067
9068 This function has many options. Use `help_simplify` to obtain the complete list.
9069
9070 >>> x = Int('x')
9071 >>> y = Int('y')
9072 >>> simplify(x + 1 + y + x + 1)
9073 2 + 2*x + y
9074 >>> simplify((x + 1)*(y + 1), som=True)
9075 1 + x + y + x*y
9076 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9077 And(Not(x == y), Not(x == 1), Not(y == 1))
9078 >>> simplify(And(x == 0, y == 1), elim_and=True)
9079 Not(Or(Not(x == 0), Not(y == 1)))
9080 """
9081 if z3_debug():
9082 _z3_assert(is_expr(a), "Z3 expression expected")
9083 if len(arguments) > 0 or len(keywords) > 0:
9084 p = args2params(arguments, keywords, a.ctx)
9086 else:
9088
9089
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
◆ simplify_param_descrs()
| simplify_param_descrs | ( | ) |
Return the set of parameter descriptions for Z3 `simplify` procedure.
Definition at line 9095 of file z3py.py.
9095def simplify_param_descrs():
9096 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9098
9099
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
◆ solve()
| solve | ( | * | args, |
| ** | keywords ) |
Solve the constraints `*args`.
This is a simple function for creating demonstrations. It creates a solver,
configure it using the options in `keywords`, adds the constraints
in `args`, and invokes check.
>>> a = Int('a')
>>> solve(a > 0, a < 2)
[a = 1]
Definition at line 9327 of file z3py.py.
9327def solve(*args, **keywords):
9328 """Solve the constraints `*args`.
9329
9330 This is a simple function for creating demonstrations. It creates a solver,
9331 configure it using the options in `keywords`, adds the constraints
9332 in `args`, and invokes check.
9333
9334 >>> a = Int('a')
9335 >>> solve(a > 0, a < 2)
9336 [a = 1]
9337 """
9338 show = keywords.pop("show", False)
9339 s = Solver()
9340 s.set(**keywords)
9341 s.add(*args)
9342 if show:
9343 print(s)
9344 r = s.check()
9345 if r == unsat:
9346 print("no solution")
9347 elif r == unknown:
9348 print("failed to solve")
9349 try:
9350 print(s.model())
9351 except Z3Exception:
9352 return
9353 else:
9354 print(s.model())
9355
9356
◆ solve_using()
| solve_using | ( | s, | |
| * | args, | ||
| ** | keywords ) |
Solve the constraints `*args` using solver `s`. This is a simple function for creating demonstrations. It is similar to `solve`, but it uses the given solver `s`. It configures solver `s` using the options in `keywords`, adds the constraints in `args`, and invokes check.
Definition at line 9357 of file z3py.py.
9357def solve_using(s, *args, **keywords):
9358 """Solve the constraints `*args` using solver `s`.
9359
9360 This is a simple function for creating demonstrations. It is similar to `solve`,
9361 but it uses the given solver `s`.
9362 It configures solver `s` using the options in `keywords`, adds the constraints
9363 in `args`, and invokes check.
9364 """
9365 show = keywords.pop("show", False)
9366 if z3_debug():
9367 _z3_assert(isinstance(s, Solver), "Solver object expected")
9368 s.set(**keywords)
9369 s.add(*args)
9370 if show:
9371 print("Problem:")
9372 print(s)
9373 r = s.check()
9374 if r == unsat:
9375 print("no solution")
9376 elif r == unknown:
9377 print("failed to solve")
9378 try:
9379 print(s.model())
9380 except Z3Exception:
9381 return
9382 else:
9383 if show:
9384 print("Solution:")
9385 print(s.model())
9386
9387
◆ SolverFor()
| SolverFor | ( | logic, | |
| ctx = None, | |||
| logFile = None ) |
Create a solver customized for the given logic.
The parameter `logic` is a string. It should be contains
the name of a SMT-LIB logic.
See http://www.smtlib.org/ for the name of all available logics.
>>> s = SolverFor("QF_LIA")
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.add(x < 2)
>>> s.check()
sat
>>> s.model()
[x = 1]
Definition at line 7619 of file z3py.py.
7619def SolverFor(logic, ctx=None, logFile=None):
7620 """Create a solver customized for the given logic.
7621
7622 The parameter `logic` is a string. It should be contains
7623 the name of a SMT-LIB logic.
7624 See http://www.smtlib.org/ for the name of all available logics.
7625
7626 >>> s = SolverFor("QF_LIA")
7627 >>> x = Int('x')
7628 >>> s.add(x > 0)
7629 >>> s.add(x < 2)
7630 >>> s.check()
7631 sat
7632 >>> s.model()
7633 [x = 1]
7634 """
7635 ctx = _get_ctx(ctx)
7636 logic = to_symbol(logic)
7638
7639
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...
◆ Sqrt()
| Sqrt | ( | a, | |
| ctx = None ) |
Return a Z3 expression which represents the square root of a.
>>> x = Real('x')
>>> Sqrt(x)
x**(1/2)
Definition at line 3517 of file z3py.py.
3517def Sqrt(a, ctx=None):
3518 """ Return a Z3 expression which represents the square root of a.
3519
3520 >>> x = Real('x')
3521 >>> Sqrt(x)
3522 x**(1/2)
3523 """
3524 if not is_expr(a):
3525 ctx = _get_ctx(ctx)
3526 a = RealVal(a, ctx)
3527 return a ** "1/2"
3528
3529
◆ SRem()
| SRem | ( | a, | |
| b ) |
Create the Z3 expression signed remainder.
Use the operator % for signed modulus, and URem() for unsigned remainder.
>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> SRem(x, y)
SRem(x, y)
>>> SRem(x, y).sort()
BitVec(32)
>>> (x % y).sexpr()
'(bvsmod x y)'
>>> SRem(x, y).sexpr()
'(bvsrem x y)'
Definition at line 4412 of file z3py.py.
4412def SRem(a, b):
4413 """Create the Z3 expression signed remainder.
4414
4415 Use the operator % for signed modulus, and URem() for unsigned remainder.
4416
4417 >>> x = BitVec('x', 32)
4418 >>> y = BitVec('y', 32)
4419 >>> SRem(x, y)
4420 SRem(x, y)
4421 >>> SRem(x, y).sort()
4422 BitVec(32)
4423 >>> (x % y).sexpr()
4424 '(bvsmod x y)'
4425 >>> SRem(x, y).sexpr()
4426 '(bvsrem x y)'
4427 """
4428 _check_bv_args(a, b)
4429 a, b = _coerce_exprs(a, b)
4431
4432
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
◆ Star()
| Star | ( | re | ) |
Create the regular expression accepting zero or more repetitions of argument.
>>> re = Star(Re("a"))
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("ab", re)))
False
>>> print(simplify(InRe("", re)))
True
Definition at line 11610 of file z3py.py.
11610def Star(re):
11611 """Create the regular expression accepting zero or more repetitions of argument.
11612 >>> re = Star(Re("a"))
11613 >>> print(simplify(InRe("aa", re)))
11614 True
11615 >>> print(simplify(InRe("ab", re)))
11616 False
11617 >>> print(simplify(InRe("", re)))
11618 True
11619 """
11620 if z3_debug():
11621 _z3_assert(is_expr(re), "expression expected")
11623
11624
◆ Store()
| Store | ( | a, | |
| * | args ) |
Return a Z3 store array expression.
>>> a = Array('a', IntSort(), IntSort())
>>> i, v = Ints('i v')
>>> s = Store(a, i, v)
>>> s.sort()
Array(Int, Int)
>>> prove(s[i] == v)
proved
>>> j = Int('j')
>>> prove(Implies(i != j, s[j] == a[j]))
proved
Definition at line 4924 of file z3py.py.
4924def Store(a, *args):
4925 """Return a Z3 store array expression.
4926
4927 >>> a = Array('a', IntSort(), IntSort())
4928 >>> i, v = Ints('i v')
4929 >>> s = Store(a, i, v)
4930 >>> s.sort()
4931 Array(Int, Int)
4932 >>> prove(s[i] == v)
4933 proved
4934 >>> j = Int('j')
4935 >>> prove(Implies(i != j, s[j] == a[j]))
4936 proved
4937 """
4938 return Update(a, args)
4939
4940
Referenced by ModelRef.get_interp().
◆ StrFromCode()
| StrFromCode | ( | c | ) |
◆ String()
| String | ( | name, | |
| ctx = None ) |
Return a string constant named `name`. If `ctx=None`, then the global context is used.
>>> x = String('x')
Definition at line 11235 of file z3py.py.
11235def String(name, ctx=None):
11236 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11237
11238 >>> x = String('x')
11239 """
11240 ctx = _get_ctx(ctx)
11242
11243
◆ Strings()
| Strings | ( | names, | |
| ctx = None ) |
Return a tuple of String constants.
Definition at line 11244 of file z3py.py.
11244def Strings(names, ctx=None):
11245 """Return a tuple of String constants. """
11246 ctx = _get_ctx(ctx)
11247 if isinstance(names, str):
11248 names = names.split(" ")
11249 return [String(name, ctx) for name in names]
11250
11251
◆ StringSort()
| StringSort | ( | ctx = None | ) |
◆ StringVal()
| StringVal | ( | s, | |
| ctx = None ) |
create a string expression
Definition at line 11228 of file z3py.py.
11228def StringVal(s, ctx=None):
11229 """create a string expression"""
11230 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11231 ctx = _get_ctx(ctx)
11233
11234
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...
Referenced by _coerce_exprs(), _py2expr(), and Extract().
◆ StrToCode()
| StrToCode | ( | s | ) |
Convert a unit length string to integer code
Definition at line 11472 of file z3py.py.
11472def StrToCode(s):
11473 """Convert a unit length string to integer code"""
11474 if not is_expr(s):
11475 s = _py2expr(s)
11477
Z3_ast Z3_API Z3_mk_string_to_code(Z3_context c, Z3_ast a)
String to code conversion.
◆ StrToInt()
| StrToInt | ( | s | ) |
Convert string expression to integer
>>> a = StrToInt("1")
>>> simplify(1 == a)
True
>>> b = StrToInt("2")
>>> simplify(1 == b)
False
>>> c = StrToInt(IntToStr(2))
>>> simplify(1 == c)
False
Definition at line 11449 of file z3py.py.
11449def StrToInt(s):
11450 """Convert string expression to integer
11451 >>> a = StrToInt("1")
11452 >>> simplify(1 == a)
11453 True
11454 >>> b = StrToInt("2")
11455 >>> simplify(1 == b)
11456 False
11457 >>> c = StrToInt(IntToStr(2))
11458 >>> simplify(1 == c)
11459 False
11460 """
11461 s = _coerce_seq(s)
11463
11464
◆ SubSeq()
| SubSeq | ( | s, | |
| offset, | |||
| length ) |
Extract substring or subsequence starting at offset.
This is a convenience function that redirects to Extract(s, offset, length).
>>> s = StringVal("hello world")
>>> SubSeq(s, 0, 5) # Extract "hello"
str.substr("hello world", 0, 5)
>>> simplify(SubSeq(StringVal("testing"), 2, 4))
"stin"
Definition at line 11266 of file z3py.py.
11266def SubSeq(s, offset, length):
11267 """Extract substring or subsequence starting at offset.
11268
11269 This is a convenience function that redirects to Extract(s, offset, length).
11270
11271 >>> s = StringVal("hello world")
11272 >>> SubSeq(s, 0, 5) # Extract "hello"
11273 str.substr("hello world", 0, 5)
11274 >>> simplify(SubSeq(StringVal("testing"), 2, 4))
11275 "stin"
11276 """
11277 return Extract(s, offset, length)
11278
11279
◆ substitute()
| substitute | ( | t, | |
| * | m ) |
Apply substitution m on t, m is a list of pairs of the form (from, to).
Every occurrence in t of from is replaced with to.
>>> x = Int('x')
>>> y = Int('y')
>>> substitute(x + 1, (x, y + 1))
y + 1 + 1
>>> f = Function('f', IntSort(), IntSort())
>>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
1 + 1
Definition at line 9100 of file z3py.py.
9100def substitute(t, *m):
9101 """Apply substitution m on t, m is a list of pairs of the form (from, to).
9102 Every occurrence in t of from is replaced with to.
9103
9104 >>> x = Int('x')
9105 >>> y = Int('y')
9106 >>> substitute(x + 1, (x, y + 1))
9107 y + 1 + 1
9108 >>> f = Function('f', IntSort(), IntSort())
9109 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
9110 1 + 1
9111 """
9112 if isinstance(m, tuple):
9113 m1 = _get_args(m)
9114 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9115 m = m1
9116 if z3_debug():
9117 _z3_assert(is_expr(t), "Z3 expression expected")
9118 _z3_assert(
9119 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
9120 "Z3 invalid substitution, expression pairs expected.")
9121 _z3_assert(
9122 all([p[0].sort().eq(p[1].sort()) for p in m]),
9123 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
9124 num = len(m)
9125 _from = (Ast * num)()
9126 _to = (Ast * num)()
9127 for i in range(num):
9128 _from[i] = m[i][0].as_ast()
9129 _to[i] = m[i][1].as_ast()
9131
9132
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....
◆ substitute_funs()
| substitute_funs | ( | t, | |
| * | m ) |
Apply substitution m on t, m is a list of pairs of a function and expression (from, to) Every occurrence in to of the function from is replaced with the expression to. The expression to can have free variables, that refer to the arguments of from. For examples, see
Definition at line 9153 of file z3py.py.
9153def substitute_funs(t, *m):
9154 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
9155 Every occurrence in to of the function from is replaced with the expression to.
9156 The expression to can have free variables, that refer to the arguments of from.
9157 For examples, see
9158 """
9159 if isinstance(m, tuple):
9160 m1 = _get_args(m)
9161 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9162 m = m1
9163 if z3_debug():
9164 _z3_assert(is_expr(t), "Z3 expression expected")
9165 _z3_assert(all([isinstance(p, tuple) and is_func_decl(p[0]) and is_expr(p[1]) for p in m]), "Z3 invalid substitution, function pairs expected.")
9166 num = len(m)
9167 _from = (FuncDecl * num)()
9168 _to = (Ast * num)()
9169 for i in range(num):
9170 _from[i] = m[i][0].as_func_decl()
9171 _to[i] = m[i][1].as_ast()
9173
9174
Z3_ast Z3_API Z3_substitute_funs(Z3_context c, Z3_ast a, unsigned num_funs, Z3_func_decl const from[], Z3_ast const to[])
Substitute functions in from with new expressions in to.
◆ substitute_vars()
| substitute_vars | ( | t, | |
| * | m ) |
Substitute the free variables in t with the expression in m.
>>> v0 = Var(0, IntSort())
>>> v1 = Var(1, IntSort())
>>> x = Int('x')
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> # replace v0 with x+1 and v1 with x
>>> substitute_vars(f(v0, v1), x + 1, x)
f(x + 1, x)
Definition at line 9133 of file z3py.py.
9133def substitute_vars(t, *m):
9134 """Substitute the free variables in t with the expression in m.
9135
9136 >>> v0 = Var(0, IntSort())
9137 >>> v1 = Var(1, IntSort())
9138 >>> x = Int('x')
9139 >>> f = Function('f', IntSort(), IntSort(), IntSort())
9140 >>> # replace v0 with x+1 and v1 with x
9141 >>> substitute_vars(f(v0, v1), x + 1, x)
9142 f(x + 1, x)
9143 """
9144 if z3_debug():
9145 _z3_assert(is_expr(t), "Z3 expression expected")
9146 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
9147 num = len(m)
9148 _to = (Ast * num)()
9149 for i in range(num):
9150 _to[i] = m[i].as_ast()
9152
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,...
◆ SubString()
| SubString | ( | s, | |
| offset, | |||
| length ) |
Extract substring or subsequence starting at offset.
This is a convenience function that redirects to Extract(s, offset, length).
>>> s = StringVal("hello world")
>>> SubString(s, 6, 5) # Extract "world"
str.substr("hello world", 6, 5)
>>> simplify(SubString(StringVal("hello"), 1, 3))
"ell"
Definition at line 11252 of file z3py.py.
11252def SubString(s, offset, length):
11253 """Extract substring or subsequence starting at offset.
11254
11255 This is a convenience function that redirects to Extract(s, offset, length).
11256
11257 >>> s = StringVal("hello world")
11258 >>> SubString(s, 6, 5) # Extract "world"
11259 str.substr("hello world", 6, 5)
11260 >>> simplify(SubString(StringVal("hello"), 1, 3))
11261 "ell"
11262 """
11263 return Extract(s, offset, length)
11264
11265
◆ SuffixOf()
| SuffixOf | ( | a, | |
| b ) |
Check if 'a' is a suffix of 'b'
>>> s1 = SuffixOf("ab", "abc")
>>> simplify(s1)
False
>>> s2 = SuffixOf("bc", "abc")
>>> simplify(s2)
True
Definition at line 11335 of file z3py.py.
11335def SuffixOf(a, b):
11336 """Check if 'a' is a suffix of 'b'
11337 >>> s1 = SuffixOf("ab", "abc")
11338 >>> simplify(s1)
11339 False
11340 >>> s2 = SuffixOf("bc", "abc")
11341 >>> simplify(s2)
11342 True
11343 """
11344 ctx = _get_ctx2(a, b)
11345 a = _coerce_seq(a, ctx)
11346 b = _coerce_seq(b, ctx)
11348
11349
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.
◆ Sum()
| Sum | ( | * | args | ) |
Create the sum of the Z3 expressions.
>>> a, b, c = Ints('a b c')
>>> Sum(a, b, c)
a + b + c
>>> Sum([a, b, c])
a + b + c
>>> A = IntVector('a', 5)
>>> Sum(A)
a__0 + a__1 + a__2 + a__3 + a__4
Definition at line 9175 of file z3py.py.
9175def Sum(*args):
9176 """Create the sum of the Z3 expressions.
9177
9178 >>> a, b, c = Ints('a b c')
9179 >>> Sum(a, b, c)
9180 a + b + c
9181 >>> Sum([a, b, c])
9182 a + b + c
9183 >>> A = IntVector('a', 5)
9184 >>> Sum(A)
9185 a__0 + a__1 + a__2 + a__3 + a__4
9186 """
9187 args = _get_args(args)
9188 if len(args) == 0:
9189 return 0
9190 ctx = _ctx_from_ast_arg_list(args)
9191 if ctx is None:
9192 return _reduce(lambda a, b: a + b, args, 0)
9193 args = _coerce_expr_list(args, ctx)
9194 if is_bv(args[0]):
9195 return _reduce(lambda a, b: a + b, args, 0)
9196 else:
9197 _args, sz = _to_ast_array(args)
9199
9200
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].
◆ tactic_description()
| tactic_description | ( | name, | |
| ctx = None ) |
Return a short description for the tactic named `name`.
>>> d = tactic_description('simplify')
Definition at line 8754 of file z3py.py.
8754def tactic_description(name, ctx=None):
8755 """Return a short description for the tactic named `name`.
8756
8757 >>> d = tactic_description('simplify')
8758 """
8759 ctx = _get_ctx(ctx)
8761
8762
Z3_string Z3_API Z3_tactic_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the tactic with the given name.
◆ tactics()
| tactics | ( | ctx = None | ) |
Return a list of all available tactics in Z3.
>>> l = tactics()
>>> l.count('simplify') == 1
True
Definition at line 8743 of file z3py.py.
8743def tactics(ctx=None):
8744 """Return a list of all available tactics in Z3.
8745
8746 >>> l = tactics()
8747 >>> l.count('simplify') == 1
8748 True
8749 """
8750 ctx = _get_ctx(ctx)
8752
8753
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.
◆ Then()
| Then | ( | * | ts, |
| ** | ks ) |
Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
>>> x, y = Ints('x y')
>>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
>>> t(And(x == 0, y > x + 1))
[[Not(y <= 1)]]
>>> t(And(x == 0, y > x + 1)).as_expr()
Not(y <= 1)
Definition at line 8611 of file z3py.py.
8611def Then(*ts, **ks):
8612 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8613
8614 >>> x, y = Ints('x y')
8615 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8616 >>> t(And(x == 0, y > x + 1))
8617 [[Not(y <= 1)]]
8618 >>> t(And(x == 0, y > x + 1)).as_expr()
8619 Not(y <= 1)
8620 """
8621 return AndThen(*ts, **ks)
8622
8623
◆ to_Ast()
| to_Ast | ( | ptr | ) |
◆ to_AstVectorObj()
| to_AstVectorObj | ( | ptr | ) |
Definition at line 11704 of file z3py.py.
11704def to_AstVectorObj(ptr,):
11705 v = AstVectorObj(ptr)
11706 super(ctypes.c_void_p, v).__init__(ptr)
11707 return v
11708
11709# NB. my-hacky-class only works for a single instance of OnClause
11710# it should be replaced with a proper correlation between OnClause
11711# and object references that can be passed over the FFI.
11712# for UserPropagator we use a global dictionary, which isn't great code.
11713
◆ to_ContextObj()
| to_ContextObj | ( | ptr | ) |
◆ to_symbol()
| to_symbol | ( | s, | |
| ctx = None ) |
Convert an integer or string into a Z3 symbol.
Definition at line 132 of file z3py.py.
132def to_symbol(s, ctx = None):
133 """Convert an integer or string into a Z3 symbol."""
134 if _is_int(s):
136 else:
138
139
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
Referenced by _mk_quantifier(), Array(), BitVec(), Bool(), Const(), CreateDatatypes(), DatatypeSort(), DeclareSort(), DeclareTypeVar(), EnumSort(), Function(), ParamDescrsRef.get_documentation(), ParamDescrsRef.get_kind(), Int(), Real(), RecFunction(), and ParamsRef.set().
◆ ToInt()
| ToInt | ( | a | ) |
Return the Z3 expression ToInt(a).
>>> x = Real('x')
>>> x.sort()
Real
>>> n = ToInt(x)
>>> n
ToInt(x)
>>> n.sort()
Int
Definition at line 3482 of file z3py.py.
3482def ToInt(a):
3483 """ Return the Z3 expression ToInt(a).
3484
3485 >>> x = Real('x')
3486 >>> x.sort()
3487 Real
3488 >>> n = ToInt(x)
3489 >>> n
3490 ToInt(x)
3491 >>> n.sort()
3492 Int
3493 """
3494 if z3_debug():
3495 _z3_assert(a.is_real(), "Z3 real expression expected.")
3496 ctx = a.ctx
3498
3499
◆ ToReal()
| ToReal | ( | a | ) |
Return the Z3 expression ToReal(a).
>>> x = Int('x')
>>> x.sort()
Int
>>> n = ToReal(x)
>>> n
ToReal(x)
>>> n.sort()
Real
Definition at line 3462 of file z3py.py.
3462def ToReal(a):
3463 """ Return the Z3 expression ToReal(a).
3464
3465 >>> x = Int('x')
3466 >>> x.sort()
3467 Int
3468 >>> n = ToReal(x)
3469 >>> n
3470 ToReal(x)
3471 >>> n.sort()
3472 Real
3473 """
3474 ctx = a.ctx
3475 if isinstance(a, BoolRef):
3476 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3477 if z3_debug():
3478 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3480
3481
◆ TransitiveClosure()
| TransitiveClosure | ( | f | ) |
Given a binary relation R, such that the two arguments have the same sort create the transitive closure relation R+. The transitive closure R+ is a new relation.
Definition at line 11687 of file z3py.py.
11687def TransitiveClosure(f):
11688 """Given a binary relation R, such that the two arguments have the same sort
11689 create the transitive closure relation R+.
11690 The transitive closure R+ is a new relation.
11691 """
11693
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
◆ TreeOrder()
| TreeOrder | ( | a, | |
| index ) |
◆ TryFor()
| TryFor | ( | t, | |
| ms, | |||
| ctx = None ) |
Return a tactic that applies `t` to a given goal for `ms` milliseconds. If `t` does not terminate in `ms` milliseconds, then it fails.
Definition at line 8734 of file z3py.py.
8734def TryFor(t, ms, ctx=None):
8735 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8736
8737 If `t` does not terminate in `ms` milliseconds, then it fails.
8738 """
8739 t = _to_tactic(t, ctx)
8741
8742
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...
◆ TupleSort()
| TupleSort | ( | name, | |
| sorts, | |||
| ctx = None ) |
Create a named tuple sort base on a set of underlying sorts
Example:
>>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
Definition at line 5517 of file z3py.py.
5517def TupleSort(name, sorts, ctx=None):
5518 """Create a named tuple sort base on a set of underlying sorts
5519 Example:
5520 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5521 """
5522 tuple = Datatype(name, ctx)
5523 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5524 tuple.declare(name, *projects)
5525 tuple = tuple.create()
5526 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5527
5528
◆ UDiv()
| UDiv | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) division `self / other`.
Use the operator / for signed division.
>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> UDiv(x, y)
UDiv(x, y)
>>> UDiv(x, y).sort()
BitVec(32)
>>> (x / y).sexpr()
'(bvsdiv x y)'
>>> UDiv(x, y).sexpr()
'(bvudiv x y)'
Definition at line 4370 of file z3py.py.
4370def UDiv(a, b):
4371 """Create the Z3 expression (unsigned) division `self / other`.
4372
4373 Use the operator / for signed division.
4374
4375 >>> x = BitVec('x', 32)
4376 >>> y = BitVec('y', 32)
4377 >>> UDiv(x, y)
4378 UDiv(x, y)
4379 >>> UDiv(x, y).sort()
4380 BitVec(32)
4381 >>> (x / y).sexpr()
4382 '(bvsdiv x y)'
4383 >>> UDiv(x, y).sexpr()
4384 '(bvudiv x y)'
4385 """
4386 _check_bv_args(a, b)
4387 a, b = _coerce_exprs(a, b)
4389
4390
◆ UGE()
| UGE | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) `other >= self`.
Use the operator >= for signed greater than or equal to.
>>> x, y = BitVecs('x y', 32)
>>> UGE(x, y)
UGE(x, y)
>>> (x >= y).sexpr()
'(bvsge x y)'
>>> UGE(x, y).sexpr()
'(bvuge x y)'
Definition at line 4334 of file z3py.py.
4334def UGE(a, b):
4335 """Create the Z3 expression (unsigned) `other >= self`.
4336
4337 Use the operator >= for signed greater than or equal to.
4338
4339 >>> x, y = BitVecs('x y', 32)
4340 >>> UGE(x, y)
4341 UGE(x, y)
4342 >>> (x >= y).sexpr()
4343 '(bvsge x y)'
4344 >>> UGE(x, y).sexpr()
4345 '(bvuge x y)'
4346 """
4347 _check_bv_args(a, b)
4348 a, b = _coerce_exprs(a, b)
4350
4351
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
◆ UGT()
| UGT | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) `other > self`.
Use the operator > for signed greater than.
>>> x, y = BitVecs('x y', 32)
>>> UGT(x, y)
UGT(x, y)
>>> (x > y).sexpr()
'(bvsgt x y)'
>>> UGT(x, y).sexpr()
'(bvugt x y)'
Definition at line 4352 of file z3py.py.
4352def UGT(a, b):
4353 """Create the Z3 expression (unsigned) `other > self`.
4354
4355 Use the operator > for signed greater than.
4356
4357 >>> x, y = BitVecs('x y', 32)
4358 >>> UGT(x, y)
4359 UGT(x, y)
4360 >>> (x > y).sexpr()
4361 '(bvsgt x y)'
4362 >>> UGT(x, y).sexpr()
4363 '(bvugt x y)'
4364 """
4365 _check_bv_args(a, b)
4366 a, b = _coerce_exprs(a, b)
4368
4369
◆ ULE()
| ULE | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) `other <= self`.
Use the operator <= for signed less than or equal to.
>>> x, y = BitVecs('x y', 32)
>>> ULE(x, y)
ULE(x, y)
>>> (x <= y).sexpr()
'(bvsle x y)'
>>> ULE(x, y).sexpr()
'(bvule x y)'
Definition at line 4298 of file z3py.py.
4298def ULE(a, b):
4299 """Create the Z3 expression (unsigned) `other <= self`.
4300
4301 Use the operator <= for signed less than or equal to.
4302
4303 >>> x, y = BitVecs('x y', 32)
4304 >>> ULE(x, y)
4305 ULE(x, y)
4306 >>> (x <= y).sexpr()
4307 '(bvsle x y)'
4308 >>> ULE(x, y).sexpr()
4309 '(bvule x y)'
4310 """
4311 _check_bv_args(a, b)
4312 a, b = _coerce_exprs(a, b)
4314
4315
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
◆ ULT()
| ULT | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) `other < self`.
Use the operator < for signed less than.
>>> x, y = BitVecs('x y', 32)
>>> ULT(x, y)
ULT(x, y)
>>> (x < y).sexpr()
'(bvslt x y)'
>>> ULT(x, y).sexpr()
'(bvult x y)'
Definition at line 4316 of file z3py.py.
4316def ULT(a, b):
4317 """Create the Z3 expression (unsigned) `other < self`.
4318
4319 Use the operator < for signed less than.
4320
4321 >>> x, y = BitVecs('x y', 32)
4322 >>> ULT(x, y)
4323 ULT(x, y)
4324 >>> (x < y).sexpr()
4325 '(bvslt x y)'
4326 >>> ULT(x, y).sexpr()
4327 '(bvult x y)'
4328 """
4329 _check_bv_args(a, b)
4330 a, b = _coerce_exprs(a, b)
4332
4333
◆ Union()
| Union | ( | * | args | ) |
Create union of regular expressions.
>>> re = Union(Re("a"), Re("b"), Re("c"))
>>> print (simplify(InRe("d", re)))
False
Definition at line 11537 of file z3py.py.
11537def Union(*args):
11538 """Create union of regular expressions.
11539 >>> re = Union(Re("a"), Re("b"), Re("c"))
11540 >>> print (simplify(InRe("d", re)))
11541 False
11542 """
11543 args = _get_args(args)
11544 sz = len(args)
11545 if z3_debug():
11546 _z3_assert(sz > 0, "At least one argument expected.")
11547 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11548 if sz == 1:
11549 return args[0]
11550 ctx = args[0].ctx
11551 v = (Ast * sz)()
11552 for i in range(sz):
11553 v[i] = args[i].as_ast()
11555
11556
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
◆ Unit()
| Unit | ( | a | ) |
◆ Update()
| Update | ( | a, | |
| * | args ) |
Return a Z3 store array expression.
>>> a = Array('a', IntSort(), IntSort())
>>> i, v = Ints('i v')
>>> s = Update(a, i, v)
>>> s.sort()
Array(Int, Int)
>>> prove(s[i] == v)
proved
>>> j = Int('j')
>>> prove(Implies(i != j, s[j] == a[j]))
proved
Definition at line 4881 of file z3py.py.
4881def Update(a, *args):
4882 """Return a Z3 store array expression.
4883
4884 >>> a = Array('a', IntSort(), IntSort())
4885 >>> i, v = Ints('i v')
4886 >>> s = Update(a, i, v)
4887 >>> s.sort()
4888 Array(Int, Int)
4889 >>> prove(s[i] == v)
4890 proved
4891 >>> j = Int('j')
4892 >>> prove(Implies(i != j, s[j] == a[j]))
4893 proved
4894 """
4895 if z3_debug():
4896 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4897 args = _get_args(args)
4898 ctx = a.ctx
4899 if len(args) <= 1:
4900 raise Z3Exception("array update requires index and value arguments")
4901 if len(args) == 2:
4902 i = args[0]
4903 v = args[1]
4904 i = a.sort().domain().cast(i)
4905 v = a.sort().range().cast(v)
4907 v = a.sort().range().cast(args[-1])
4908 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4909 _args, sz = _to_ast_array(idxs)
4911
4912
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.
Referenced by Store().
◆ URem()
| URem | ( | a, | |
| b ) |
Create the Z3 expression (unsigned) remainder `self % other`.
Use the operator % for signed modulus, and SRem() for signed remainder.
>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> URem(x, y)
URem(x, y)
>>> URem(x, y).sort()
BitVec(32)
>>> (x % y).sexpr()
'(bvsmod x y)'
>>> URem(x, y).sexpr()
'(bvurem x y)'
Definition at line 4391 of file z3py.py.
4391def URem(a, b):
4392 """Create the Z3 expression (unsigned) remainder `self % other`.
4393
4394 Use the operator % for signed modulus, and SRem() for signed remainder.
4395
4396 >>> x = BitVec('x', 32)
4397 >>> y = BitVec('y', 32)
4398 >>> URem(x, y)
4399 URem(x, y)
4400 >>> URem(x, y).sort()
4401 BitVec(32)
4402 >>> (x % y).sexpr()
4403 '(bvsmod x y)'
4404 >>> URem(x, y).sexpr()
4405 '(bvurem x y)'
4406 """
4407 _check_bv_args(a, b)
4408 a, b = _coerce_exprs(a, b)
4410
4411
◆ user_prop_binding()
| user_prop_binding | ( | ctx, | |
| cb, | |||
| q_ref, | |||
| inst_ref ) |
Definition at line 11857 of file z3py.py.
11857def user_prop_binding(ctx, cb, q_ref, inst_ref):
11858 prop = _prop_closures.get(ctx)
11859 old_cb = prop.cb
11860 prop.cb = cb
11861 q = _to_expr_ref(to_Ast(q_ref), prop.ctx())
11862 inst = _to_expr_ref(to_Ast(inst_ref), prop.ctx())
11863 r = prop.binding(q, inst)
11864 prop.cb = old_cb
11865 return r
11866
11867
◆ user_prop_created()
| user_prop_created | ( | ctx, | |
| cb, | |||
| id ) |
◆ user_prop_decide()
| user_prop_decide | ( | ctx, | |
| cb, | |||
| t_ref, | |||
| idx, | |||
| phase ) |
◆ user_prop_diseq()
| user_prop_diseq | ( | ctx, | |
| cb, | |||
| x, | |||
| y ) |
Definition at line 11840 of file z3py.py.
11840def user_prop_diseq(ctx, cb, x, y):
11841 prop = _prop_closures.get(ctx)
11842 old_cb = prop.cb
11843 prop.cb = cb
11844 x = _to_expr_ref(to_Ast(x), prop.ctx())
11845 y = _to_expr_ref(to_Ast(y), prop.ctx())
11846 prop.diseq(x, y)
11847 prop.cb = old_cb
11848
◆ user_prop_eq()
| user_prop_eq | ( | ctx, | |
| cb, | |||
| x, | |||
| y ) |
◆ user_prop_final()
| user_prop_final | ( | ctx, | |
| cb ) |
◆ user_prop_fixed()
| user_prop_fixed | ( | ctx, | |
| cb, | |||
| id, | |||
| value ) |
Definition at line 11806 of file z3py.py.
11806def user_prop_fixed(ctx, cb, id, value):
11807 prop = _prop_closures.get(ctx)
11808 old_cb = prop.cb
11809 prop.cb = cb
11810 id = _to_expr_ref(to_Ast(id), prop.ctx())
11811 value = _to_expr_ref(to_Ast(value), prop.ctx())
11812 prop.fixed(id, value)
11813 prop.cb = old_cb
11814
◆ user_prop_fresh()
| user_prop_fresh | ( | ctx, | |
| _new_ctx ) |
Definition at line 11792 of file z3py.py.
11792def user_prop_fresh(ctx, _new_ctx):
11793 _prop_closures.set_threaded()
11794 prop = _prop_closures.get(ctx)
11795 nctx = Context()
11796 Z3_del_context(nctx.ctx)
11797 new_ctx = to_ContextObj(_new_ctx)
11798 nctx.ctx = new_ctx
11799 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11800 nctx.owner = False
11801 new_prop = prop.fresh(nctx)
11802 _prop_closures.set(new_prop.id, new_prop)
11803 return new_prop.id
11804
11805
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
◆ user_prop_pop()
| user_prop_pop | ( | ctx, | |
| cb, | |||
| num_scopes ) |
◆ user_prop_push()
| user_prop_push | ( | ctx, | |
| cb ) |
◆ Var()
Create a Z3 free variable. Free variables are used to create quantified formulas. A free variable with index n is bound when it occurs within the scope of n+1 quantified declarations. >>> Var(0, IntSort()) Var(0) >>> eq(Var(0, IntSort()), Var(0, BoolSort())) False
Definition at line 1534 of file z3py.py.
1534def Var(idx : int, s : SortRef) -> ExprRef:
1535 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1536 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1537 declarations.
1538
1539 >>> Var(0, IntSort())
1540 Var(0)
1541 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1542 False
1543 """
1544 if z3_debug():
1545 _z3_assert(is_sort(s), "Z3 sort expected")
1547
1548
Referenced by RealVar().
◆ When()
| When | ( | p, | |
| t, | |||
| ctx = None ) |
Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
Otherwise, it returns the input goal unmodified.
>>> t = When(Probe('size') > 2, Tactic('simplify'))
>>> x, y = Ints('x y')
>>> g = Goal()
>>> g.add(x > 0)
>>> g.add(y > 0)
>>> t(g)
[[x > 0, y > 0]]
>>> g.add(x == y + 1)
>>> t(g)
[[Not(x <= 0), Not(y <= 0), x == 1 + y]]
Definition at line 9028 of file z3py.py.
9028def When(p, t, ctx=None):
9029 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
9030 Otherwise, it returns the input goal unmodified.
9031
9032 >>> t = When(Probe('size') > 2, Tactic('simplify'))
9033 >>> x, y = Ints('x y')
9034 >>> g = Goal()
9035 >>> g.add(x > 0)
9036 >>> g.add(y > 0)
9037 >>> t(g)
9038 [[x > 0, y > 0]]
9039 >>> g.add(x == y + 1)
9040 >>> t(g)
9041 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9042 """
9043 p = _to_probe(p, ctx)
9044 t = _to_tactic(t, ctx)
9046
9047
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...
◆ With()
| With | ( | t, | |
| * | args, | ||
| ** | keys ) |
Return a tactic that applies tactic `t` using the given configuration options.
>>> x, y = Ints('x y')
>>> t = With(Tactic('simplify'), som=True)
>>> t((x + 1)*(y + 2) == 0)
[[2*x + y + x*y == -2]]
Definition at line 8685 of file z3py.py.
8685def With(t, *args, **keys):
8686 """Return a tactic that applies tactic `t` using the given configuration options.
8687
8688 >>> x, y = Ints('x y')
8689 >>> t = With(Tactic('simplify'), som=True)
8690 >>> t((x + 1)*(y + 2) == 0)
8691 [[2*x + y + x*y == -2]]
8692 """
8693 ctx = keys.pop("ctx", None)
8694 t = _to_tactic(t, ctx)
8695 p = args2params(args, keys, t.ctx)
8697
8698
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.
◆ WithParams()
| WithParams | ( | t, | |
| p ) |
Return a tactic that applies tactic `t` using the given configuration options.
>>> x, y = Ints('x y')
>>> p = ParamsRef()
>>> p.set("som", True)
>>> t = WithParams(Tactic('simplify'), p)
>>> t((x + 1)*(y + 2) == 0)
[[2*x + y + x*y == -2]]
Definition at line 8699 of file z3py.py.
8699def WithParams(t, p):
8700 """Return a tactic that applies tactic `t` using the given configuration options.
8701
8702 >>> x, y = Ints('x y')
8703 >>> p = ParamsRef()
8704 >>> p.set("som", True)
8705 >>> t = WithParams(Tactic('simplify'), p)
8706 >>> t((x + 1)*(y + 2) == 0)
8707 [[2*x + y + x*y == -2]]
8708 """
8709 t = _to_tactic(t, None)
8711
8712
◆ Xor()
| Xor | ( | a, | |
| b, | |||
| ctx = None ) |
Create a Z3 Xor expression.
>>> p, q = Bools('p q')
>>> Xor(p, q)
Xor(p, q)
>>> simplify(Xor(p, q))
Not(p == q)
Definition at line 1891 of file z3py.py.
1891def Xor(a, b, ctx=None):
1892 """Create a Z3 Xor expression.
1893
1894 >>> p, q = Bools('p q')
1895 >>> Xor(p, q)
1896 Xor(p, q)
1897 >>> simplify(Xor(p, q))
1898 Not(p == q)
1899 """
1900 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1901 s = BoolSort(ctx)
1902 a = s.cast(a)
1903 b = s.cast(b)
1905
1906
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
Referenced by BoolRef.__xor__().
◆ z3_debug()
| z3_debug | ( | ) |
Definition at line 70 of file z3py.py.
70def z3_debug():
71 global Z3_DEBUG
72 return Z3_DEBUG
73
74
Referenced by ModelRef.__getitem__(), QuantifierRef.__getitem__(), Context.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _check_bv_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _mk_bin(), _mk_quantifier(), _py2expr(), _to_sort_ref(), DatatypeSortRef.accessor(), And(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), ArithSortRef.cast(), BitVecSortRef.cast(), SortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), AstRef.eq(), eq(), Ext(), Extract(), FreshConst(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), IsInt(), K(), ExprRef.kind(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), QuantifierRef.pattern(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Update(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().
◆ z3_error_handler()
| z3_error_handler | ( | c, | |
| e ) |
◆ ZeroExt()
| ZeroExt | ( | n, | |
| a ) |
Return a bit-vector expression with `n` extra zero-bits.
>>> x = BitVec('x', 16)
>>> n = ZeroExt(8, x)
>>> n.size()
24
>>> n
ZeroExt(8, x)
>>> n.sort()
BitVec(24)
>>> v0 = BitVecVal(2, 2)
>>> v0
2
>>> v0.size()
2
>>> v = simplify(ZeroExt(6, v0))
>>> v
2
>>> v.size()
8
Definition at line 4527 of file z3py.py.
4527def ZeroExt(n, a):
4528 """Return a bit-vector expression with `n` extra zero-bits.
4529
4530 >>> x = BitVec('x', 16)
4531 >>> n = ZeroExt(8, x)
4532 >>> n.size()
4533 24
4534 >>> n
4535 ZeroExt(8, x)
4536 >>> n.sort()
4537 BitVec(24)
4538 >>> v0 = BitVecVal(2, 2)
4539 >>> v0
4540 2
4541 >>> v0.size()
4542 2
4543 >>> v = simplify(ZeroExt(6, v0))
4544 >>> v
4545 2
4546 >>> v.size()
4547 8
4548 """
4549 if z3_debug():
4550 _z3_assert(_is_int(n), "First argument must be an integer")
4551 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4553
4554
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,...
Variable Documentation
◆ _dflt_fpsort_ebits
◆ _dflt_fpsort_sbits
◆ _dflt_rounding_mode
|
protected |
◆ _main_ctx
◆ _my_hacky_class
◆ _on_clause_eh
|
protected |
◆ _on_model_eh
|
protected |
◆ _on_models
◆ _prop_closures
◆ _ROUNDING_MODES
|
protected |
◆ _user_prop_binding
|
protected |
◆ _user_prop_created
|
protected |
◆ _user_prop_decide
|
protected |
◆ _user_prop_diseq
|
protected |
◆ _user_prop_eq
|
protected |
◆ _user_prop_final
|
protected |
◆ _user_prop_fixed
|
protected |
◆ _user_prop_fresh
|
protected |
◆ _user_prop_pop
|
protected |
◆ _user_prop_push
|
protected |
◆ sat
| sat = CheckSatResult(Z3_L_TRUE) |
◆ unknown
| unknown = CheckSatResult(Z3_L_UNDEF) |
◆ unsat
| unsat = CheckSatResult(Z3_L_FALSE) |
◆ Z3_DEBUG
Generated on for Z3 by
1.15.0