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) | |
| _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, 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 8540 of file z3py.py.
8540def _and_then(t1, t2, ctx=None):
8541 t1 = _to_tactic(t1, ctx)
8542 t2 = _to_tactic(t2, ctx)
8543 if z3_debug():
8544 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8546
8547
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 4717 of file z3py.py.
4717def _array_select(ar, arg):
4718 if isinstance(arg, tuple):
4719 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4720 _args, sz = _to_ast_array(args)
4722 arg = ar.sort().domain().cast(arg)
4724
4725
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 4278 of file z3py.py.
4278def _check_bv_args(a, b):
4279 if z3_debug():
4280 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4281
4282
Referenced by BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().
◆ _check_fp_args()
|
protected |
◆ _coerce_char()
|
protected |
◆ _coerce_expr_list()
|
protected |
Definition at line 1277 of file z3py.py.
1277def _coerce_expr_list(alist, ctx=None):
1278 has_expr = False
1279 for a in alist:
1280 if is_expr(a):
1281 has_expr = True
1282 break
1283 if not has_expr:
1284 alist = [_py2expr(a, ctx) for a in alist]
1285 s = _reduce(_coerce_expr_merge, alist, None)
1286 return [s.cast(a) for a in alist]
1287
1288
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
1248
Referenced by _coerce_exprs().
◆ _coerce_exprs()
|
protected |
Definition at line 1249 of file z3py.py.
1249def _coerce_exprs(a, b, ctx=None):
1250 if not is_expr(a) and not is_expr(b):
1251 a = _py2expr(a, ctx)
1252 b = _py2expr(b, ctx)
1253 if isinstance(a, str) and isinstance(b, SeqRef):
1254 a = StringVal(a, b.ctx)
1255 if isinstance(b, str) and isinstance(a, SeqRef):
1256 b = StringVal(b, a.ctx)
1257 if isinstance(a, float) and isinstance(b, ArithRef):
1258 a = RealVal(a, b.ctx)
1259 if isinstance(b, float) and isinstance(a, ArithRef):
1260 b = RealVal(b, a.ctx)
1261
1262 s = None
1263 s = _coerce_expr_merge(s, a)
1264 s = _coerce_expr_merge(s, b)
1265 a = s.cast(a)
1266 b = s.cast(b)
1267 return (a, b)
1268
1269
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 9601 of file z3py.py.
9601def _coerce_fp_expr_list(alist, ctx):
9602 first_fp_sort = None
9603 for a in alist:
9604 if is_fp(a):
9605 if first_fp_sort is None:
9606 first_fp_sort = a.sort()
9607 elif first_fp_sort == a.sort():
9608 pass # OK, same as before
9609 else:
9610 # we saw at least 2 different float sorts; something will
9611 # throw a sort mismatch later, for now assume None.
9612 first_fp_sort = None
9613 break
9614
9615 r = []
9616 for i in range(len(alist)):
9617 a = alist[i]
9618 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9619 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9620 r.append(FPVal(a, None, first_fp_sort, ctx))
9621 else:
9622 r.append(a)
9623 return _coerce_expr_list(r, ctx)
9624
9625
9626# FP Sorts
9627
◆ _coerce_seq()
|
protected |
Definition at line 11145 of file z3py.py.
11145def _coerce_seq(s, ctx=None):
11146 if isinstance(s, str):
11147 ctx = _get_ctx(ctx)
11148 s = StringVal(s, ctx)
11149 if not is_expr(s):
11150 raise Z3Exception("Non-expression passed as a sequence")
11151 if not is_seq(s):
11152 raise Z3Exception("Non-sequence passed as a sequence")
11153 return s
11154
11155
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 9466 of file z3py.py.
9466def _dict2darray(decls, ctx):
9467 sz = len(decls)
9468 _names = (Symbol * sz)()
9469 _decls = (FuncDecl * sz)()
9470 i = 0
9471 for k in decls:
9472 v = decls[k]
9473 if z3_debug():
9474 _z3_assert(isinstance(k, str), "String expected")
9475 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9476 _names[i] = to_symbol(k, ctx)
9477 if is_const(v):
9478 _decls[i] = v.decl().ast
9479 else:
9480 _decls[i] = v.ast
9481 i = i + 1
9482 return sz, _names, _decls
9483
◆ _dict2sarray()
|
protected |
Definition at line 9450 of file z3py.py.
9450def _dict2sarray(sorts, ctx):
9451 sz = len(sorts)
9452 _names = (Symbol * sz)()
9453 _sorts = (Sort * sz)()
9454 i = 0
9455 for k in sorts:
9456 v = sorts[k]
9457 if z3_debug():
9458 _z3_assert(isinstance(k, str), "String expected")
9459 _z3_assert(is_sort(v), "Z3 sort expected")
9460 _names[i] = to_symbol(k, ctx)
9461 _sorts[i] = v.ast
9462 i = i + 1
9463 return sz, _names, _sorts
9464
9465
◆ _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 1918 of file z3py.py.
1918def _has_probe(args):
1919 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1920 for arg in args:
1921 if is_probe(arg):
1922 return True
1923 return False
1924
1925
◆ _is_algebraic()
|
protected |
Definition at line 2815 of file z3py.py.
2815def _is_algebraic(ctx, a):
2817
2818
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 2811 of file z3py.py.
2811def _is_numeral(ctx, a):
2813
2814
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 1475 of file z3py.py.
1475def _mk_bin(f, a, b):
1476 args = (Ast * 2)()
1477 if z3_debug():
1478 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1479 args[0] = a.as_ast()
1480 args[1] = b.as_ast()
1481 return f(a.ctx.ref(), 2, args)
1482
1483
Referenced by ArithRef.__add__(), ArithRef.__mul__(), ArithRef.__radd__(), ArithRef.__rmul__(), ArithRef.__rsub__(), and ArithRef.__sub__().
◆ _mk_fp_bin()
|
protected |
Definition at line 10440 of file z3py.py.
10440def _mk_fp_bin(f, rm, a, b, ctx):
10441 ctx = _get_ctx(ctx)
10442 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10443 if z3_debug():
10444 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10445 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10446 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10447
10448
◆ _mk_fp_bin_norm()
|
protected |
Definition at line 10449 of file z3py.py.
10449def _mk_fp_bin_norm(f, a, b, ctx):
10450 ctx = _get_ctx(ctx)
10451 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10452 if z3_debug():
10453 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10454 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10455
10456
◆ _mk_fp_bin_pred()
|
protected |
Definition at line 10457 of file z3py.py.
10457def _mk_fp_bin_pred(f, a, b, ctx):
10458 ctx = _get_ctx(ctx)
10459 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10460 if z3_debug():
10461 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10462 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10463
10464
◆ _mk_fp_tern()
|
protected |
Definition at line 10465 of file z3py.py.
10465def _mk_fp_tern(f, rm, a, b, c, ctx):
10466 ctx = _get_ctx(ctx)
10467 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10468 if z3_debug():
10469 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10470 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10471 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10472 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10473
10474
◆ _mk_fp_unary()
|
protected |
Definition at line 10423 of file z3py.py.
10423def _mk_fp_unary(f, rm, a, ctx):
10424 ctx = _get_ctx(ctx)
10425 [a] = _coerce_fp_expr_list([a], ctx)
10426 if z3_debug():
10427 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10428 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10429 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10430
10431
◆ _mk_fp_unary_pred()
|
protected |
Definition at line 10432 of file z3py.py.
10432def _mk_fp_unary_pred(f, a, ctx):
10433 ctx = _get_ctx(ctx)
10434 [a] = _coerce_fp_expr_list([a], ctx)
10435 if z3_debug():
10436 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10437 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10438
10439
◆ _mk_quantifier()
|
protected |
Definition at line 2274 of file z3py.py.
2274def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2275 if z3_debug():
2276 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2277 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2278 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2279 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2280 if is_app(vs):
2281 ctx = vs.ctx
2282 vs = [vs]
2283 else:
2284 ctx = vs[0].ctx
2285 if not is_expr(body):
2286 body = BoolVal(body, ctx)
2287 num_vars = len(vs)
2288 if num_vars == 0:
2289 return body
2290 _vs = (Ast * num_vars)()
2291 for i in range(num_vars):
2292 # TODO: Check if is constant
2293 _vs[i] = vs[i].as_ast()
2294 patterns = [_to_pattern(p) for p in patterns]
2295 num_pats = len(patterns)
2296 _pats = (Pattern * num_pats)()
2297 for i in range(num_pats):
2298 _pats[i] = patterns[i].ast
2299 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2300 qid = to_symbol(qid, ctx)
2301 skid = to_symbol(skid, ctx)
2303 num_vars, _vs,
2304 num_pats, _pats,
2305 num_no_pats, _no_pats,
2306 body.as_ast()), ctx)
2307
2308
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 8548 of file z3py.py.
8548def _or_else(t1, t2, ctx=None):
8549 t1 = _to_tactic(t1, ctx)
8550 t2 = _to_tactic(t2, ctx)
8551 if z3_debug():
8552 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8554
8555
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 9239 of file z3py.py.
9239def _pb_args_coeffs(args, default_ctx=None):
9240 args = _get_args_ast_list(args)
9241 if len(args) == 0:
9242 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9243 args = [_reorder_pb_arg(arg) for arg in args]
9244 args, coeffs = zip(*args)
9245 if z3_debug():
9246 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9247 ctx = _ctx_from_ast_arg_list(args)
9248 if z3_debug():
9249 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9250 args = _coerce_expr_list(args, ctx)
9251 _args, sz = _to_ast_array(args)
9252 _coeffs = (ctypes.c_int * len(coeffs))()
9253 for i in range(len(coeffs)):
9254 _z3_check_cint_overflow(coeffs[i], "coefficient")
9255 _coeffs[i] = coeffs[i]
9256 return ctx, sz, _args, _coeffs, args
9257
9258
◆ _probe_and()
|
protected |
◆ _probe_nary()
|
protected |
Definition at line 8953 of file z3py.py.
8953def _probe_nary(f, args, ctx):
8954 if z3_debug():
8955 _z3_assert(len(args) > 0, "At least one argument expected")
8956 num = len(args)
8957 r = _to_probe(args[0], ctx)
8958 for i in range(num - 1):
8959 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8960 return r
8961
8962
◆ _probe_or()
|
protected |
◆ _prove_html()
|
protected |
Version of function `prove` that renders HTML.
Definition at line 9430 of file z3py.py.
9430def _prove_html(claim, show=False, **keywords):
9431 """Version of function `prove` that renders HTML."""
9432 if z3_debug():
9433 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9434 s = Solver()
9435 s.set(**keywords)
9436 s.add(Not(claim))
9437 if show:
9438 print(s)
9439 r = s.check()
9440 if r == unsat:
9441 print("<b>proved</b>")
9442 elif r == unknown:
9443 print("<b>failed to prove</b>")
9444 print(s.model())
9445 else:
9446 print("<b>counterexample</b>")
9447 print(s.model())
9448
9449
◆ _py2expr()
|
protected |
Definition at line 3216 of file z3py.py.
3216def _py2expr(a, ctx=None):
3217 if isinstance(a, bool):
3218 return BoolVal(a, ctx)
3219 if _is_int(a):
3220 return IntVal(a, ctx)
3221 if isinstance(a, float):
3222 return RealVal(a, ctx)
3223 if isinstance(a, str):
3224 return StringVal(a, ctx)
3225 if is_expr(a):
3226 return a
3227 if z3_debug():
3228 _z3_assert(False, "Python bool, int, long or float expected")
3229
3230
Referenced by _coerce_expr_list(), _coerce_exprs(), IsMember(), K(), SetAdd(), SetDel(), SetHasSize(), and ModelRef.update_value().
◆ _reduce()
|
protected |
Definition at line 1270 of file z3py.py.
1270def _reduce(func, sequence, initial):
1271 result = initial
1272 for element in sequence:
1273 result = func(result, element)
1274 return result
1275
1276
Referenced by _coerce_expr_list().
◆ _reorder_pb_arg()
|
protected |
◆ _solve_html()
|
protected |
Version of function `solve` that renders HTML output.
Definition at line 9381 of file z3py.py.
9381def _solve_html(*args, **keywords):
9382 """Version of function `solve` that renders HTML output."""
9383 show = keywords.pop("show", False)
9384 s = Solver()
9385 s.set(**keywords)
9386 s.add(*args)
9387 if show:
9388 print("<b>Problem:</b>")
9389 print(s)
9390 r = s.check()
9391 if r == unsat:
9392 print("<b>no solution</b>")
9393 elif r == unknown:
9394 print("<b>failed to solve</b>")
9395 try:
9396 print(s.model())
9397 except Z3Exception:
9398 return
9399 else:
9400 if show:
9401 print("<b>Solution:</b>")
9402 print(s.model())
9403
9404
◆ _solve_using_html()
|
protected |
Version of function `solve_using` that renders HTML.
Definition at line 9405 of file z3py.py.
9405def _solve_using_html(s, *args, **keywords):
9406 """Version of function `solve_using` that renders HTML."""
9407 show = keywords.pop("show", False)
9408 if z3_debug():
9409 _z3_assert(isinstance(s, Solver), "Solver object expected")
9410 s.set(**keywords)
9411 s.add(*args)
9412 if show:
9413 print("<b>Problem:</b>")
9414 print(s)
9415 r = s.check()
9416 if r == unsat:
9417 print("<b>no solution</b>")
9418 elif r == unknown:
9419 print("<b>failed to solve</b>")
9420 try:
9421 print(s.model())
9422 except Z3Exception:
9423 return
9424 else:
9425 if show:
9426 print("<b>Solution:</b>")
9427 print(s.model())
9428
9429
◆ _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 10185 of file z3py.py.
10185def _to_float_str(val, exp=0):
10186 if isinstance(val, float):
10187 if math.isnan(val):
10188 res = "NaN"
10189 elif val == 0.0:
10190 sone = math.copysign(1.0, val)
10191 if sone < 0.0:
10192 return "-0.0"
10193 else:
10194 return "+0.0"
10195 elif val == float("+inf"):
10196 res = "+oo"
10197 elif val == float("-inf"):
10198 res = "-oo"
10199 else:
10200 v = val.as_integer_ratio()
10201 num = v[0]
10202 den = v[1]
10203 rvs = str(num) + "/" + str(den)
10204 res = rvs + "p" + _to_int_str(exp)
10205 elif isinstance(val, bool):
10206 if val:
10207 res = "1.0"
10208 else:
10209 res = "0.0"
10210 elif _is_int(val):
10211 res = str(val)
10212 elif isinstance(val, str):
10213 inx = val.find("*(2**")
10214 if inx == -1:
10215 res = val
10216 elif val[-1] == ")":
10217 res = val[0:inx]
10218 exp = str(int(val[inx + 5:-1]) + int(exp))
10219 else:
10220 _z3_assert(False, "String does not have floating-point numeral form.")
10221 elif z3_debug():
10222 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10223 if exp == 0:
10224 return res
10225 else:
10226 return res + "p" + exp
10227
10228
◆ _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 3265 of file z3py.py.
3265def _to_int_str(val):
3266 if isinstance(val, float):
3267 return str(int(val))
3268 elif isinstance(val, bool):
3269 if val:
3270 return "1"
3271 else:
3272 return "0"
3273 else:
3274 return str(val)
3275
3276
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 2052 of file z3py.py.
2052def _to_pattern(arg):
2053 if is_pattern(arg):
2054 return arg
2055 else:
2056 return MultiPattern(arg)
2057
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 5156 of file z3py.py.
5156def _valid_accessor(acc):
5157 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5158 if not isinstance(acc, tuple):
5159 return False
5160 if len(acc) != 2:
5161 return False
5162 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5163
5164
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 11628 of file z3py.py.
11628def AllChar(regex_sort, ctx=None):
11629 """Create a regular expression that accepts all single character strings
11630 """
11632
11633# Special Relations
11634
11635
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 1926 of file z3py.py.
1926def And(*args):
1927 """Create a Z3 and-expression or and-probe.
1928
1929 >>> p, q, r = Bools('p q r')
1930 >>> And(p, q, r)
1931 And(p, q, r)
1932 >>> P = BoolVector('p', 5)
1933 >>> And(P)
1934 And(p__0, p__1, p__2, p__3, p__4)
1935 """
1936 last_arg = None
1937 if len(args) > 0:
1938 last_arg = args[len(args) - 1]
1939 if isinstance(last_arg, Context):
1940 ctx = args[len(args) - 1]
1941 args = args[:len(args) - 1]
1942 elif len(args) == 1 and isinstance(args[0], AstVector):
1943 ctx = args[0].ctx
1944 args = [a for a in args[0]]
1945 else:
1946 ctx = None
1947 args = _get_args(args)
1948 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1949 if z3_debug():
1950 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1951 if _has_probe(args):
1952 return _probe_and(args, ctx)
1953 else:
1954 args = _coerce_expr_list(args, ctx)
1955 _args, sz = _to_ast_array(args)
1957
1958
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 8556 of file z3py.py.
8556def AndThen(*ts, **ks):
8557 """Return a tactic that applies the tactics in `*ts` in sequence.
8558
8559 >>> x, y = Ints('x y')
8560 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8561 >>> t(And(x == 0, y > x + 1))
8562 [[Not(y <= 1)]]
8563 >>> t(And(x == 0, y > x + 1)).as_expr()
8564 Not(y <= 1)
8565 """
8566 if z3_debug():
8567 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8568 ctx = ks.get("ctx", None)
8569 num = len(ts)
8570 r = ts[0]
8571 for i in range(num - 1):
8572 r = _and_then(r, ts[i + 1], ctx)
8573 return r
8574
8575
◆ 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 5585 of file z3py.py.
5585def args2params(arguments, keywords, ctx=None):
5586 """Convert python arguments into a Z3_params object.
5587 A ':' is added to the keywords, and '_' is replaced with '-'
5588
5589 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5590 (params model true relevancy 2 elim_and true)
5591 """
5592 if z3_debug():
5593 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5594 prev = None
5595 r = ParamsRef(ctx)
5596 for a in arguments:
5597 if prev is None:
5598 prev = a
5599 else:
5600 r.set(prev, a)
5601 prev = None
5602 for k in keywords:
5603 v = keywords[k]
5604 r.set(k, v)
5605 return r
5606
5607
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 4852 of file z3py.py.
4852def Array(name, *sorts):
4853 """Return an array constant named `name` with the given domain and range sorts.
4854
4855 >>> a = Array('a', IntSort(), IntSort())
4856 >>> a.sort()
4857 Array(Int, Int)
4858 >>> a[0]
4859 a[0]
4860 """
4861 s = ArraySort(sorts)
4862 ctx = s.ctx
4864
4865
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 4819 of file z3py.py.
4819def ArraySort(*sig):
4820 """Return the Z3 array sort with the given domain and range sorts.
4821
4822 >>> A = ArraySort(IntSort(), BoolSort())
4823 >>> A
4824 Array(Int, Bool)
4825 >>> A.domain()
4826 Int
4827 >>> A.range()
4828 Bool
4829 >>> AA = ArraySort(IntSort(), A)
4830 >>> AA
4831 Array(Int, Array(Int, Bool))
4832 """
4833 sig = _get_args(sig)
4834 if z3_debug():
4835 _z3_assert(len(sig) > 1, "At least two arguments expected")
4836 arity = len(sig) - 1
4837 r = sig[arity]
4838 d = sig[0]
4839 if z3_debug():
4840 for s in sig:
4841 _z3_assert(is_sort(s), "Z3 sort expected")
4842 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4843 ctx = d.ctx
4844 if len(sig) == 2:
4846 dom = (Sort * arity)()
4847 for i in range(arity):
4848 dom[i] = sig[i].ast
4850
4851
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 9214 of file z3py.py.
9214def AtLeast(*args):
9215 """Create an at-least Pseudo-Boolean k constraint.
9216
9217 >>> a, b, c = Bools('a b c')
9218 >>> f = AtLeast(a, b, c, 2)
9219 """
9220 args = _get_args(args)
9221 if z3_debug():
9222 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9223 ctx = _ctx_from_ast_arg_list(args)
9224 if z3_debug():
9225 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9226 args1 = _coerce_expr_list(args[:-1], ctx)
9227 k = args[-1]
9228 _args, sz = _to_ast_array(args1)
9230
9231
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 9196 of file z3py.py.
9196def AtMost(*args):
9197 """Create an at-most Pseudo-Boolean k constraint.
9198
9199 >>> a, b, c = Bools('a b c')
9200 >>> f = AtMost(a, b, c, 2)
9201 """
9202 args = _get_args(args)
9203 if z3_debug():
9204 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9205 ctx = _ctx_from_ast_arg_list(args)
9206 if z3_debug():
9207 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9208 args1 = _coerce_expr_list(args[:-1], ctx)
9209 k = args[-1]
9210 _args, sz = _to_ast_array(args1)
9212
9213
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 4133 of file z3py.py.
4133def BitVec(name, bv, ctx=None):
4134 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4135 If `ctx=None`, then the global context is used.
4136
4137 >>> x = BitVec('x', 16)
4138 >>> is_bv(x)
4139 True
4140 >>> x.size()
4141 16
4142 >>> x.sort()
4143 BitVec(16)
4144 >>> word = BitVecSort(16)
4145 >>> x2 = BitVec('x', word)
4146 >>> eq(x, x2)
4147 True
4148 """
4149 if isinstance(bv, BitVecSortRef):
4150 ctx = bv.ctx
4151 else:
4152 ctx = _get_ctx(ctx)
4153 bv = BitVecSort(bv, ctx)
4155
4156
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 4157 of file z3py.py.
4157def BitVecs(names, bv, ctx=None):
4158 """Return a tuple of bit-vector constants of size bv.
4159
4160 >>> x, y, z = BitVecs('x y z', 16)
4161 >>> x.size()
4162 16
4163 >>> x.sort()
4164 BitVec(16)
4165 >>> Sum(x, y, z)
4166 0 + x + y + z
4167 >>> Product(x, y, z)
4168 1*x*y*z
4169 >>> simplify(Product(x, y, z))
4170 x*y*z
4171 """
4172 ctx = _get_ctx(ctx)
4173 if isinstance(names, str):
4174 names = names.split(" ")
4175 return [BitVec(name, bv, ctx) for name in names]
4176
4177
◆ 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 4101 of file z3py.py.
4101def BitVecSort(sz, ctx=None):
4102 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4103
4104 >>> Byte = BitVecSort(8)
4105 >>> Word = BitVecSort(16)
4106 >>> Byte
4107 BitVec(8)
4108 >>> x = Const('x', Byte)
4109 >>> eq(x, BitVec('x', 8))
4110 True
4111 """
4112 ctx = _get_ctx(ctx)
4114
4115
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 4116 of file z3py.py.
4116def BitVecVal(val, bv, ctx=None):
4117 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4118
4119 >>> v = BitVecVal(10, 32)
4120 >>> v
4121 10
4122 >>> print("0x%.8x" % v.as_long())
4123 0x0000000a
4124 """
4125 if is_bv_sort(bv):
4126 ctx = bv.ctx
4128 else:
4129 ctx = _get_ctx(ctx)
4131
4132
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 1805 of file z3py.py.
1805def Bool(name, ctx=None):
1806 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1807
1808 >>> p = Bool('p')
1809 >>> q = Bool('q')
1810 >>> And(p, q)
1811 And(p, q)
1812 """
1813 ctx = _get_ctx(ctx)
1815
1816
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 1817 of file z3py.py.
1817def Bools(names, ctx=None):
1818 """Return a tuple of Boolean constants.
1819
1820 `names` is a single string containing all names separated by blank spaces.
1821 If `ctx=None`, then the global context is used.
1822
1823 >>> p, q, r = Bools('p q r')
1824 >>> And(p, Or(q, r))
1825 And(p, Or(q, r))
1826 """
1827 ctx = _get_ctx(ctx)
1828 if isinstance(names, str):
1829 names = names.split(" ")
1830 return [Bool(name, ctx) for name in names]
1831
1832
◆ 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 1768 of file z3py.py.
1768def BoolSort(ctx=None):
1769 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1770
1771 >>> BoolSort()
1772 Bool
1773 >>> p = Const('p', BoolSort())
1774 >>> is_bool(p)
1775 True
1776 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1777 >>> r(0, 1)
1778 r(0, 1)
1779 >>> is_bool(r(0, 1))
1780 True
1781 """
1782 ctx = _get_ctx(ctx)
1784
1785
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 1786 of file z3py.py.
1786def BoolVal(val, ctx=None):
1787 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1788
1789 >>> BoolVal(True)
1790 True
1791 >>> is_true(BoolVal(True))
1792 True
1793 >>> is_true(True)
1794 False
1795 >>> is_false(BoolVal(False))
1796 True
1797 """
1798 ctx = _get_ctx(ctx)
1799 if val:
1801 else:
1803
1804
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 1833 of file z3py.py.
1833def BoolVector(prefix, sz, ctx=None):
1834 """Return a list of Boolean constants of size `sz`.
1835
1836 The constants are named using the given prefix.
1837 If `ctx=None`, then the global context is used.
1838
1839 >>> P = BoolVector('p', 3)
1840 >>> P
1841 [p__0, p__1, p__2]
1842 >>> And(P)
1843 And(p__0, p__1, p__2)
1844 """
1845 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1846
1847
◆ 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 4069 of file z3py.py.
4069def BV2Int(a, is_signed=False):
4070 """Return the Z3 expression BV2Int(a).
4071
4072 >>> b = BitVec('b', 3)
4073 >>> BV2Int(b).sort()
4074 Int
4075 >>> x = Int('x')
4076 >>> x > BV2Int(b)
4077 x > BV2Int(b)
4078 >>> x > BV2Int(b, is_signed=False)
4079 x > BV2Int(b)
4080 >>> x > BV2Int(b, is_signed=True)
4081 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4082 >>> solve(x > BV2Int(b), b == 1, x < 3)
4083 [x = 2, b = 1]
4084 """
4085 if z3_debug():
4086 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4087 ctx = a.ctx
4088 # investigate problem with bv2int
4090
4091
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 4578 of file z3py.py.
4578def BVAddNoOverflow(a, b, signed):
4579 """A predicate the determines that bit-vector addition does not overflow"""
4580 _check_bv_args(a, b)
4581 a, b = _coerce_exprs(a, b)
4583
4584
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 4585 of file z3py.py.
4585def BVAddNoUnderflow(a, b):
4586 """A predicate the determines that signed bit-vector addition does not underflow"""
4587 _check_bv_args(a, b)
4588 a, b = _coerce_exprs(a, b)
4590
4591
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 4620 of file z3py.py.
4620def BVMulNoOverflow(a, b, signed):
4621 """A predicate the determines that bit-vector multiplication does not overflow"""
4622 _check_bv_args(a, b)
4623 a, b = _coerce_exprs(a, b)
4625
4626
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 4627 of file z3py.py.
4627def BVMulNoUnderflow(a, b):
4628 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4629 _check_bv_args(a, b)
4630 a, b = _coerce_exprs(a, b)
4632
4633
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 4564 of file z3py.py.
4564def BVRedAnd(a):
4565 """Return the reduction-and expression of `a`."""
4566 if z3_debug():
4567 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4569
4570
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 4571 of file z3py.py.
4571def BVRedOr(a):
4572 """Return the reduction-or expression of `a`."""
4573 if z3_debug():
4574 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4576
4577
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 4606 of file z3py.py.
4606def BVSDivNoOverflow(a, b):
4607 """A predicate the determines that bit-vector signed division does not overflow"""
4608 _check_bv_args(a, b)
4609 a, b = _coerce_exprs(a, b)
4611
4612
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 4613 of file z3py.py.
4613def BVSNegNoOverflow(a):
4614 """A predicate the determines that bit-vector unary negation does not overflow"""
4615 if z3_debug():
4616 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4618
4619
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 4592 of file z3py.py.
4592def BVSubNoOverflow(a, b):
4593 """A predicate the determines that bit-vector subtraction does not overflow"""
4594 _check_bv_args(a, b)
4595 a, b = _coerce_exprs(a, b)
4597
4598
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 4599 of file z3py.py.
4599def BVSubNoUnderflow(a, b, signed):
4600 """A predicate the determines that bit-vector subtraction does not underflow"""
4601 _check_bv_args(a, b)
4602 a, b = _coerce_exprs(a, b)
4604
4605
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 3515 of file z3py.py.
3515def Cbrt(a, ctx=None):
3516 """ Return a Z3 expression which represents the cubic root of a.
3517
3518 >>> x = Real('x')
3519 >>> Cbrt(x)
3520 x**(1/3)
3521 """
3522 if not is_expr(a):
3523 ctx = _get_ctx(ctx)
3524 a = RealVal(a, ctx)
3525 return a ** "1/3"
3526
◆ 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 4178 of file z3py.py.
4178def Concat(*args):
4179 """Create a Z3 bit-vector concatenation expression.
4180
4181 >>> v = BitVecVal(1, 4)
4182 >>> Concat(v, v+1, v)
4183 Concat(Concat(1, 1 + 1), 1)
4184 >>> simplify(Concat(v, v+1, v))
4185 289
4186 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4187 121
4188 """
4189 args = _get_args(args)
4190 sz = len(args)
4191 if z3_debug():
4192 _z3_assert(sz >= 2, "At least two arguments expected.")
4193
4194 ctx = None
4195 for a in args:
4196 if is_expr(a):
4197 ctx = a.ctx
4198 break
4199 if is_seq(args[0]) or isinstance(args[0], str):
4200 args = [_coerce_seq(s, ctx) for s in args]
4201 if z3_debug():
4202 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4203 v = (Ast * sz)()
4204 for i in range(sz):
4205 v[i] = args[i].as_ast()
4207
4208 if is_re(args[0]):
4209 if z3_debug():
4210 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4211 v = (Ast * sz)()
4212 for i in range(sz):
4213 v[i] = args[i].as_ast()
4215
4216 if z3_debug():
4217 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4218 r = args[0]
4219 for i in range(sz - 1):
4220 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4221 return r
4222
4223
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 9013 of file z3py.py.
9013def Cond(p, t1, t2, ctx=None):
9014 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
9015
9016 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
9017 """
9018 p = _to_probe(p, ctx)
9019 t1 = _to_tactic(t1, ctx)
9020 t2 = _to_tactic(t2, ctx)
9022
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 1484 of file z3py.py.
1484def Const(name, sort):
1485 """Create a constant of the given sort.
1486
1487 >>> Const('x', IntSort())
1488 x
1489 """
1490 if z3_debug():
1491 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1492 ctx = sort.ctx
1494
1495
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 1496 of file z3py.py.
1496def Consts(names, sort):
1497 """Create several constants of the given sort.
1498
1499 `names` is a string containing the names of all constants to be created.
1500 Blank spaces separate the names of different constants.
1501
1502 >>> x, y, z = Consts('x y z', IntSort())
1503 >>> x + y + z
1504 x + y + z
1505 """
1506 if isinstance(names, str):
1507 names = names.split(" ")
1508 return [Const(name, sort) for name in names]
1509
1510
◆ 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 11315 of file z3py.py.
11315def Contains(a, b):
11316 """Check if 'a' contains 'b'
11317 >>> s1 = Contains("abc", "ab")
11318 >>> simplify(s1)
11319 True
11320 >>> s2 = Contains("abc", "bc")
11321 >>> simplify(s2)
11322 True
11323 >>> x, y, z = Strings('x y z')
11324 >>> s3 = Contains(Concat(x,y,z), y)
11325 >>> simplify(s3)
11326 True
11327 """
11328 ctx = _get_ctx2(a, b)
11329 a = _coerce_seq(a, ctx)
11330 b = _coerce_seq(b, ctx)
11332
11333
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 5277 of file z3py.py.
5277def CreateDatatypes(*ds):
5278 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5279
5280 In the following example we define a Tree-List using two mutually recursive datatypes.
5281
5282 >>> TreeList = Datatype('TreeList')
5283 >>> Tree = Datatype('Tree')
5284 >>> # Tree has two constructors: leaf and node
5285 >>> Tree.declare('leaf', ('val', IntSort()))
5286 >>> # a node contains a list of trees
5287 >>> Tree.declare('node', ('children', TreeList))
5288 >>> TreeList.declare('nil')
5289 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5290 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5291 >>> Tree.val(Tree.leaf(10))
5292 val(leaf(10))
5293 >>> simplify(Tree.val(Tree.leaf(10)))
5294 10
5295 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5296 >>> n1
5297 node(cons(leaf(10), cons(leaf(20), nil)))
5298 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5299 >>> simplify(n2 == n1)
5300 False
5301 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5302 True
5303 """
5304 ds = _get_args(ds)
5305 if z3_debug():
5306 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5307 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5308 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5309 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5310 ctx = ds[0].ctx
5311 num = len(ds)
5312 names = (Symbol * num)()
5313 out = (Sort * num)()
5314 clists = (ConstructorList * num)()
5315 to_delete = []
5316 for i in range(num):
5317 d = ds[i]
5318 names[i] = to_symbol(d.name, ctx)
5319 num_cs = len(d.constructors)
5320 cs = (Constructor * num_cs)()
5321 for j in range(num_cs):
5322 c = d.constructors[j]
5323 cname = to_symbol(c[0], ctx)
5324 rname = to_symbol(c[1], ctx)
5325 fs = c[2]
5326 num_fs = len(fs)
5327 fnames = (Symbol * num_fs)()
5328 sorts = (Sort * num_fs)()
5329 refs = (ctypes.c_uint * num_fs)()
5330 for k in range(num_fs):
5331 fname = fs[k][0]
5332 ftype = fs[k][1]
5333 fnames[k] = to_symbol(fname, ctx)
5334 if isinstance(ftype, Datatype):
5335 if z3_debug():
5336 _z3_assert(
5337 ds.count(ftype) == 1,
5338 "One and only one occurrence of each datatype is expected",
5339 )
5340 sorts[k] = None
5341 refs[k] = ds.index(ftype)
5342 else:
5343 if z3_debug():
5344 _z3_assert(is_sort(ftype), "Z3 sort expected")
5345 sorts[k] = ftype.ast
5346 refs[k] = 0
5347 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5348 to_delete.append(ScopedConstructor(cs[j], ctx))
5349 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5350 to_delete.append(ScopedConstructorList(clists[i], ctx))
5351 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5352 result = []
5353 # Create a field for every constructor, recognizer and accessor
5354 for i in range(num):
5355 dref = DatatypeSortRef(out[i], ctx)
5356 num_cs = dref.num_constructors()
5357 for j in range(num_cs):
5358 cref = dref.constructor(j)
5359 cref_name = cref.name()
5360 cref_arity = cref.arity()
5361 if cref.arity() == 0:
5362 cref = cref()
5363 setattr(dref, cref_name, cref)
5364 rref = dref.recognizer(j)
5365 setattr(dref, "is_" + cref_name, rref)
5366 for k in range(cref_arity):
5367 aref = dref.accessor(j, k)
5368 setattr(dref, aref.name(), aref)
5369 result.append(dref)
5370 return tuple(result)
5371
5372
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, | |
| ctx = None ) |
Create a reference to a sort that was declared, or will be declared, as a recursive datatype
Definition at line 5477 of file z3py.py.
5477def DatatypeSort(name, ctx = None):
5478 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5479 ctx = _get_ctx(ctx)
5481
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name)
create a forward reference to a recursive datatype being declared. The forward reference can be used ...
◆ 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 4898 of file z3py.py.
4898def Default(a):
4899 """ Return a default value for array expression.
4900 >>> b = K(IntSort(), 1)
4901 >>> prove(Default(b) == 1)
4902 proved
4903 """
4904 if z3_debug():
4905 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4906 return a.default()
4907
4908
◆ describe_probes()
| describe_probes | ( | ) |
Display a (tabular) description of all available probes in Z3.
Definition at line 8934 of file z3py.py.
8934def describe_probes():
8935 """Display a (tabular) description of all available probes in Z3."""
8936 if in_html_mode():
8937 even = True
8938 print('<table border="1" cellpadding="2" cellspacing="0">')
8939 for p in probes():
8940 if even:
8941 print('<tr style="background-color:#CFCFCF">')
8942 even = False
8943 else:
8944 print("<tr>")
8945 even = True
8946 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8947 print("</table>")
8948 else:
8949 for p in probes():
8950 print("%s : %s" % (p, probe_description(p)))
8951
8952
◆ describe_tactics()
| describe_tactics | ( | ) |
Display a (tabular) description of all available tactics in Z3.
Definition at line 8728 of file z3py.py.
8728def describe_tactics():
8729 """Display a (tabular) description of all available tactics in Z3."""
8730 if in_html_mode():
8731 even = True
8732 print('<table border="1" cellpadding="2" cellspacing="0">')
8733 for t in tactics():
8734 if even:
8735 print('<tr style="background-color:#CFCFCF">')
8736 even = False
8737 else:
8738 print("<tr>")
8739 even = True
8740 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8741 print("</table>")
8742 else:
8743 for t in tactics():
8744 print("%s : %s" % (t, tactic_description(t)))
8745
8746
◆ 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 11620 of file z3py.py.
11620def Diff(a, b, ctx=None):
11621 """Create the difference regular expression
11622 """
11623 if z3_debug():
11624 _z3_assert(is_expr(a), "expression expected")
11625 _z3_assert(is_expr(b), "expression expected")
11627
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 5494 of file z3py.py.
5494def DisjointSum(name, sorts, ctx=None):
5495 """Create a named tagged union sort base on a set of underlying sorts
5496 Example:
5497 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5498 """
5499 sum = Datatype(name, ctx)
5500 for i in range(len(sorts)):
5501 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5502 sum = sum.create()
5503 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5504
5505
◆ 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 1451 of file z3py.py.
1451def Distinct(*args):
1452 """Create a Z3 distinct expression.
1453
1454 >>> x = Int('x')
1455 >>> y = Int('y')
1456 >>> Distinct(x, y)
1457 x != y
1458 >>> z = Int('z')
1459 >>> Distinct(x, y, z)
1460 Distinct(x, y, z)
1461 >>> simplify(Distinct(x, y, z))
1462 Distinct(x, y, z)
1463 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1464 And(Not(x == y), Not(x == z), Not(y == z))
1465 """
1466 args = _get_args(args)
1467 ctx = _ctx_from_ast_arg_list(args)
1468 if z3_debug():
1469 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1470 args = _coerce_expr_list(args, ctx)
1471 _args, sz = _to_ast_array(args)
1473
1474
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 11245 of file z3py.py.
11245def Empty(s):
11246 """Create the empty sequence of the given sort
11247 >>> e = Empty(StringSort())
11248 >>> e2 = StringVal("")
11249 >>> print(e.eq(e2))
11250 True
11251 >>> e3 = Empty(SeqSort(IntSort()))
11252 >>> print(e3)
11253 Empty(Seq(Int))
11254 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11255 >>> print(e4)
11256 Empty(ReSort(Seq(Int)))
11257 """
11258 if isinstance(s, SeqSortRef):
11260 if isinstance(s, ReSortRef):
11262 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11263
11264
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 5506 of file z3py.py.
5506def EnumSort(name, values, ctx=None):
5507 """Return a new enumeration sort named `name` containing the given values.
5508
5509 The result is a pair (sort, list of constants).
5510 Example:
5511 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5512 """
5513 if z3_debug():
5514 _z3_assert(isinstance(name, str), "Name must be a string")
5515 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
5516 _z3_assert(len(values) > 0, "At least one value expected")
5517 ctx = _get_ctx(ctx)
5518 num = len(values)
5519 _val_names = (Symbol * num)()
5520 for i in range(num):
5521 _val_names[i] = to_symbol(values[i], ctx)
5522 _values = (FuncDecl * num)()
5523 _testers = (FuncDecl * num)()
5524 name = to_symbol(name, ctx)
5525 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5526 V = []
5527 for i in range(num):
5528 V.append(FuncDeclRef(_values[i], ctx))
5529 V = [a() for a in V]
5530 return S, V
5531
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 2327 of file z3py.py.
2327def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2328 """Create a Z3 exists formula.
2329
2330 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2331
2332
2333 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2334 >>> x = Int('x')
2335 >>> y = Int('y')
2336 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2337 >>> q
2338 Exists([x, y], f(x, y) >= x)
2339 >>> is_quantifier(q)
2340 True
2341 >>> r = Tactic('nnf')(q).as_expr()
2342 >>> is_quantifier(r)
2343 False
2344 """
2345 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2346
2347
◆ 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 4987 of file z3py.py.
4987def Ext(a, b):
4988 """Return extensionality index for one-dimensional arrays.
4989 >> a, b = Consts('a b', SetSort(IntSort()))
4990 >> Ext(a, b)
4991 Ext(a, b)
4992 """
4993 ctx = a.ctx
4994 if z3_debug():
4995 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4997
4998
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 4224 of file z3py.py.
4224def Extract(high, low, a):
4225 """Create a Z3 bit-vector extraction expression or sequence extraction expression.
4226
4227 Extract is overloaded to work with both bit-vectors and sequences:
4228
4229 **Bit-vector extraction**: Extract(high, low, bitvector)
4230 Extracts bits from position `high` down to position `low` (both inclusive).
4231 - high: int - the highest bit position to extract (0-indexed from right)
4232 - low: int - the lowest bit position to extract (0-indexed from right)
4233 - bitvector: BitVecRef - the bit-vector to extract from
4234 Returns a new bit-vector containing bits [high:low]
4235
4236 **Sequence extraction**: Extract(sequence, offset, length)
4237 Extracts a subsequence starting at the given offset with the specified length.
4238 The functions SubString and SubSeq are redirected to this form of Extract.
4239 - sequence: SeqRef or str - the sequence to extract from
4240 - offset: int - the starting position (0-indexed)
4241 - length: int - the number of elements to extract
4242 Returns a new sequence containing the extracted subsequence
4243
4244 >>> # Bit-vector extraction examples
4245 >>> x = BitVec('x', 8)
4246 >>> Extract(6, 2, x) # Extract bits 6 down to 2 (5 bits total)
4247 Extract(6, 2, x)
4248 >>> Extract(6, 2, x).sort() # Result is a 5-bit vector
4249 BitVec(5)
4250 >>> Extract(7, 0, x) # Extract all 8 bits
4251 Extract(7, 0, x)
4252 >>> Extract(3, 3, x) # Extract single bit at position 3
4253 Extract(3, 3, x)
4254
4255 >>> # Sequence extraction examples
4256 >>> s = StringVal("hello")
4257 >>> Extract(s, 1, 3) # Extract 3 characters starting at position 1
4258 str.substr("hello", 1, 3)
4259 >>> simplify(Extract(StringVal("abcd"), 2, 1)) # Extract 1 character at position 2
4260 "c"
4261 >>> simplify(Extract(StringVal("abcd"), 0, 2)) # Extract first 2 characters
4262 "ab"
4263 """
4264 if isinstance(high, str):
4265 high = StringVal(high)
4266 if is_seq(high):
4267 s = high
4268 offset, length = _coerce_exprs(low, a, s.ctx)
4269 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4270 if z3_debug():
4271 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4272 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4273 "First and second arguments must be non negative integers")
4274 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4276
4277
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 8971 of file z3py.py.
8971def FailIf(p, ctx=None):
8972 """Return a tactic that fails if the probe `p` evaluates to true.
8973 Otherwise, it returns the input goal unmodified.
8974
8975 In the following example, the tactic applies 'simplify' if and only if there are
8976 more than 2 constraints in the goal.
8977
8978 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8979 >>> x, y = Ints('x y')
8980 >>> g = Goal()
8981 >>> g.add(x > 0)
8982 >>> g.add(y > 0)
8983 >>> t(g)
8984 [[x > 0, y > 0]]
8985 >>> g.add(x == y + 1)
8986 >>> t(g)
8987 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8988 """
8989 p = _to_probe(p, ctx)
8991
8992
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 7902 of file z3py.py.
7902def FiniteDomainSort(name, sz, ctx=None):
7903 """Create a named finite domain sort of a given size sz"""
7904 if not isinstance(name, Symbol):
7905 name = to_symbol(name)
7906 ctx = _get_ctx(ctx)
7908
7909
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 7972 of file z3py.py.
7972def FiniteDomainVal(val, sort, ctx=None):
7973 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7974
7975 >>> s = FiniteDomainSort('S', 256)
7976 >>> FiniteDomainVal(255, s)
7977 255
7978 >>> FiniteDomainVal('100', s)
7979 100
7980 """
7981 if z3_debug():
7982 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7983 ctx = sort.ctx
7985
7986
◆ Float128()
| Float128 | ( | ctx = None | ) |
Floating-point 128-bit (quadruple) sort.
Definition at line 9699 of file z3py.py.
9699def Float128(ctx=None):
9700 """Floating-point 128-bit (quadruple) sort."""
9701 ctx = _get_ctx(ctx)
9703
9704
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 9705 of file z3py.py.
9705def FloatQuadruple(ctx=None):
9706 """Floating-point 128-bit (quadruple) sort."""
9707 ctx = _get_ctx(ctx)
9709
9710
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 2309 of file z3py.py.
2309def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2310 """Create a Z3 forall formula.
2311
2312 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2313
2314 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2315 >>> x = Int('x')
2316 >>> y = Int('y')
2317 >>> ForAll([x, y], f(x, y) >= x)
2318 ForAll([x, y], f(x, y) >= x)
2319 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2320 ForAll([x, y], f(x, y) >= x)
2321 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2322 ForAll([x, y], f(x, y) >= x)
2323 """
2324 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2325
2326
◆ 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 10341 of file z3py.py.
10341def FP(name, fpsort, ctx=None):
10342 """Return a floating-point constant named `name`.
10343 `fpsort` is the floating-point sort.
10344 If `ctx=None`, then the global context is used.
10345
10346 >>> x = FP('x', FPSort(8, 24))
10347 >>> is_fp(x)
10348 True
10349 >>> x.ebits()
10350 8
10351 >>> x.sort()
10352 FPSort(8, 24)
10353 >>> word = FPSort(8, 24)
10354 >>> x2 = FP('x', word)
10355 >>> eq(x, x2)
10356 True
10357 """
10358 if isinstance(fpsort, FPSortRef) and ctx is None:
10359 ctx = fpsort.ctx
10360 else:
10361 ctx = _get_ctx(ctx)
10363
10364
◆ 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 10384 of file z3py.py.
10384def fpAbs(a, ctx=None):
10385 """Create a Z3 floating-point absolute value expression.
10386
10387 >>> s = FPSort(8, 24)
10388 >>> rm = RNE()
10389 >>> x = FPVal(1.0, s)
10390 >>> fpAbs(x)
10391 fpAbs(1)
10392 >>> y = FPVal(-20.0, s)
10393 >>> y
10394 -1.25*(2**4)
10395 >>> fpAbs(y)
10396 fpAbs(-1.25*(2**4))
10397 >>> fpAbs(-1.25*(2**4))
10398 fpAbs(-1.25*(2**4))
10399 >>> fpAbs(x).sort()
10400 FPSort(8, 24)
10401 """
10402 ctx = _get_ctx(ctx)
10403 [a] = _coerce_fp_expr_list([a], ctx)
10405
10406
◆ 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 10475 of file z3py.py.
10475def fpAdd(rm, a, b, ctx=None):
10476 """Create a Z3 floating-point addition expression.
10477
10478 >>> s = FPSort(8, 24)
10479 >>> rm = RNE()
10480 >>> x = FP('x', s)
10481 >>> y = FP('y', s)
10482 >>> fpAdd(rm, x, y)
10483 x + y
10484 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10485 fpAdd(RTZ(), x, y)
10486 >>> fpAdd(rm, x, y).sort()
10487 FPSort(8, 24)
10488 """
10489 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10490
10491
◆ 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 10797 of file z3py.py.
10797def fpBVToFP(v, sort, ctx=None):
10798 """Create a Z3 floating-point conversion expression that represents the
10799 conversion from a bit-vector term to a floating-point term.
10800
10801 >>> x_bv = BitVecVal(0x3F800000, 32)
10802 >>> x_fp = fpBVToFP(x_bv, Float32())
10803 >>> x_fp
10804 fpToFP(1065353216)
10805 >>> simplify(x_fp)
10806 1
10807 """
10808 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10809 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10810 ctx = _get_ctx(ctx)
10812
10813
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 10522 of file z3py.py.
10522def fpDiv(rm, a, b, ctx=None):
10523 """Create a Z3 floating-point division expression.
10524
10525 >>> s = FPSort(8, 24)
10526 >>> rm = RNE()
10527 >>> x = FP('x', s)
10528 >>> y = FP('y', s)
10529 >>> fpDiv(rm, x, y)
10530 x / y
10531 >>> fpDiv(rm, x, y).sort()
10532 FPSort(8, 24)
10533 """
10534 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10535
10536
◆ 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 10705 of file z3py.py.
10705def fpEQ(a, b, ctx=None):
10706 """Create the Z3 floating-point expression `fpEQ(other, self)`.
10707
10708 >>> x, y = FPs('x y', FPSort(8, 24))
10709 >>> fpEQ(x, y)
10710 fpEQ(x, y)
10711 >>> fpEQ(x, y).sexpr()
10712 '(fp.eq x y)'
10713 """
10714 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10715
10716
◆ 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 10729 of file z3py.py.
10729def fpFP(sgn, exp, sig, ctx=None):
10730 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10731
10732 >>> s = FPSort(8, 24)
10733 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10734 >>> print(x)
10735 fpFP(1, 127, 4194304)
10736 >>> xv = FPVal(-1.5, s)
10737 >>> print(xv)
10738 -1.5
10739 >>> slvr = Solver()
10740 >>> slvr.add(fpEQ(x, xv))
10741 >>> slvr.check()
10742 sat
10743 >>> xv = FPVal(+1.5, s)
10744 >>> print(xv)
10745 1.5
10746 >>> slvr = Solver()
10747 >>> slvr.add(fpEQ(x, xv))
10748 >>> slvr.check()
10749 unsat
10750 """
10751 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10752 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10753 ctx = _get_ctx(ctx)
10754 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10756
10757
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.
◆ 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 10814 of file z3py.py.
10814def fpFPToFP(rm, v, sort, ctx=None):
10815 """Create a Z3 floating-point conversion expression that represents the
10816 conversion from a floating-point term to a floating-point term of different precision.
10817
10818 >>> x_sgl = FPVal(1.0, Float32())
10819 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10820 >>> x_dbl
10821 fpToFP(RNE(), 1)
10822 >>> simplify(x_dbl)
10823 1
10824 >>> x_dbl.sort()
10825 FPSort(11, 53)
10826 """
10827 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10828 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10829 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10830 ctx = _get_ctx(ctx)
10832
10833
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 10693 of file z3py.py.
10693def fpGEQ(a, b, ctx=None):
10694 """Create the Z3 floating-point expression `other >= self`.
10695
10696 >>> x, y = FPs('x y', FPSort(8, 24))
10697 >>> fpGEQ(x, y)
10698 x >= y
10699 >>> (x >= y).sexpr()
10700 '(fp.geq x y)'
10701 """
10702 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10703
10704
◆ 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 10681 of file z3py.py.
10681def fpGT(a, b, ctx=None):
10682 """Create the Z3 floating-point expression `other > self`.
10683
10684 >>> x, y = FPs('x y', FPSort(8, 24))
10685 >>> fpGT(x, y)
10686 x > y
10687 >>> (x > y).sexpr()
10688 '(fp.gt x y)'
10689 """
10690 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10691
10692
◆ fpInfinity()
| fpInfinity | ( | s, | |
| negative ) |
Create a Z3 floating-point +oo or -oo term.
Definition at line 10269 of file z3py.py.
10269def fpInfinity(s, negative):
10270 """Create a Z3 floating-point +oo or -oo term."""
10271 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10272 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10274
10275
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 10611 of file z3py.py.
10611def fpIsInf(a, ctx=None):
10612 """Create a Z3 floating-point isInfinite expression.
10613
10614 >>> s = FPSort(8, 24)
10615 >>> x = FP('x', s)
10616 >>> fpIsInf(x)
10617 fpIsInf(x)
10618 """
10619 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10620
10621
◆ 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 10599 of file z3py.py.
10599def fpIsNaN(a, ctx=None):
10600 """Create a Z3 floating-point isNaN expression.
10601
10602 >>> s = FPSort(8, 24)
10603 >>> x = FP('x', s)
10604 >>> y = FP('y', s)
10605 >>> fpIsNaN(x)
10606 fpIsNaN(x)
10607 """
10608 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10609
10610
◆ 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 10669 of file z3py.py.
10669def fpLEQ(a, b, ctx=None):
10670 """Create the Z3 floating-point expression `other <= self`.
10671
10672 >>> x, y = FPs('x y', FPSort(8, 24))
10673 >>> fpLEQ(x, y)
10674 x <= y
10675 >>> (x <= y).sexpr()
10676 '(fp.leq x y)'
10677 """
10678 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10679
10680
◆ 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 10657 of file z3py.py.
10657def fpLT(a, b, ctx=None):
10658 """Create the Z3 floating-point expression `other < self`.
10659
10660 >>> x, y = FPs('x y', FPSort(8, 24))
10661 >>> fpLT(x, y)
10662 x < y
10663 >>> (x < y).sexpr()
10664 '(fp.lt x y)'
10665 """
10666 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10667
10668
◆ 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 10566 of file z3py.py.
10566def fpMax(a, b, ctx=None):
10567 """Create a Z3 floating-point maximum expression.
10568
10569 >>> s = FPSort(8, 24)
10570 >>> rm = RNE()
10571 >>> x = FP('x', s)
10572 >>> y = FP('y', s)
10573 >>> fpMax(x, y)
10574 fpMax(x, y)
10575 >>> fpMax(x, y).sort()
10576 FPSort(8, 24)
10577 """
10578 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10579
10580
◆ 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 10551 of file z3py.py.
10551def fpMin(a, b, ctx=None):
10552 """Create a Z3 floating-point minimum expression.
10553
10554 >>> s = FPSort(8, 24)
10555 >>> rm = RNE()
10556 >>> x = FP('x', s)
10557 >>> y = FP('y', s)
10558 >>> fpMin(x, y)
10559 fpMin(x, y)
10560 >>> fpMin(x, y).sort()
10561 FPSort(8, 24)
10562 """
10563 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10564
10565
◆ fpMinusInfinity()
| fpMinusInfinity | ( | s | ) |
◆ fpMinusZero()
| fpMinusZero | ( | s | ) |
Create a Z3 floating-point -0.0 term.
Definition at line 10282 of file z3py.py.
10282def fpMinusZero(s):
10283 """Create a Z3 floating-point -0.0 term."""
10284 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10286
10287
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 10507 of file z3py.py.
10507def fpMul(rm, a, b, ctx=None):
10508 """Create a Z3 floating-point multiplication expression.
10509
10510 >>> s = FPSort(8, 24)
10511 >>> rm = RNE()
10512 >>> x = FP('x', s)
10513 >>> y = FP('y', s)
10514 >>> fpMul(rm, x, y)
10515 x * y
10516 >>> fpMul(rm, x, y).sort()
10517 FPSort(8, 24)
10518 """
10519 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10520
10521
◆ 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 10229 of file z3py.py.
10229def fpNaN(s):
10230 """Create a Z3 floating-point NaN term.
10231
10232 >>> s = FPSort(8, 24)
10233 >>> set_fpa_pretty(True)
10234 >>> fpNaN(s)
10235 NaN
10236 >>> pb = get_fpa_pretty()
10237 >>> set_fpa_pretty(False)
10238 >>> fpNaN(s)
10239 fpNaN(FPSort(8, 24))
10240 >>> set_fpa_pretty(pb)
10241 """
10242 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10244
10245
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 10407 of file z3py.py.
10407def fpNeg(a, ctx=None):
10408 """Create a Z3 floating-point addition expression.
10409
10410 >>> s = FPSort(8, 24)
10411 >>> rm = RNE()
10412 >>> x = FP('x', s)
10413 >>> fpNeg(x)
10414 -x
10415 >>> fpNeg(x).sort()
10416 FPSort(8, 24)
10417 """
10418 ctx = _get_ctx(ctx)
10419 [a] = _coerce_fp_expr_list([a], ctx)
10421
10422
◆ 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 10717 of file z3py.py.
10717def fpNEQ(a, b, ctx=None):
10718 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10719
10720 >>> x, y = FPs('x y', FPSort(8, 24))
10721 >>> fpNEQ(x, y)
10722 Not(fpEQ(x, y))
10723 >>> (x != y).sexpr()
10724 '(distinct x y)'
10725 """
10726 return Not(fpEQ(a, b, ctx))
10727
10728
◆ 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 10246 of file z3py.py.
10246def fpPlusInfinity(s):
10247 """Create a Z3 floating-point +oo term.
10248
10249 >>> s = FPSort(8, 24)
10250 >>> pb = get_fpa_pretty()
10251 >>> set_fpa_pretty(True)
10252 >>> fpPlusInfinity(s)
10253 +oo
10254 >>> set_fpa_pretty(False)
10255 >>> fpPlusInfinity(s)
10256 fpPlusInfinity(FPSort(8, 24))
10257 >>> set_fpa_pretty(pb)
10258 """
10259 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10261
10262
◆ 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 10834 of file z3py.py.
10834def fpRealToFP(rm, v, sort, ctx=None):
10835 """Create a Z3 floating-point conversion expression that represents the
10836 conversion from a real term to a floating-point term.
10837
10838 >>> x_r = RealVal(1.5)
10839 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10840 >>> x_fp
10841 fpToFP(RNE(), 3/2)
10842 >>> simplify(x_fp)
10843 1.5
10844 """
10845 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10846 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10847 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10848 ctx = _get_ctx(ctx)
10850
10851
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 10537 of file z3py.py.
10537def fpRem(a, b, ctx=None):
10538 """Create a Z3 floating-point remainder expression.
10539
10540 >>> s = FPSort(8, 24)
10541 >>> x = FP('x', s)
10542 >>> y = FP('y', s)
10543 >>> fpRem(x, y)
10544 fpRem(x, y)
10545 >>> fpRem(x, y).sort()
10546 FPSort(8, 24)
10547 """
10548 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10549
10550
◆ 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 10365 of file z3py.py.
10365def FPs(names, fpsort, ctx=None):
10366 """Return an array of floating-point constants.
10367
10368 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10369 >>> x.sort()
10370 FPSort(8, 24)
10371 >>> x.sbits()
10372 24
10373 >>> x.ebits()
10374 8
10375 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10376 (x + y) * z
10377 """
10378 ctx = _get_ctx(ctx)
10379 if isinstance(names, str):
10380 names = names.split(" ")
10381 return [FP(name, fpsort, ctx) for name in names]
10382
10383
◆ 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 10852 of file z3py.py.
10852def fpSignedToFP(rm, v, sort, ctx=None):
10853 """Create a Z3 floating-point conversion expression that represents the
10854 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10855
10856 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10857 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10858 >>> x_fp
10859 fpToFP(RNE(), 4294967291)
10860 >>> simplify(x_fp)
10861 -1.25*(2**2)
10862 """
10863 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10864 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10865 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10866 ctx = _get_ctx(ctx)
10868
10869
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 10170 of file z3py.py.
10170def FPSort(ebits, sbits, ctx=None):
10171 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10172
10173 >>> Single = FPSort(8, 24)
10174 >>> Double = FPSort(11, 53)
10175 >>> Single
10176 FPSort(8, 24)
10177 >>> x = Const('x', Single)
10178 >>> eq(x, FP('x', FPSort(8, 24)))
10179 True
10180 """
10181 ctx = _get_ctx(ctx)
10183
10184
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 10492 of file z3py.py.
10492def fpSub(rm, a, b, ctx=None):
10493 """Create a Z3 floating-point subtraction expression.
10494
10495 >>> s = FPSort(8, 24)
10496 >>> rm = RNE()
10497 >>> x = FP('x', s)
10498 >>> y = FP('y', s)
10499 >>> fpSub(rm, x, y)
10500 x - y
10501 >>> fpSub(rm, x, y).sort()
10502 FPSort(8, 24)
10503 """
10504 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10505
10506
◆ 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 10758 of file z3py.py.
10758def fpToFP(a1, a2=None, a3=None, ctx=None):
10759 """Create a Z3 floating-point conversion expression from other term sorts
10760 to floating-point.
10761
10762 From a bit-vector term in IEEE 754-2008 format:
10763 >>> x = FPVal(1.0, Float32())
10764 >>> x_bv = fpToIEEEBV(x)
10765 >>> simplify(fpToFP(x_bv, Float32()))
10766 1
10767
10768 From a floating-point term with different precision:
10769 >>> x = FPVal(1.0, Float32())
10770 >>> x_db = fpToFP(RNE(), x, Float64())
10771 >>> x_db.sort()
10772 FPSort(11, 53)
10773
10774 From a real term:
10775 >>> x_r = RealVal(1.5)
10776 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10777 1.5
10778
10779 From a signed bit-vector term:
10780 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10781 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10782 -1.25*(2**2)
10783 """
10784 ctx = _get_ctx(ctx)
10785 if is_bv(a1) and is_fp_sort(a2):
10787 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10789 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10791 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10793 else:
10794 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10795
10796
◆ 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 10888 of file z3py.py.
10888def fpToFPUnsigned(rm, x, s, ctx=None):
10889 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10890 if z3_debug():
10891 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10892 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10893 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10894 ctx = _get_ctx(ctx)
10896
10897
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 10962 of file z3py.py.
10962def fpToIEEEBV(x, ctx=None):
10963 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10964
10965 The size of the resulting bit-vector is automatically determined.
10966
10967 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10968 knows only one NaN and it will always produce the same bit-vector representation of
10969 that NaN.
10970
10971 >>> x = FP('x', FPSort(8, 24))
10972 >>> y = fpToIEEEBV(x)
10973 >>> print(is_fp(x))
10974 True
10975 >>> print(is_bv(y))
10976 True
10977 >>> print(is_fp(y))
10978 False
10979 >>> print(is_bv(x))
10980 False
10981 """
10982 if z3_debug():
10983 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10984 ctx = _get_ctx(ctx)
10986
10987
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 10942 of file z3py.py.
10942def fpToReal(x, ctx=None):
10943 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10944
10945 >>> x = FP('x', FPSort(8, 24))
10946 >>> y = fpToReal(x)
10947 >>> print(is_fp(x))
10948 True
10949 >>> print(is_real(y))
10950 True
10951 >>> print(is_fp(y))
10952 False
10953 >>> print(is_real(x))
10954 False
10955 """
10956 if z3_debug():
10957 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10958 ctx = _get_ctx(ctx)
10960
10961
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 10898 of file z3py.py.
10898def fpToSBV(rm, x, s, ctx=None):
10899 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10900
10901 >>> x = FP('x', FPSort(8, 24))
10902 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10903 >>> print(is_fp(x))
10904 True
10905 >>> print(is_bv(y))
10906 True
10907 >>> print(is_fp(y))
10908 False
10909 >>> print(is_bv(x))
10910 False
10911 """
10912 if z3_debug():
10913 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10914 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10915 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10916 ctx = _get_ctx(ctx)
10918
10919
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 10920 of file z3py.py.
10920def fpToUBV(rm, x, s, ctx=None):
10921 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10922
10923 >>> x = FP('x', FPSort(8, 24))
10924 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10925 >>> print(is_fp(x))
10926 True
10927 >>> print(is_bv(y))
10928 True
10929 >>> print(is_fp(y))
10930 False
10931 >>> print(is_bv(x))
10932 False
10933 """
10934 if z3_debug():
10935 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10936 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10937 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10938 ctx = _get_ctx(ctx)
10940
10941
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 10870 of file z3py.py.
10870def fpUnsignedToFP(rm, v, sort, ctx=None):
10871 """Create a Z3 floating-point conversion expression that represents the
10872 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10873
10874 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10875 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10876 >>> x_fp
10877 fpToFPUnsigned(RNE(), 4294967291)
10878 >>> simplify(x_fp)
10879 1*(2**32)
10880 """
10881 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10882 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10883 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10884 ctx = _get_ctx(ctx)
10886
10887
◆ 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 10295 of file z3py.py.
10295def FPVal(sig, exp=None, fps=None, ctx=None):
10296 """Return a floating-point value of value `val` and sort `fps`.
10297 If `ctx=None`, then the global context is used.
10298
10299 >>> v = FPVal(20.0, FPSort(8, 24))
10300 >>> v
10301 1.25*(2**4)
10302 >>> print("0x%.8x" % v.exponent_as_long(False))
10303 0x00000004
10304 >>> v = FPVal(2.25, FPSort(8, 24))
10305 >>> v
10306 1.125*(2**1)
10307 >>> v = FPVal(-2.25, FPSort(8, 24))
10308 >>> v
10309 -1.125*(2**1)
10310 >>> FPVal(-0.0, FPSort(8, 24))
10311 -0.0
10312 >>> FPVal(0.0, FPSort(8, 24))
10313 +0.0
10314 >>> FPVal(+0.0, FPSort(8, 24))
10315 +0.0
10316 """
10317 ctx = _get_ctx(ctx)
10318 if is_fp_sort(exp):
10319 fps = exp
10320 exp = None
10321 elif fps is None:
10322 fps = _dflt_fps(ctx)
10323 _z3_assert(is_fp_sort(fps), "sort mismatch")
10324 if exp is None:
10325 exp = 0
10326 val = _to_float_str(sig)
10327 if val == "NaN" or val == "nan":
10328 return fpNaN(fps)
10329 elif val == "-0.0":
10330 return fpMinusZero(fps)
10331 elif val == "0.0" or val == "+0.0":
10332 return fpPlusZero(fps)
10333 elif val == "+oo" or val == "+inf" or val == "+Inf":
10334 return fpPlusInfinity(fps)
10335 elif val == "-oo" or val == "-inf" or val == "-Inf":
10336 return fpMinusInfinity(fps)
10337 else:
10339
10340
◆ fpZero()
| fpZero | ( | s, | |
| negative ) |
Create a Z3 floating-point +0.0 or -0.0 term.
Definition at line 10288 of file z3py.py.
10288def fpZero(s, negative):
10289 """Create a Z3 floating-point +0.0 or -0.0 term."""
10290 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10291 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10293
10294
◆ 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 1848 of file z3py.py.
1848def FreshBool(prefix="b", ctx=None):
1849 """Return a fresh Boolean constant in the given context using the given prefix.
1850
1851 If `ctx=None`, then the global context is used.
1852
1853 >>> b1 = FreshBool()
1854 >>> b2 = FreshBool()
1855 >>> eq(b1, b2)
1856 False
1857 """
1858 ctx = _get_ctx(ctx)
1860
1861
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 1511 of file z3py.py.
1511def FreshConst(sort, prefix="c"):
1512 """Create a fresh constant of a specified sort"""
1513 if z3_debug():
1514 _z3_assert(is_sort(sort), f"Z3 sort expected, got {type(sort)}")
1515 ctx = _get_ctx(sort.ctx)
1517
1518
◆ 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 3376 of file z3py.py.
3376def FreshInt(prefix="x", ctx=None):
3377 """Return a fresh integer constant in the given context using the given prefix.
3378
3379 >>> x = FreshInt()
3380 >>> y = FreshInt()
3381 >>> eq(x, y)
3382 False
3383 >>> x.sort()
3384 Int
3385 """
3386 ctx = _get_ctx(ctx)
3388
3389
◆ 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 3433 of file z3py.py.
3433def FreshReal(prefix="b", ctx=None):
3434 """Return a fresh real constant in the given context using the given prefix.
3435
3436 >>> x = FreshReal()
3437 >>> y = FreshReal()
3438 >>> eq(x, y)
3439 False
3440 >>> x.sort()
3441 Real
3442 """
3443 ctx = _get_ctx(ctx)
3445
3446
◆ 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 11265 of file z3py.py.
11265def Full(s):
11266 """Create the regular expression that accepts the universal language
11267 >>> e = Full(ReSort(SeqSort(IntSort())))
11268 >>> print(e)
11269 Full(ReSort(Seq(Int)))
11270 >>> e1 = Full(ReSort(StringSort()))
11271 >>> print(e1)
11272 Full(ReSort(String))
11273 """
11274 if isinstance(s, ReSortRef):
11276 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11277
11278
11279
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 6845 of file z3py.py.
6845def get_as_array_func(n):
6846 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6847 if z3_debug():
6848 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6850
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 9549 of file z3py.py.
9549def get_default_rounding_mode(ctx=None):
9550 """Retrieves the global default rounding mode."""
9551 global _dflt_rounding_mode
9552 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9553 return RTZ(ctx)
9554 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9555 return RTN(ctx)
9556 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9557 return RTP(ctx)
9558 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9559 return RNE(ctx)
9560 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9561 return RNA(ctx)
9562
9563
◆ 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 4795 of file z3py.py.
4795def get_map_func(a):
4796 """Return the function declaration associated with a Z3 map array expression.
4797
4798 >>> f = Function('f', IntSort(), IntSort())
4799 >>> b = Array('b', IntSort(), IntSort())
4800 >>> a = Map(f, b)
4801 >>> eq(f, get_map_func(a))
4802 True
4803 >>> get_map_func(a)
4804 f
4805 >>> get_map_func(a)(0)
4806 f(0)
4807 """
4808 if z3_debug():
4809 _z3_assert(is_map(a), "Z3 array map expression expected.")
4810 return FuncDeclRef(
4811 Z3_to_func_decl(
4812 a.ctx_ref(),
4813 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4814 ),
4815 ctx=a.ctx,
4816 )
4817
4818
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 1382 of file z3py.py.
1382def get_var_index(a):
1383 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1384
1385 >>> x = Int('x')
1386 >>> y = Int('y')
1387 >>> is_var(x)
1388 False
1389 >>> is_const(x)
1390 True
1391 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1392 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1393 >>> q = ForAll([x, y], f(x, y) == x + y)
1394 >>> q.body()
1395 f(Var(1), Var(0)) == Var(1) + Var(0)
1396 >>> b = q.body()
1397 >>> b.arg(0)
1398 f(Var(1), Var(0))
1399 >>> v1 = b.arg(0).arg(0)
1400 >>> v2 = b.arg(0).arg(1)
1401 >>> v1
1402 Var(1)
1403 >>> v2
1404 Var(0)
1405 >>> get_var_index(v1)
1406 1
1407 >>> get_var_index(v2)
1408 0
1409 """
1410 if z3_debug():
1411 _z3_assert(is_var(a), "Z3 bound variable expected")
1413
1414
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 9055 of file z3py.py.
9055def help_simplify():
9056 """Return a string describing all options available for Z3 `simplify` procedure."""
9057 print(Z3_simplify_get_help(main_ctx().ref()))
9058
9059
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 1428 of file z3py.py.
1428def If(a, b, c, ctx=None):
1429 """Create a Z3 if-then-else expression.
1430
1431 >>> x = Int('x')
1432 >>> y = Int('y')
1433 >>> max = If(x > y, x, y)
1434 >>> max
1435 If(x > y, x, y)
1436 >>> simplify(max)
1437 If(x <= y, y, x)
1438 """
1439 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1440 return Cond(a, b, c, ctx)
1441 else:
1442 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1443 s = BoolSort(ctx)
1444 a = s.cast(a)
1445 b, c = _coerce_exprs(b, c, ctx)
1446 if z3_debug():
1447 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1449
1450
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 1862 of file z3py.py.
1862def Implies(a, b, ctx=None):
1863 """Create a Z3 implies expression.
1864
1865 >>> p, q = Bools('p q')
1866 >>> Implies(p, q)
1867 Implies(p, q)
1868 """
1869 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1870 s = BoolSort(ctx)
1871 a = s.cast(a)
1872 b = s.cast(b)
1874
1875
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 11349 of file z3py.py.
11349def IndexOf(s, substr, offset=None):
11350 """Retrieve the index of substring within a string starting at a specified offset.
11351 >>> simplify(IndexOf("abcabc", "bc", 0))
11352 1
11353 >>> simplify(IndexOf("abcabc", "bc", 2))
11354 4
11355 """
11356 if offset is None:
11357 offset = IntVal(0)
11358 ctx = None
11359 if is_expr(offset):
11360 ctx = offset.ctx
11361 ctx = _get_ctx2(s, substr, ctx)
11362 s = _coerce_seq(s, ctx)
11363 substr = _coerce_seq(substr, ctx)
11364 if _is_int(offset):
11365 offset = IntVal(offset, ctx)
11366 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11367
11368
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 11488 of file z3py.py.
11488def InRe(s, re):
11489 """Create regular expression membership test
11490 >>> re = Union(Re("a"),Re("b"))
11491 >>> print (simplify(InRe("a", re)))
11492 True
11493 >>> print (simplify(InRe("b", re)))
11494 True
11495 >>> print (simplify(InRe("c", re)))
11496 False
11497 """
11498 s = _coerce_seq(s, re.ctx)
11500
11501
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 3337 of file z3py.py.
3337def Int(name, ctx=None):
3338 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3339
3340 >>> x = Int('x')
3341 >>> is_int(x)
3342 True
3343 >>> is_int(x + 1)
3344 True
3345 """
3346 ctx = _get_ctx(ctx)
3348
3349
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 4092 of file z3py.py.
4092def Int2BV(a, num_bits):
4093 """Return the z3 expression Int2BV(a, num_bits).
4094 It is a bit-vector of width num_bits and represents the
4095 modulo of a by 2^num_bits
4096 """
4097 ctx = a.ctx
4099
4100
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 11522 of file z3py.py.
11522def Intersect(*args):
11523 """Create intersection of regular expressions.
11524 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11525 """
11526 args = _get_args(args)
11527 sz = len(args)
11528 if z3_debug():
11529 _z3_assert(sz > 0, "At least one argument expected.")
11530 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11531 if sz == 1:
11532 return args[0]
11533 ctx = args[0].ctx
11534 v = (Ast * sz)()
11535 for i in range(sz):
11536 v[i] = args[i].as_ast()
11538
11539
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 3350 of file z3py.py.
3350def Ints(names, ctx=None):
3351 """Return a tuple of Integer constants.
3352
3353 >>> x, y, z = Ints('x y z')
3354 >>> Sum(x, y, z)
3355 x + y + z
3356 """
3357 ctx = _get_ctx(ctx)
3358 if isinstance(names, str):
3359 names = names.split(" ")
3360 return [Int(name, ctx) for name in names]
3361
3362
◆ 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 3231 of file z3py.py.
3231def IntSort(ctx=None):
3232 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3233
3234 >>> IntSort()
3235 Int
3236 >>> x = Const('x', IntSort())
3237 >>> is_int(x)
3238 True
3239 >>> x.sort() == IntSort()
3240 True
3241 >>> x.sort() == BoolSort()
3242 False
3243 """
3244 ctx = _get_ctx(ctx)
3246
3247
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 3277 of file z3py.py.
3277def IntVal(val, ctx=None):
3278 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3279
3280 >>> IntVal(1)
3281 1
3282 >>> IntVal("100")
3283 100
3284 """
3285 ctx = _get_ctx(ctx)
3287
3288
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 3363 of file z3py.py.
3363def IntVector(prefix, sz, ctx=None):
3364 """Return a list of integer constants of size `sz`.
3365
3366 >>> X = IntVector('x', 3)
3367 >>> X
3368 [x__0, x__1, x__2]
3369 >>> Sum(X)
3370 x__0 + x__1 + x__2
3371 """
3372 ctx = _get_ctx(ctx)
3373 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3374
3375
◆ 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 2879 of file z3py.py.
2879def is_add(a : Any) -> bool:
2880 """Return `True` if `a` is an expression of the form b + c.
2881
2882 >>> x, y = Ints('x y')
2883 >>> is_add(x + y)
2884 True
2885 >>> is_add(x - y)
2886 False
2887 """
2888 return is_app_of(a, Z3_OP_ADD)
2889
2890
◆ 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 2865 of file z3py.py.
2865def is_algebraic_value(a):
2866 """Return `True` if `a` is an algebraic value of sort Real.
2867
2868 >>> is_algebraic_value(RealVal("3/5"))
2869 False
2870 >>> n = simplify(Sqrt(2))
2871 >>> n
2872 1.4142135623?
2873 >>> is_algebraic_value(n)
2874 True
2875 """
2876 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2877
2878
◆ 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 1698 of file z3py.py.
1698def is_and(a : Any) -> bool:
1699 """Return `True` if `a` is a Z3 and expression.
1700
1701 >>> p, q = Bools('p q')
1702 >>> is_and(And(p, q))
1703 True
1704 >>> is_and(Or(p, q))
1705 False
1706 """
1707 return is_app_of(a, Z3_OP_AND)
1708
1709
◆ 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 1312 of file z3py.py.
1312def is_app(a):
1313 """Return `True` if `a` is a Z3 function application.
1314
1315 Note that, constants are function applications with 0 arguments.
1316
1317 >>> a = Int('a')
1318 >>> is_app(a)
1319 True
1320 >>> is_app(a + 1)
1321 True
1322 >>> is_app(IntSort())
1323 False
1324 >>> is_app(1)
1325 False
1326 >>> is_app(IntVal(1))
1327 True
1328 >>> x = Int('x')
1329 >>> is_app(ForAll(x, x >= 0))
1330 False
1331 """
1332 if not isinstance(a, ExprRef):
1333 return False
1334 k = _ast_kind(a.ctx, a)
1335 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1336
1337
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 1415 of file z3py.py.
1415def is_app_of(a, k):
1416 """Return `True` if `a` is an application of the given kind `k`.
1417
1418 >>> x = Int('x')
1419 >>> n = x + 1
1420 >>> is_app_of(n, Z3_OP_ADD)
1421 True
1422 >>> is_app_of(n, Z3_OP_MUL)
1423 False
1424 """
1425 return is_app(a) and a.kind() == k
1426
1427
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 2752 of file z3py.py.
2752def is_arith(a):
2753 """Return `True` if `a` is an arithmetical expression.
2754
2755 >>> x = Int('x')
2756 >>> is_arith(x)
2757 True
2758 >>> is_arith(x + 1)
2759 True
2760 >>> is_arith(1)
2761 False
2762 >>> is_arith(IntVal(1))
2763 True
2764 >>> y = Real('y')
2765 >>> is_arith(y)
2766 True
2767 >>> is_arith(y + 1)
2768 True
2769 """
2770 return isinstance(a, ArithRef)
2771
2772
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 2451 of file z3py.py.
2451def is_arith_sort(s : Any) -> bool:
2452 """Return `True` if s is an arithmetical sort (type).
2453
2454 >>> is_arith_sort(IntSort())
2455 True
2456 >>> is_arith_sort(RealSort())
2457 True
2458 >>> is_arith_sort(BoolSort())
2459 False
2460 >>> n = Int('x') + 1
2461 >>> is_arith_sort(n.sort())
2462 True
2463 """
2464 return isinstance(s, ArithSortRef)
2465
2466
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 4730 of file z3py.py.
4730def is_array(a : Any) -> bool:
4731 """Return `True` if `a` is a Z3 array expression.
4732
4733 >>> a = Array('a', IntSort(), IntSort())
4734 >>> is_array(a)
4735 True
4736 >>> is_array(Store(a, 0, 1))
4737 True
4738 >>> is_array(a[0])
4739 False
4740 """
4741 return isinstance(a, ArrayRef)
4742
4743
◆ 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 6840 of file z3py.py.
6840def is_as_array(n):
6841 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6843
6844
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 1648 of file z3py.py.
1648def is_bool(a : Any) -> bool:
1649 """Return `True` if `a` is a Z3 Boolean expression.
1650
1651 >>> p = Bool('p')
1652 >>> is_bool(p)
1653 True
1654 >>> q = Bool('q')
1655 >>> is_bool(And(p, q))
1656 True
1657 >>> x = Real('x')
1658 >>> is_bool(x)
1659 False
1660 >>> is_bool(x == 0)
1661 True
1662 """
1663 return isinstance(a, BoolRef)
1664
1665
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 4040 of file z3py.py.
4040def is_bv(a):
4041 """Return `True` if `a` is a Z3 bit-vector expression.
4042
4043 >>> b = BitVec('b', 32)
4044 >>> is_bv(b)
4045 True
4046 >>> is_bv(b + 10)
4047 True
4048 >>> is_bv(Int('x'))
4049 False
4050 """
4051 return isinstance(a, BitVecRef)
4052
4053
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 3567 of file z3py.py.
3567def is_bv_sort(s):
3568 """Return True if `s` is a Z3 bit-vector sort.
3569
3570 >>> is_bv_sort(BitVecSort(32))
3571 True
3572 >>> is_bv_sort(IntSort())
3573 False
3574 """
3575 return isinstance(s, BitVecSortRef)
3576
3577
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 4054 of file z3py.py.
4054def is_bv_value(a):
4055 """Return `True` if `a` is a Z3 bit-vector numeral value.
4056
4057 >>> b = BitVec('b', 32)
4058 >>> is_bv_value(b)
4059 False
4060 >>> b = BitVecVal(10, 32)
4061 >>> b
4062 10
4063 >>> is_bv_value(b)
4064 True
4065 """
4066 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4067
4068
◆ 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 1338 of file z3py.py.
1338def is_const(a):
1339 """Return `True` if `a` is Z3 constant/variable expression.
1340
1341 >>> a = Int('a')
1342 >>> is_const(a)
1343 True
1344 >>> is_const(a + 1)
1345 False
1346 >>> is_const(1)
1347 False
1348 >>> is_const(IntVal(1))
1349 True
1350 >>> x = Int('x')
1351 >>> is_const(ForAll(x, x >= 0))
1352 False
1353 """
1354 return is_app(a) and a.num_args() == 0
1355
1356
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 4744 of file z3py.py.
4744def is_const_array(a):
4745 """Return `True` if `a` is a Z3 constant array.
4746
4747 >>> a = K(IntSort(), 10)
4748 >>> is_const_array(a)
4749 True
4750 >>> a = Array('a', IntSort(), IntSort())
4751 >>> is_const_array(a)
4752 False
4753 """
4754 return is_app_of(a, Z3_OP_CONST_ARRAY)
4755
4756
◆ 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 4786 of file z3py.py.
4786def is_default(a):
4787 """Return `True` if `a` is a Z3 default array expression.
4788 >>> d = Default(K(IntSort(), 10))
4789 >>> is_default(d)
4790 True
4791 """
4792 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4793
4794
◆ 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 1756 of file z3py.py.
1756def is_distinct(a : Any) -> bool:
1757 """Return `True` if `a` is a Z3 distinct expression.
1758
1759 >>> x, y, z = Ints('x y z')
1760 >>> is_distinct(x == y)
1761 False
1762 >>> is_distinct(Distinct(x, y, z))
1763 True
1764 """
1765 return is_app_of(a, Z3_OP_DISTINCT)
1766
1767
◆ 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 2915 of file z3py.py.
2915def is_div(a : Any) -> bool:
2916 """Return `True` if `a` is an expression of the form b / c.
2917
2918 >>> x, y = Reals('x y')
2919 >>> is_div(x / y)
2920 True
2921 >>> is_div(x + y)
2922 False
2923 >>> x, y = Ints('x y')
2924 >>> is_div(x / y)
2925 False
2926 >>> is_idiv(x / y)
2927 True
2928 """
2929 return is_app_of(a, Z3_OP_DIV)
2930
2931
◆ 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 1746 of file z3py.py.
1746def is_eq(a : Any) -> bool:
1747 """Return `True` if `a` is a Z3 equality expression.
1748
1749 >>> x, y = Ints('x y')
1750 >>> is_eq(x == y)
1751 True
1752 """
1753 return is_app_of(a, Z3_OP_EQ)
1754
1755
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 1289 of file z3py.py.
1289def is_expr(a):
1290 """Return `True` if `a` is a Z3 expression.
1291
1292 >>> a = Int('a')
1293 >>> is_expr(a)
1294 True
1295 >>> is_expr(a + 1)
1296 True
1297 >>> is_expr(IntSort())
1298 False
1299 >>> is_expr(1)
1300 False
1301 >>> is_expr(IntVal(1))
1302 True
1303 >>> x = Int('x')
1304 >>> is_expr(ForAll(x, x >= 0))
1305 True
1306 >>> is_expr(FPVal(1.0))
1307 True
1308 """
1309 return isinstance(a, ExprRef)
1310
1311
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 1684 of file z3py.py.
1684def is_false(a : Any) -> bool:
1685 """Return `True` if `a` is the Z3 false expression.
1686
1687 >>> p = Bool('p')
1688 >>> is_false(p)
1689 False
1690 >>> is_false(False)
1691 False
1692 >>> is_false(BoolVal(False))
1693 True
1694 """
1695 return is_app_of(a, Z3_OP_FALSE)
1696
1697
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 7933 of file z3py.py.
7933def is_finite_domain(a):
7934 """Return `True` if `a` is a Z3 finite-domain expression.
7935
7936 >>> s = FiniteDomainSort('S', 100)
7937 >>> b = Const('b', s)
7938 >>> is_finite_domain(b)
7939 True
7940 >>> is_finite_domain(Int('x'))
7941 False
7942 """
7943 return isinstance(a, FiniteDomainRef)
7944
7945
◆ 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 7910 of file z3py.py.
7910def is_finite_domain_sort(s):
7911 """Return True if `s` is a Z3 finite-domain sort.
7912
7913 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7914 True
7915 >>> is_finite_domain_sort(IntSort())
7916 False
7917 """
7918 return isinstance(s, FiniteDomainSortRef)
7919
7920
◆ 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 7987 of file z3py.py.
7987def is_finite_domain_value(a):
7988 """Return `True` if `a` is a Z3 finite-domain value.
7989
7990 >>> s = FiniteDomainSort('S', 100)
7991 >>> b = Const('b', s)
7992 >>> is_finite_domain_value(b)
7993 False
7994 >>> b = FiniteDomainVal(10, s)
7995 >>> b
7996 10
7997 >>> is_finite_domain_value(b)
7998 True
7999 """
8000 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
8001
8002
◆ 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 10141 of file z3py.py.
10141def is_fp(a):
10142 """Return `True` if `a` is a Z3 floating-point expression.
10143
10144 >>> b = FP('b', FPSort(8, 24))
10145 >>> is_fp(b)
10146 True
10147 >>> is_fp(b + 1.0)
10148 True
10149 >>> is_fp(Int('x'))
10150 False
10151 """
10152 return isinstance(a, FPRef)
10153
10154
◆ 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 9715 of file z3py.py.
9715def is_fp_sort(s):
9716 """Return True if `s` is a Z3 floating-point sort.
9717
9718 >>> is_fp_sort(FPSort(8, 24))
9719 True
9720 >>> is_fp_sort(IntSort())
9721 False
9722 """
9723 return isinstance(s, FPSortRef)
9724
9725
◆ 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 10155 of file z3py.py.
10155def is_fp_value(a):
10156 """Return `True` if `a` is a Z3 floating-point numeral value.
10157
10158 >>> b = FP('b', FPSort(8, 24))
10159 >>> is_fp_value(b)
10160 False
10161 >>> b = FPVal(1.0, FPSort(8, 24))
10162 >>> b
10163 1
10164 >>> is_fp_value(b)
10165 True
10166 """
10167 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10168
10169
◆ 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 9975 of file z3py.py.
9975def is_fprm(a):
9976 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9977
9978 >>> rm = RNE()
9979 >>> is_fprm(rm)
9980 True
9981 >>> rm = 1.0
9982 >>> is_fprm(rm)
9983 False
9984 """
9985 return isinstance(a, FPRMRef)
9986
9987
◆ 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 9726 of file z3py.py.
9726def is_fprm_sort(s):
9727 """Return True if `s` is a Z3 floating-point rounding mode sort.
9728
9729 >>> is_fprm_sort(FPSort(8, 24))
9730 False
9731 >>> is_fprm_sort(RNE().sort())
9732 True
9733 """
9734 return isinstance(s, FPRMSortRef)
9735
9736# FP Expressions
9737
9738
◆ is_fprm_value()
| is_fprm_value | ( | a | ) |
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.
Definition at line 9988 of file z3py.py.
9988def is_fprm_value(a):
9989 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9990 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9991
9992# FP Numerals
9993
9994
◆ 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 2980 of file z3py.py.
2980def is_ge(a : Any) -> bool:
2981 """Return `True` if `a` is an expression of the form b >= c.
2982
2983 >>> x, y = Ints('x y')
2984 >>> is_ge(x >= y)
2985 True
2986 >>> is_ge(x == y)
2987 False
2988 """
2989 return is_app_of(a, Z3_OP_GE)
2990
2991
◆ 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 2992 of file z3py.py.
2992def is_gt(a : Any) -> bool:
2993 """Return `True` if `a` is an expression of the form b > c.
2994
2995 >>> x, y = Ints('x y')
2996 >>> is_gt(x > y)
2997 True
2998 >>> is_gt(x == y)
2999 False
3000 """
3001 return is_app_of(a, Z3_OP_GT)
3002
3003
◆ 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 2932 of file z3py.py.
2932def is_idiv(a : Any) -> bool:
2933 """Return `True` if `a` is an expression of the form b div c.
2934
2935 >>> x, y = Ints('x y')
2936 >>> is_idiv(x / y)
2937 True
2938 >>> is_idiv(x + y)
2939 False
2940 """
2941 return is_app_of(a, Z3_OP_IDIV)
2942
2943
◆ 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 1722 of file z3py.py.
1722def is_implies(a : Any) -> bool:
1723 """Return `True` if `a` is a Z3 implication expression.
1724
1725 >>> p, q = Bools('p q')
1726 >>> is_implies(Implies(p, q))
1727 True
1728 >>> is_implies(And(p, q))
1729 False
1730 """
1731 return is_app_of(a, Z3_OP_IMPLIES)
1732
1733
◆ 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 2773 of file z3py.py.
2773def is_int(a) -> bool:
2774 """Return `True` if `a` is an integer expression.
2775
2776 >>> x = Int('x')
2777 >>> is_int(x + 1)
2778 True
2779 >>> is_int(1)
2780 False
2781 >>> is_int(IntVal(1))
2782 True
2783 >>> y = Real('y')
2784 >>> is_int(y)
2785 False
2786 >>> is_int(y + 1)
2787 False
2788 """
2789 return is_arith(a) and a.is_int()
2790
2791
◆ 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 2819 of file z3py.py.
2819def is_int_value(a):
2820 """Return `True` if `a` is an integer value of sort Int.
2821
2822 >>> is_int_value(IntVal(1))
2823 True
2824 >>> is_int_value(1)
2825 False
2826 >>> is_int_value(Int('x'))
2827 False
2828 >>> n = Int('x') + 1
2829 >>> n
2830 x + 1
2831 >>> n.arg(1)
2832 1
2833 >>> is_int_value(n.arg(1))
2834 True
2835 >>> is_int_value(RealVal("1/3"))
2836 False
2837 >>> is_int_value(RealVal(1))
2838 False
2839 """
2840 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2841
2842
◆ 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 3004 of file z3py.py.
3004def is_is_int(a : Any) -> bool:
3005 """Return `True` if `a` is an expression of the form IsInt(b).
3006
3007 >>> x = Real('x')
3008 >>> is_is_int(IsInt(x))
3009 True
3010 >>> is_is_int(x)
3011 False
3012 """
3013 return is_app_of(a, Z3_OP_IS_INT)
3014
3015
◆ 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 4757 of file z3py.py.
4757def is_K(a):
4758 """Return `True` if `a` is a Z3 constant array.
4759
4760 >>> a = K(IntSort(), 10)
4761 >>> is_K(a)
4762 True
4763 >>> a = Array('a', IntSort(), IntSort())
4764 >>> is_K(a)
4765 False
4766 """
4767 return is_app_of(a, Z3_OP_CONST_ARRAY)
4768
4769
◆ 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 2956 of file z3py.py.
2956def is_le(a : Any) -> bool:
2957 """Return `True` if `a` is an expression of the form b <= c.
2958
2959 >>> x, y = Ints('x y')
2960 >>> is_le(x <= y)
2961 True
2962 >>> is_le(x < y)
2963 False
2964 """
2965 return is_app_of(a, Z3_OP_LE)
2966
2967
◆ 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 2968 of file z3py.py.
2968def is_lt(a : Any) -> bool:
2969 """Return `True` if `a` is an expression of the form b < c.
2970
2971 >>> x, y = Ints('x y')
2972 >>> is_lt(x < y)
2973 True
2974 >>> is_lt(x == y)
2975 False
2976 """
2977 return is_app_of(a, Z3_OP_LT)
2978
2979
◆ 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 4770 of file z3py.py.
4770def is_map(a):
4771 """Return `True` if `a` is a Z3 map array expression.
4772
4773 >>> f = Function('f', IntSort(), IntSort())
4774 >>> b = Array('b', IntSort(), IntSort())
4775 >>> a = Map(f, b)
4776 >>> a
4777 Map(f, b)
4778 >>> is_map(a)
4779 True
4780 >>> is_map(b)
4781 False
4782 """
4783 return is_app_of(a, Z3_OP_ARRAY_MAP)
4784
4785
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 2944 of file z3py.py.
2944def is_mod(a : Any) -> bool:
2945 """Return `True` if `a` is an expression of the form b % c.
2946
2947 >>> x, y = Ints('x y')
2948 >>> is_mod(x % y)
2949 True
2950 >>> is_mod(x + y)
2951 False
2952 """
2953 return is_app_of(a, Z3_OP_MOD)
2954
2955
◆ 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 2891 of file z3py.py.
2891def is_mul(a : Any) -> bool:
2892 """Return `True` if `a` is an expression of the form b * c.
2893
2894 >>> x, y = Ints('x y')
2895 >>> is_mul(x * y)
2896 True
2897 >>> is_mul(x - y)
2898 False
2899 """
2900 return is_app_of(a, Z3_OP_MUL)
2901
2902
◆ 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 1734 of file z3py.py.
1734def is_not(a : Any) -> bool:
1735 """Return `True` if `a` is a Z3 not expression.
1736
1737 >>> p = Bool('p')
1738 >>> is_not(p)
1739 False
1740 >>> is_not(Not(p))
1741 True
1742 """
1743 return is_app_of(a, Z3_OP_NOT)
1744
1745
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 1710 of file z3py.py.
1710def is_or(a : Any) -> bool:
1711 """Return `True` if `a` is a Z3 or expression.
1712
1713 >>> p, q = Bools('p q')
1714 >>> is_or(Or(p, q))
1715 True
1716 >>> is_or(And(p, q))
1717 False
1718 """
1719 return is_app_of(a, Z3_OP_OR)
1720
1721
◆ 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 2010 of file z3py.py.
2010def is_pattern(a):
2011 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
2012
2013 >>> f = Function('f', IntSort(), IntSort())
2014 >>> x = Int('x')
2015 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2016 >>> q
2017 ForAll(x, f(x) == 0)
2018 >>> q.num_patterns()
2019 1
2020 >>> is_pattern(q.pattern(0))
2021 True
2022 >>> q.pattern(0)
2023 f(Var(0))
2024 """
2025 return isinstance(a, PatternRef)
2026
2027
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 8896 of file z3py.py.
8896def is_probe(p):
8897 """Return `True` if `p` is a Z3 probe.
8898
8899 >>> is_probe(Int('x'))
8900 False
8901 >>> is_probe(Probe('memory'))
8902 True
8903 """
8904 return isinstance(p, Probe)
8905
8906
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 2260 of file z3py.py.
2260def is_quantifier(a):
2261 """Return `True` if `a` is a Z3 quantifier.
2262
2263 >>> f = Function('f', IntSort(), IntSort())
2264 >>> x = Int('x')
2265 >>> q = ForAll(x, f(x) == 0)
2266 >>> is_quantifier(q)
2267 True
2268 >>> is_quantifier(f(x))
2269 False
2270 """
2271 return isinstance(a, QuantifierRef)
2272
2273
◆ 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 2843 of file z3py.py.
2843def is_rational_value(a):
2844 """Return `True` if `a` is rational value of sort Real.
2845
2846 >>> is_rational_value(RealVal(1))
2847 True
2848 >>> is_rational_value(RealVal("3/5"))
2849 True
2850 >>> is_rational_value(IntVal(1))
2851 False
2852 >>> is_rational_value(1)
2853 False
2854 >>> n = Real('x') + 1
2855 >>> n.arg(1)
2856 1
2857 >>> is_rational_value(n.arg(1))
2858 True
2859 >>> is_rational_value(Real('x'))
2860 False
2861 """
2862 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2863
2864
◆ 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 2792 of file z3py.py.
2792def is_real(a):
2793 """Return `True` if `a` is a real expression.
2794
2795 >>> x = Int('x')
2796 >>> is_real(x + 1)
2797 False
2798 >>> y = Real('y')
2799 >>> is_real(y)
2800 True
2801 >>> is_real(y + 1)
2802 True
2803 >>> is_real(1)
2804 False
2805 >>> is_real(RealVal(1))
2806 True
2807 """
2808 return is_arith(a) and a.is_real()
2809
2810
◆ 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 5005 of file z3py.py.
5005def is_select(a):
5006 """Return `True` if `a` is a Z3 array select application.
5007
5008 >>> a = Array('a', IntSort(), IntSort())
5009 >>> is_select(a)
5010 False
5011 >>> i = Int('i')
5012 >>> is_select(a[i])
5013 True
5014 """
5015 return is_app_of(a, Z3_OP_SELECT)
5016
5017
◆ 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 11166 of file z3py.py.
11166def is_seq(a):
11167 """Return `True` if `a` is a Z3 sequence expression.
11168 >>> print (is_seq(Unit(IntVal(0))))
11169 True
11170 >>> print (is_seq(StringVal("abc")))
11171 True
11172 """
11173 return isinstance(a, SeqRef)
11174
11175
◆ 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 5018 of file z3py.py.
5018def is_store(a):
5019 """Return `True` if `a` is a Z3 array store application.
5020
5021 >>> a = Array('a', IntSort(), IntSort())
5022 >>> is_store(a)
5023 False
5024 >>> is_store(Store(a, 0, 1))
5025 True
5026 """
5027 return is_app_of(a, Z3_OP_STORE)
5028
◆ 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 11176 of file z3py.py.
11176def is_string(a: Any) -> bool:
11177 """Return `True` if `a` is a Z3 string expression.
11178 >>> print (is_string(StringVal("ab")))
11179 True
11180 """
11181 return isinstance(a, SeqRef) and a.is_string()
11182
11183
◆ 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 11184 of file z3py.py.
11184def is_string_value(a: Any) -> bool:
11185 """return 'True' if 'a' is a Z3 string constant expression.
11186 >>> print (is_string_value(StringVal("a")))
11187 True
11188 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11189 False
11190 """
11191 return isinstance(a, SeqRef) and a.is_string_value()
11192
◆ 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 2903 of file z3py.py.
2903def is_sub(a : Any) -> bool:
2904 """Return `True` if `a` is an expression of the form b - c.
2905
2906 >>> x, y = Ints('x y')
2907 >>> is_sub(x - y)
2908 True
2909 >>> is_sub(x + y)
2910 False
2911 """
2912 return is_app_of(a, Z3_OP_SUB)
2913
2914
◆ 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 3031 of file z3py.py.
3031def is_to_int(a : Any) -> bool:
3032 """Return `True` if `a` is an expression of the form ToInt(b).
3033
3034 >>> x = Real('x')
3035 >>> n = ToInt(x)
3036 >>> n
3037 ToInt(x)
3038 >>> is_to_int(n)
3039 True
3040 >>> is_to_int(x)
3041 False
3042 """
3043 return is_app_of(a, Z3_OP_TO_INT)
3044
3045
◆ 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 3016 of file z3py.py.
3016def is_to_real(a : Any) -> bool:
3017 """Return `True` if `a` is an expression of the form ToReal(b).
3018
3019 >>> x = Int('x')
3020 >>> n = ToReal(x)
3021 >>> n
3022 ToReal(x)
3023 >>> is_to_real(n)
3024 True
3025 >>> is_to_real(x)
3026 False
3027 """
3028 return is_app_of(a, Z3_OP_TO_REAL)
3029
3030
◆ 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 1666 of file z3py.py.
1666def is_true(a : Any) -> bool:
1667 """Return `True` if `a` is the Z3 true expression.
1668
1669 >>> p = Bool('p')
1670 >>> is_true(p)
1671 False
1672 >>> is_true(simplify(p == p))
1673 True
1674 >>> x = Real('x')
1675 >>> is_true(x == 0)
1676 False
1677 >>> # True is a Python Boolean expression
1678 >>> is_true(True)
1679 False
1680 """
1681 return is_app_of(a, Z3_OP_TRUE)
1682
1683
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 1357 of file z3py.py.
1357def is_var(a):
1358 """Return `True` if `a` is variable.
1359
1360 Z3 uses de-Bruijn indices for representing bound variables in
1361 quantifiers.
1362
1363 >>> x = Int('x')
1364 >>> is_var(x)
1365 False
1366 >>> is_const(x)
1367 True
1368 >>> f = Function('f', IntSort(), IntSort())
1369 >>> # Z3 replaces x with bound variables when ForAll is executed.
1370 >>> q = ForAll(x, f(x) == x)
1371 >>> b = q.body()
1372 >>> b
1373 f(Var(0)) == Var(0)
1374 >>> b.arg(1)
1375 Var(0)
1376 >>> is_var(b.arg(1))
1377 True
1378 """
1379 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1380
1381
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 3485 of file z3py.py.
3485def IsInt(a):
3486 """ Return the Z3 predicate IsInt(a).
3487
3488 >>> x = Real('x')
3489 >>> IsInt(x + "1/2")
3490 IsInt(x + 1/2)
3491 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3492 [x = 1/2]
3493 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3494 no solution
3495 """
3496 if z3_debug():
3497 _z3_assert(a.is_real(), "Z3 real expression expected.")
3498 ctx = a.ctx
3500
3501
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 5128 of file z3py.py.
5128def IsMember(e, s):
5129 """ Check if e is a member of set s
5130 >>> a = Const('a', SetSort(IntSort()))
5131 >>> IsMember(1, a)
5132 a[1]
5133 """
5134 ctx = _ctx_from_ast_arg_list([s, e])
5135 e = _py2expr(e, ctx)
5137
5138
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 5139 of file z3py.py.
5139def IsSubset(a, b):
5140 """ Check if a is a subset of b
5141 >>> a = Const('a', SetSort(IntSort()))
5142 >>> b = Const('b', SetSort(IntSort()))
5143 >>> IsSubset(a, b)
5144 subset(a, b)
5145 """
5146 ctx = _ctx_from_ast_arg_list([a, b])
5148
5149
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 4965 of file z3py.py.
4965def K(dom, v):
4966 """Return a Z3 constant array expression.
4967
4968 >>> a = K(IntSort(), 10)
4969 >>> a
4970 K(Int, 10)
4971 >>> a.sort()
4972 Array(Int, Int)
4973 >>> i = Int('i')
4974 >>> a[i]
4975 K(Int, 10)[i]
4976 >>> simplify(a[i])
4977 10
4978 """
4979 if z3_debug():
4980 _z3_assert(is_sort(dom), "Z3 sort expected")
4981 ctx = dom.ctx
4982 if not is_expr(v):
4983 v = _py2expr(v, ctx)
4985
4986
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 2348 of file z3py.py.
2348def Lambda(vs, body):
2349 """Create a Z3 lambda expression.
2350
2351 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2352 >>> mem0 = Array('mem0', IntSort(), IntSort())
2353 >>> lo, hi, e, i = Ints('lo hi e i')
2354 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2355 >>> mem1
2356 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2357 """
2358 ctx = body.ctx
2359 if is_app(vs):
2360 vs = [vs]
2361 num_vars = len(vs)
2362 _vs = (Ast * num_vars)()
2363 for i in range(num_vars):
2364 # TODO: Check if is constant
2365 _vs[i] = vs[i].as_ast()
2367
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 11369 of file z3py.py.
11369def LastIndexOf(s, substr):
11370 """Retrieve the last index of substring within a string"""
11371 ctx = None
11372 ctx = _get_ctx2(s, substr, ctx)
11373 s = _coerce_seq(s, ctx)
11374 substr = _coerce_seq(substr, ctx)
11376
11377
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 11378 of file z3py.py.
11378def Length(s):
11379 """Obtain the length of a sequence 's'
11380 >>> l = Length(StringVal("abc"))
11381 >>> simplify(l)
11382 3
11383 """
11384 s = _coerce_seq(s)
11386
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 11590 of file z3py.py.
11590def Loop(re, lo, hi=0):
11591 """Create the regular expression accepting between a lower and upper bound repetitions
11592 >>> re = Loop(Re("a"), 1, 3)
11593 >>> print(simplify(InRe("aa", re)))
11594 True
11595 >>> print(simplify(InRe("aaaa", re)))
11596 False
11597 >>> print(simplify(InRe("", 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_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 4418 of file z3py.py.
4418def LShR(a, b):
4419 """Create the Z3 expression logical right shift.
4420
4421 Use the operator >> for the arithmetical right shift.
4422
4423 >>> x, y = BitVecs('x y', 32)
4424 >>> LShR(x, y)
4425 LShR(x, y)
4426 >>> (x >> y).sexpr()
4427 '(bvashr x y)'
4428 >>> LShR(x, y).sexpr()
4429 '(bvlshr x y)'
4430 >>> BitVecVal(4, 3)
4431 4
4432 >>> BitVecVal(4, 3).as_signed_long()
4433 -4
4434 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4435 -2
4436 >>> simplify(BitVecVal(4, 3) >> 1)
4437 6
4438 >>> simplify(LShR(BitVecVal(4, 3), 1))
4439 2
4440 >>> simplify(BitVecVal(2, 3) >> 1)
4441 1
4442 >>> simplify(LShR(BitVecVal(2, 3), 1))
4443 1
4444 """
4445 _check_bv_args(a, b)
4446 a, b = _coerce_exprs(a, b)
4448
4449
◆ 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 4942 of file z3py.py.
4942def Map(f, *args):
4943 """Return a Z3 map array expression.
4944
4945 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4946 >>> a1 = Array('a1', IntSort(), IntSort())
4947 >>> a2 = Array('a2', IntSort(), IntSort())
4948 >>> b = Map(f, a1, a2)
4949 >>> b
4950 Map(f, a1, a2)
4951 >>> prove(b[0] == f(a1[0], a2[0]))
4952 proved
4953 """
4954 args = _get_args(args)
4955 if z3_debug():
4956 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4957 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4958 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4959 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4960 _args, sz = _to_ast_array(args)
4961 ctx = f.ctx
4963
4964
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 6832 of file z3py.py.
6832def Model(ctx=None, eval = {}):
6833 ctx = _get_ctx(ctx)
6834 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
6835 for k, v in eval.items():
6836 mdl.update_value(k, v)
6837 return mdl
6838
6839
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 2028 of file z3py.py.
2028def MultiPattern(*args):
2029 """Create a Z3 multi-pattern using the given expressions `*args`
2030
2031 >>> f = Function('f', IntSort(), IntSort())
2032 >>> g = Function('g', IntSort(), IntSort())
2033 >>> x = Int('x')
2034 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
2035 >>> q
2036 ForAll(x, f(x) != g(x))
2037 >>> q.num_patterns()
2038 1
2039 >>> is_pattern(q.pattern(0))
2040 True
2041 >>> q.pattern(0)
2042 MultiPattern(f(Var(0)), g(Var(0)))
2043 """
2044 if z3_debug():
2045 _z3_assert(len(args) > 0, "At least one argument expected")
2046 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2047 ctx = args[0].ctx
2048 args, sz = _to_ast_array(args)
2050
2051
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 1892 of file z3py.py.
1892def Not(a, ctx=None):
1893 """Create a Z3 not expression or probe.
1894
1895 >>> p = Bool('p')
1896 >>> Not(Not(p))
1897 Not(Not(p))
1898 >>> simplify(Not(Not(p)))
1899 p
1900 """
1901 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1902 if is_probe(a):
1903 # Not is also used to build probes
1905 else:
1906 s = BoolSort(ctx)
1907 a = s.cast(a)
1909
1910
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 11680 of file z3py.py.
11680def on_clause_eh(ctx, p, n, dep, clause):
11681 onc = _my_hacky_class
11682 p = _to_expr_ref(to_Ast(p), onc.ctx)
11683 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11684 deps = [dep[i] for i in range(n)]
11685 onc.on_clause(p, deps, clause)
11686
◆ 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 11555 of file z3py.py.
11555def Option(re):
11556 """Create the regular expression that optionally accepts the argument.
11557 >>> re = Option(Re("a"))
11558 >>> print(simplify(InRe("a", re)))
11559 True
11560 >>> print(simplify(InRe("", re)))
11561 True
11562 >>> print(simplify(InRe("aa", re)))
11563 False
11564 """
11565 if z3_debug():
11566 _z3_assert(is_expr(re), "expression expected")
11568
11569
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 1959 of file z3py.py.
1959def Or(*args):
1960 """Create a Z3 or-expression or or-probe.
1961
1962 >>> p, q, r = Bools('p q r')
1963 >>> Or(p, q, r)
1964 Or(p, q, r)
1965 >>> P = BoolVector('p', 5)
1966 >>> Or(P)
1967 Or(p__0, p__1, p__2, p__3, p__4)
1968 """
1969 last_arg = None
1970 if len(args) > 0:
1971 last_arg = args[len(args) - 1]
1972 if isinstance(last_arg, Context):
1973 ctx = args[len(args) - 1]
1974 args = args[:len(args) - 1]
1975 elif len(args) == 1 and isinstance(args[0], AstVector):
1976 ctx = args[0].ctx
1977 args = [a for a in args[0]]
1978 else:
1979 ctx = None
1980 args = _get_args(args)
1981 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1982 if z3_debug():
1983 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1984 if _has_probe(args):
1985 return _probe_or(args, ctx)
1986 else:
1987 args = _coerce_expr_list(args, ctx)
1988 _args, sz = _to_ast_array(args)
1990
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 8589 of file z3py.py.
8589def OrElse(*ts, **ks):
8590 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8591
8592 >>> x = Int('x')
8593 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8594 >>> # Tactic split-clause fails if there is no clause in the given goal.
8595 >>> t(x == 0)
8596 [[x == 0]]
8597 >>> t(Or(x == 0, x == 1))
8598 [[x == 0], [x == 1]]
8599 """
8600 if z3_debug():
8601 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8602 ctx = ks.get("ctx", None)
8603 num = len(ts)
8604 r = ts[0]
8605 for i in range(num - 1):
8606 r = _or_else(r, ts[i + 1], ctx)
8607 return r
8608
8609
◆ 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 8610 of file z3py.py.
8610def ParOr(*ts, **ks):
8611 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8612
8613 >>> x = Int('x')
8614 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8615 >>> t(x + 1 == 2)
8616 [[x == 1]]
8617 """
8618 if z3_debug():
8619 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8620 ctx = _get_ctx(ks.get("ctx", None))
8621 ts = [_to_tactic(t, ctx) for t in ts]
8622 sz = len(ts)
8623 _args = (TacticObj * sz)()
8624 for i in range(sz):
8625 _args[i] = ts[i].tactic
8627
8628
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 9525 of file z3py.py.
9525def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9526 """Parse a file in SMT 2.0 format using the given sorts and decls.
9527
9528 This function is similar to parse_smt2_string().
9529 """
9530 ctx = _get_ctx(ctx)
9531 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9532 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9533 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9534
9535
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 9504 of file z3py.py.
9504def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9505 """Parse a string in SMT 2.0 format using the given sorts and decls.
9506
9507 The arguments sorts and decls are Python dictionaries used to initialize
9508 the symbol table used for the SMT 2.0 parser.
9509
9510 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9511 [x > 0, x < 10]
9512 >>> x, y = Ints('x y')
9513 >>> f = Function('f', IntSort(), IntSort())
9514 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9515 [x + f(y) > 0]
9516 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9517 [a > 0]
9518 """
9519 ctx = _get_ctx(ctx)
9520 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9521 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9522 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9523
9524
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 8629 of file z3py.py.
8629def ParThen(t1, t2, ctx=None):
8630 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8631 The subgoals are processed in parallel.
8632
8633 >>> x, y = Ints('x y')
8634 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8635 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8636 [[x == 1, y == 2], [x == 2, y == 3]]
8637 """
8638 t1 = _to_tactic(t1, ctx)
8639 t2 = _to_tactic(t2, ctx)
8640 if z3_debug():
8641 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8643
8644
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 9281 of file z3py.py.
9281def PbEq(args, k, ctx=None):
9282 """Create a Pseudo-Boolean equality k constraint.
9283
9284 >>> a, b, c = Bools('a b c')
9285 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9286 """
9287 _z3_check_cint_overflow(k, "k")
9288 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9290
9291
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 9270 of file z3py.py.
9270def PbGe(args, k):
9271 """Create a Pseudo-Boolean inequality k constraint.
9272
9273 >>> a, b, c = Bools('a b c')
9274 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9275 """
9276 _z3_check_cint_overflow(k, "k")
9277 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9279
9280
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 9259 of file z3py.py.
9259def PbLe(args, k):
9260 """Create a Pseudo-Boolean inequality k constraint.
9261
9262 >>> a, b, c = Bools('a b c')
9263 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9264 """
9265 _z3_check_cint_overflow(k, "k")
9266 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9268
9269
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 11540 of file z3py.py.
11540def Plus(re):
11541 """Create the regular expression accepting one or more repetitions of argument.
11542 >>> re = Plus(Re("a"))
11543 >>> print(simplify(InRe("aa", re)))
11544 True
11545 >>> print(simplify(InRe("ab", re)))
11546 False
11547 >>> print(simplify(InRe("", re)))
11548 False
11549 """
11550 if z3_debug():
11551 _z3_assert(is_expr(re), "expression expected")
11553
11554
◆ 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 11285 of file z3py.py.
11285def PrefixOf(a, b):
11286 """Check if 'a' is a prefix of 'b'
11287 >>> s1 = PrefixOf("ab", "abc")
11288 >>> simplify(s1)
11289 True
11290 >>> s2 = PrefixOf("bc", "abc")
11291 >>> simplify(s2)
11292 False
11293 """
11294 ctx = _get_ctx2(a, b)
11295 a = _coerce_seq(a, ctx)
11296 b = _coerce_seq(b, ctx)
11298
11299
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 8925 of file z3py.py.
8925def probe_description(name, ctx=None):
8926 """Return a short description for the probe named `name`.
8927
8928 >>> d = probe_description('memory')
8929 """
8930 ctx = _get_ctx(ctx)
8932
8933
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 8914 of file z3py.py.
8914def probes(ctx=None):
8915 """Return a list of all available probes in Z3.
8916
8917 >>> l = probes()
8918 >>> l.count('memory') == 1
8919 True
8920 """
8921 ctx = _get_ctx(ctx)
8923
8924
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 9166 of file z3py.py.
9166def Product(*args):
9167 """Create the product of the Z3 expressions.
9168
9169 >>> a, b, c = Ints('a b c')
9170 >>> Product(a, b, c)
9171 a*b*c
9172 >>> Product([a, b, c])
9173 a*b*c
9174 >>> A = IntVector('a', 5)
9175 >>> Product(A)
9176 a__0*a__1*a__2*a__3*a__4
9177 """
9178 args = _get_args(args)
9179 if len(args) == 0:
9180 return 1
9181 ctx = _ctx_from_ast_arg_list(args)
9182 if ctx is None:
9183 return _reduce(lambda a, b: a * b, args, 1)
9184 args = _coerce_expr_list(args, ctx)
9185 if is_bv(args[0]):
9186 return _reduce(lambda a, b: a * b, args, 1)
9187 else:
9188 _args, sz = _to_ast_array(args)
9190
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 11845 of file z3py.py.
11845def PropagateFunction(name, *sig):
11846 """Create a function that gets tracked by user propagator.
11847 Every term headed by this function symbol is tracked.
11848 If a term is fixed and the fixed callback is registered a
11849 callback is invoked that the term headed by this function is fixed.
11850 """
11851 sig = _get_args(sig)
11852 if z3_debug():
11853 _z3_assert(len(sig) > 0, "At least two arguments expected")
11854 arity = len(sig) - 1
11855 rng = sig[arity]
11856 if z3_debug():
11857 _z3_assert(is_sort(rng), "Z3 sort expected")
11858 dom = (Sort * arity)()
11859 for i in range(arity):
11860 if z3_debug():
11861 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11862 dom[i] = sig[i].ast
11863 ctx = rng.ctx
11864 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11865
11866
11867
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 9353 of file z3py.py.
9353def prove(claim, show=False, **keywords):
9354 """Try to prove the given claim.
9355
9356 This is a simple function for creating demonstrations. It tries to prove
9357 `claim` by showing the negation is unsatisfiable.
9358
9359 >>> p, q = Bools('p q')
9360 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9361 proved
9362 """
9363 if z3_debug():
9364 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9365 s = Solver()
9366 s.set(**keywords)
9367 s.add(Not(claim))
9368 if show:
9369 print(s)
9370 r = s.check()
9371 if r == unsat:
9372 print("proved")
9373 elif r == unknown:
9374 print("failed to prove")
9375 print(s.model())
9376 else:
9377 print("counterexample")
9378 print(s.model())
9379
9380
◆ 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 3324 of file z3py.py.
3324def Q(a, b, ctx=None):
3325 """Return a Z3 rational a/b.
3326
3327 If `ctx=None`, then the global context is used.
3328
3329 >>> Q(3,5)
3330 3/5
3331 >>> Q(3,5).sort()
3332 Real
3333 """
3334 return simplify(RatVal(a, b, ctx=ctx))
3335
3336
◆ 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 11605 of file z3py.py.
11605def Range(lo, hi, ctx=None):
11606 """Create the range regular expression over two sequences of length 1
11607 >>> range = Range("a","z")
11608 >>> print(simplify(InRe("b", range)))
11609 True
11610 >>> print(simplify(InRe("bb", range)))
11611 False
11612 """
11613 lo = _coerce_seq(lo, ctx)
11614 hi = _coerce_seq(hi, ctx)
11615 if z3_debug():
11616 _z3_assert(is_expr(lo), "expression expected")
11617 _z3_assert(is_expr(hi), "expression expected")
11619
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 3308 of file z3py.py.
3308def RatVal(a, b, ctx=None):
3309 """Return a Z3 rational a/b.
3310
3311 If `ctx=None`, then the global context is used.
3312
3313 >>> RatVal(3,5)
3314 3/5
3315 >>> RatVal(3,5).sort()
3316 Real
3317 """
3318 if z3_debug():
3319 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3320 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3321 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3322
3323
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 11449 of file z3py.py.
11449def Re(s, ctx=None):
11450 """The regular expression that accepts sequence 's'
11451 >>> s1 = Re("ab")
11452 >>> s2 = Re(StringVal("ab"))
11453 >>> s3 = Re(Unit(BoolVal(True)))
11454 """
11455 s = _coerce_seq(s, ctx)
11457
11458
11459# Regular expressions
11460
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 3390 of file z3py.py.
3390def Real(name, ctx=None):
3391 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3392
3393 >>> x = Real('x')
3394 >>> is_real(x)
3395 True
3396 >>> is_real(x + 1)
3397 True
3398 """
3399 ctx = _get_ctx(ctx)
3401
3402
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 3403 of file z3py.py.
3403def Reals(names, ctx=None):
3404 """Return a tuple of real constants.
3405
3406 >>> x, y, z = Reals('x y z')
3407 >>> Sum(x, y, z)
3408 x + y + z
3409 >>> Sum(x, y, z).sort()
3410 Real
3411 """
3412 ctx = _get_ctx(ctx)
3413 if isinstance(names, str):
3414 names = names.split(" ")
3415 return [Real(name, ctx) for name in names]
3416
3417
◆ 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 3248 of file z3py.py.
3248def RealSort(ctx=None):
3249 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3250
3251 >>> RealSort()
3252 Real
3253 >>> x = Const('x', RealSort())
3254 >>> is_real(x)
3255 True
3256 >>> is_int(x)
3257 False
3258 >>> x.sort() == RealSort()
3259 True
3260 """
3261 ctx = _get_ctx(ctx)
3263
3264
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 3289 of file z3py.py.
3289def RealVal(val, ctx=None):
3290 """Return a Z3 real value.
3291
3292 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3293 If `ctx=None`, then the global context is used.
3294
3295 >>> RealVal(1)
3296 1
3297 >>> RealVal(1).sort()
3298 Real
3299 >>> RealVal("3/5")
3300 3/5
3301 >>> RealVal("1.5")
3302 3/2
3303 """
3304 ctx = _get_ctx(ctx)
3306
3307
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 1534 of file z3py.py.
1534def RealVar(idx: int, ctx=None) -> ExprRef:
1535 """
1536 Create a real free variable. Free variables are used to create quantified formulas.
1537 They are also used to create polynomials.
1538
1539 >>> RealVar(0)
1540 Var(0)
1541 """
1542 return Var(idx, RealSort(ctx))
1543
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 1544 of file z3py.py.
1544def RealVarVector(n: int, ctx= None):
1545 """
1546 Create a list of Real free variables.
1547 The variables have ids: 0, 1, ..., n-1
1548
1549 >>> x0, x1, x2, x3 = RealVarVector(4)
1550 >>> x2
1551 Var(2)
1552 """
1553 return [RealVar(i, ctx) for i in range(n)]
1554
◆ 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 3418 of file z3py.py.
3418def RealVector(prefix, sz, ctx=None):
3419 """Return a list of real constants of size `sz`.
3420
3421 >>> X = RealVector('x', 3)
3422 >>> X
3423 [x__0, x__1, x__2]
3424 >>> Sum(X)
3425 x__0 + x__1 + x__2
3426 >>> Sum(X).sort()
3427 Real
3428 """
3429 ctx = _get_ctx(ctx)
3430 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3431
3432
◆ 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 8678 of file z3py.py.
8678def Repeat(t, max=4294967295, ctx=None):
8679 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8680 or the maximum number of iterations `max` is reached.
8681
8682 >>> x, y = Ints('x y')
8683 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8684 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8685 >>> r = t(c)
8686 >>> for subgoal in r: print(subgoal)
8687 [x == 0, y == 0, x > y]
8688 [x == 0, y == 1, x > y]
8689 [x == 1, y == 0, x > y]
8690 [x == 1, y == 1, x > y]
8691 >>> t = Then(t, Tactic('propagate-values'))
8692 >>> t(c)
8693 [[x == 1, y == 0]]
8694 """
8695 t = _to_tactic(t, ctx)
8697
8698
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 4540 of file z3py.py.
4540def RepeatBitVec(n, a):
4541 """Return an expression representing `n` copies of `a`.
4542
4543 >>> x = BitVec('x', 8)
4544 >>> n = RepeatBitVec(4, x)
4545 >>> n
4546 RepeatBitVec(4, x)
4547 >>> n.size()
4548 32
4549 >>> v0 = BitVecVal(10, 4)
4550 >>> print("%.x" % v0.as_long())
4551 a
4552 >>> v = simplify(RepeatBitVec(4, v0))
4553 >>> v.size()
4554 16
4555 >>> print("%.x" % v.as_long())
4556 aaaa
4557 """
4558 if z3_debug():
4559 _z3_assert(_is_int(n), "First argument must be an integer")
4560 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4562
4563
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 11334 of file z3py.py.
11334def Replace(s, src, dst):
11335 """Replace the first occurrence of 'src' by 'dst' in 's'
11336 >>> r = Replace("aaa", "a", "b")
11337 >>> simplify(r)
11338 "baa"
11339 """
11340 ctx = _get_ctx2(dst, s)
11341 if ctx is None and is_expr(src):
11342 ctx = src.ctx
11343 src = _coerce_seq(src, ctx)
11344 dst = _coerce_seq(dst, ctx)
11345 s = _coerce_seq(s, ctx)
11346 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11347
11348
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 11468 of file z3py.py.
11468def ReSort(s):
11469 if is_ast(s):
11471 if s is None or isinstance(s, Context):
11472 ctx = _get_ctx(s)
11474 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11475
11476
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 4450 of file z3py.py.
4450def RotateLeft(a, b):
4451 """Return an expression representing `a` rotated to the left `b` times.
4452
4453 >>> a, b = BitVecs('a b', 16)
4454 >>> RotateLeft(a, b)
4455 RotateLeft(a, b)
4456 >>> simplify(RotateLeft(a, 0))
4457 a
4458 >>> simplify(RotateLeft(a, 16))
4459 a
4460 """
4461 _check_bv_args(a, b)
4462 a, b = _coerce_exprs(a, b)
4464
4465
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 4466 of file z3py.py.
4466def RotateRight(a, b):
4467 """Return an expression representing `a` rotated to the right `b` times.
4468
4469 >>> a, b = BitVecs('a b', 16)
4470 >>> RotateRight(a, b)
4471 RotateRight(a, b)
4472 >>> simplify(RotateRight(a, 0))
4473 a
4474 >>> simplify(RotateRight(a, 16))
4475 a
4476 """
4477 _check_bv_args(a, b)
4478 a, b = _coerce_exprs(a, b)
4480
4481
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 4926 of file z3py.py.
4926def Select(a, *args):
4927 """Return a Z3 select array expression.
4928
4929 >>> a = Array('a', IntSort(), IntSort())
4930 >>> i = Int('i')
4931 >>> Select(a, i)
4932 a[i]
4933 >>> eq(Select(a, i), a[i])
4934 True
4935 """
4936 args = _get_args(args)
4937 if z3_debug():
4938 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4939 return a[args]
4940
4941
◆ SeqFoldLeft()
| SeqFoldLeft | ( | f, | |
| a, | |||
| s ) |
Definition at line 11401 of file z3py.py.
11401def SeqFoldLeft(f, a, s):
11402 ctx = _get_ctx2(f, s)
11403 s = _coerce_seq(s, ctx)
11404 a = _py2expr(a)
11406
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 11407 of file z3py.py.
11407def SeqFoldLeftI(f, i, a, s):
11408 ctx = _get_ctx2(f, s)
11409 s = _coerce_seq(s, ctx)
11410 a = _py2expr(a)
11411 i = _py2expr(i)
11412 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11413
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 11387 of file z3py.py.
11387def SeqMap(f, s):
11388 """Map function 'f' over sequence 's'"""
11389 ctx = _get_ctx2(f, s)
11390 s = _coerce_seq(s, ctx)
11392
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 11393 of file z3py.py.
11393def SeqMapI(f, i, s):
11394 """Map function 'f' over sequence 's' at index 'i'"""
11395 ctx = _get_ctx2(f, s)
11396 s = _coerce_seq(s, ctx)
11397 if not is_expr(i):
11398 i = _py2expr(i)
11400
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 11034 of file z3py.py.
11034def SeqSort(s):
11035 """Create a sequence sort over elements provided in the argument
11036 >>> s = SeqSort(IntSort())
11037 >>> s == Unit(IntVal(1)).sort()
11038 True
11039 """
11041
11042
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 9573 of file z3py.py.
9573def set_default_rounding_mode(rm, ctx=None):
9574 global _dflt_rounding_mode
9575 if is_fprm_value(rm):
9576 _dflt_rounding_mode = rm.kind()
9577 else:
9578 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9579 _dflt_rounding_mode = rm
9580
9581
◆ 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 5085 of file z3py.py.
5085def SetAdd(s, e):
5086 """ Add element e to set s
5087 >>> a = Const('a', SetSort(IntSort()))
5088 >>> SetAdd(a, 1)
5089 Store(a, 1, True)
5090 """
5091 ctx = _ctx_from_ast_arg_list([s, e])
5092 e = _py2expr(e, ctx)
5094
5095
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 5107 of file z3py.py.
5107def SetComplement(s):
5108 """ The complement of set s
5109 >>> a = Const('a', SetSort(IntSort()))
5110 >>> SetComplement(a)
5111 complement(a)
5112 """
5113 ctx = s.ctx
5115
5116
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 5096 of file z3py.py.
5096def SetDel(s, e):
5097 """ Remove element e to set s
5098 >>> a = Const('a', SetSort(IntSort()))
5099 >>> SetDel(a, 1)
5100 Store(a, 1, False)
5101 """
5102 ctx = _ctx_from_ast_arg_list([s, e])
5103 e = _py2expr(e, ctx)
5105
5106
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 5117 of file z3py.py.
5117def SetDifference(a, b):
5118 """ The set difference of a and b
5119 >>> a = Const('a', SetSort(IntSort()))
5120 >>> b = Const('b', SetSort(IntSort()))
5121 >>> SetDifference(a, b)
5122 setminus(a, b)
5123 """
5124 ctx = _ctx_from_ast_arg_list([a, b])
5126
5127
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 5072 of file z3py.py.
5072def SetIntersect(*args):
5073 """ Take the union of sets
5074 >>> a = Const('a', SetSort(IntSort()))
5075 >>> b = Const('b', SetSort(IntSort()))
5076 >>> SetIntersect(a, b)
5077 intersection(a, b)
5078 """
5079 args = _get_args(args)
5080 ctx = _ctx_from_ast_arg_list(args)
5081 _args, sz = _to_ast_array(args)
5083
5084
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 5059 of file z3py.py.
5059def SetUnion(*args):
5060 """ Take the union of sets
5061 >>> a = Const('a', SetSort(IntSort()))
5062 >>> b = Const('b', SetSort(IntSort()))
5063 >>> SetUnion(a, b)
5064 union(a, b)
5065 """
5066 args = _get_args(args)
5067 ctx = _ctx_from_ast_arg_list(args)
5068 _args, sz = _to_ast_array(args)
5070
5071
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 4482 of file z3py.py.
4482def SignExt(n, a):
4483 """Return a bit-vector expression with `n` extra sign-bits.
4484
4485 >>> x = BitVec('x', 16)
4486 >>> n = SignExt(8, x)
4487 >>> n.size()
4488 24
4489 >>> n
4490 SignExt(8, x)
4491 >>> n.sort()
4492 BitVec(24)
4493 >>> v0 = BitVecVal(2, 2)
4494 >>> v0
4495 2
4496 >>> v0.size()
4497 2
4498 >>> v = simplify(SignExt(6, v0))
4499 >>> v
4500 254
4501 >>> v.size()
4502 8
4503 >>> print("%.x" % v.as_long())
4504 fe
4505 """
4506 if z3_debug():
4507 _z3_assert(_is_int(n), "First argument must be an integer")
4508 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4510
4511
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 7605 of file z3py.py.
7605def SimpleSolver(ctx=None, logFile=None):
7606 """Return a simple general purpose solver with limited amount of preprocessing.
7607
7608 >>> s = SimpleSolver()
7609 >>> x = Int('x')
7610 >>> s.add(x > 0)
7611 >>> s.check()
7612 sat
7613 """
7614 ctx = _get_ctx(ctx)
7616
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 9030 of file z3py.py.
9030def simplify(a, *arguments, **keywords):
9031 """Simplify the expression `a` using the given options.
9032
9033 This function has many options. Use `help_simplify` to obtain the complete list.
9034
9035 >>> x = Int('x')
9036 >>> y = Int('y')
9037 >>> simplify(x + 1 + y + x + 1)
9038 2 + 2*x + y
9039 >>> simplify((x + 1)*(y + 1), som=True)
9040 1 + x + y + x*y
9041 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9042 And(Not(x == y), Not(x == 1), Not(y == 1))
9043 >>> simplify(And(x == 0, y == 1), elim_and=True)
9044 Not(Or(Not(x == 0), Not(y == 1)))
9045 """
9046 if z3_debug():
9047 _z3_assert(is_expr(a), "Z3 expression expected")
9048 if len(arguments) > 0 or len(keywords) > 0:
9049 p = args2params(arguments, keywords, a.ctx)
9051 else:
9053
9054
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 9060 of file z3py.py.
9060def simplify_param_descrs():
9061 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9063
9064
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 9292 of file z3py.py.
9292def solve(*args, **keywords):
9293 """Solve the constraints `*args`.
9294
9295 This is a simple function for creating demonstrations. It creates a solver,
9296 configure it using the options in `keywords`, adds the constraints
9297 in `args`, and invokes check.
9298
9299 >>> a = Int('a')
9300 >>> solve(a > 0, a < 2)
9301 [a = 1]
9302 """
9303 show = keywords.pop("show", False)
9304 s = Solver()
9305 s.set(**keywords)
9306 s.add(*args)
9307 if show:
9308 print(s)
9309 r = s.check()
9310 if r == unsat:
9311 print("no solution")
9312 elif r == unknown:
9313 print("failed to solve")
9314 try:
9315 print(s.model())
9316 except Z3Exception:
9317 return
9318 else:
9319 print(s.model())
9320
9321
◆ 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 9322 of file z3py.py.
9322def solve_using(s, *args, **keywords):
9323 """Solve the constraints `*args` using solver `s`.
9324
9325 This is a simple function for creating demonstrations. It is similar to `solve`,
9326 but it uses the given solver `s`.
9327 It configures solver `s` using the options in `keywords`, adds the constraints
9328 in `args`, and invokes check.
9329 """
9330 show = keywords.pop("show", False)
9331 if z3_debug():
9332 _z3_assert(isinstance(s, Solver), "Solver object expected")
9333 s.set(**keywords)
9334 s.add(*args)
9335 if show:
9336 print("Problem:")
9337 print(s)
9338 r = s.check()
9339 if r == unsat:
9340 print("no solution")
9341 elif r == unknown:
9342 print("failed to solve")
9343 try:
9344 print(s.model())
9345 except Z3Exception:
9346 return
9347 else:
9348 if show:
9349 print("Solution:")
9350 print(s.model())
9351
9352
◆ 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 7584 of file z3py.py.
7584def SolverFor(logic, ctx=None, logFile=None):
7585 """Create a solver customized for the given logic.
7586
7587 The parameter `logic` is a string. It should be contains
7588 the name of a SMT-LIB logic.
7589 See http://www.smtlib.org/ for the name of all available logics.
7590
7591 >>> s = SolverFor("QF_LIA")
7592 >>> x = Int('x')
7593 >>> s.add(x > 0)
7594 >>> s.add(x < 2)
7595 >>> s.check()
7596 sat
7597 >>> s.model()
7598 [x = 1]
7599 """
7600 ctx = _get_ctx(ctx)
7601 logic = to_symbol(logic)
7603
7604
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 3502 of file z3py.py.
3502def Sqrt(a, ctx=None):
3503 """ Return a Z3 expression which represents the square root of a.
3504
3505 >>> x = Real('x')
3506 >>> Sqrt(x)
3507 x**(1/2)
3508 """
3509 if not is_expr(a):
3510 ctx = _get_ctx(ctx)
3511 a = RealVal(a, ctx)
3512 return a ** "1/2"
3513
3514
◆ 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 4397 of file z3py.py.
4397def SRem(a, b):
4398 """Create the Z3 expression signed remainder.
4399
4400 Use the operator % for signed modulus, and URem() for unsigned remainder.
4401
4402 >>> x = BitVec('x', 32)
4403 >>> y = BitVec('y', 32)
4404 >>> SRem(x, y)
4405 SRem(x, y)
4406 >>> SRem(x, y).sort()
4407 BitVec(32)
4408 >>> (x % y).sexpr()
4409 '(bvsmod x y)'
4410 >>> SRem(x, y).sexpr()
4411 '(bvsrem x y)'
4412 """
4413 _check_bv_args(a, b)
4414 a, b = _coerce_exprs(a, b)
4416
4417
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 11575 of file z3py.py.
11575def Star(re):
11576 """Create the regular expression accepting zero or more repetitions of argument.
11577 >>> re = Star(Re("a"))
11578 >>> print(simplify(InRe("aa", re)))
11579 True
11580 >>> print(simplify(InRe("ab", re)))
11581 False
11582 >>> print(simplify(InRe("", re)))
11583 True
11584 """
11585 if z3_debug():
11586 _z3_assert(is_expr(re), "expression expected")
11588
11589
◆ 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 4909 of file z3py.py.
4909def Store(a, *args):
4910 """Return a Z3 store array expression.
4911
4912 >>> a = Array('a', IntSort(), IntSort())
4913 >>> i, v = Ints('i v')
4914 >>> s = Store(a, i, v)
4915 >>> s.sort()
4916 Array(Int, Int)
4917 >>> prove(s[i] == v)
4918 proved
4919 >>> j = Int('j')
4920 >>> prove(Implies(i != j, s[j] == a[j]))
4921 proved
4922 """
4923 return Update(a, args)
4924
4925
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 11200 of file z3py.py.
11200def String(name, ctx=None):
11201 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11202
11203 >>> x = String('x')
11204 """
11205 ctx = _get_ctx(ctx)
11207
11208
◆ Strings()
| Strings | ( | names, | |
| ctx = None ) |
Return a tuple of String constants.
Definition at line 11209 of file z3py.py.
11209def Strings(names, ctx=None):
11210 """Return a tuple of String constants. """
11211 ctx = _get_ctx(ctx)
11212 if isinstance(names, str):
11213 names = names.split(" ")
11214 return [String(name, ctx) for name in names]
11215
11216
◆ StringSort()
| StringSort | ( | ctx = None | ) |
◆ StringVal()
| StringVal | ( | s, | |
| ctx = None ) |
create a string expression
Definition at line 11193 of file z3py.py.
11193def StringVal(s, ctx=None):
11194 """create a string expression"""
11195 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11196 ctx = _get_ctx(ctx)
11198
11199
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 11437 of file z3py.py.
11437def StrToCode(s):
11438 """Convert a unit length string to integer code"""
11439 if not is_expr(s):
11440 s = _py2expr(s)
11442
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 11414 of file z3py.py.
11414def StrToInt(s):
11415 """Convert string expression to integer
11416 >>> a = StrToInt("1")
11417 >>> simplify(1 == a)
11418 True
11419 >>> b = StrToInt("2")
11420 >>> simplify(1 == b)
11421 False
11422 >>> c = StrToInt(IntToStr(2))
11423 >>> simplify(1 == c)
11424 False
11425 """
11426 s = _coerce_seq(s)
11428
11429
◆ 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 11231 of file z3py.py.
11231def SubSeq(s, offset, length):
11232 """Extract substring or subsequence starting at offset.
11233
11234 This is a convenience function that redirects to Extract(s, offset, length).
11235
11236 >>> s = StringVal("hello world")
11237 >>> SubSeq(s, 0, 5) # Extract "hello"
11238 str.substr("hello world", 0, 5)
11239 >>> simplify(SubSeq(StringVal("testing"), 2, 4))
11240 "stin"
11241 """
11242 return Extract(s, offset, length)
11243
11244
◆ 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 9065 of file z3py.py.
9065def substitute(t, *m):
9066 """Apply substitution m on t, m is a list of pairs of the form (from, to).
9067 Every occurrence in t of from is replaced with to.
9068
9069 >>> x = Int('x')
9070 >>> y = Int('y')
9071 >>> substitute(x + 1, (x, y + 1))
9072 y + 1 + 1
9073 >>> f = Function('f', IntSort(), IntSort())
9074 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
9075 1 + 1
9076 """
9077 if isinstance(m, tuple):
9078 m1 = _get_args(m)
9079 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9080 m = m1
9081 if z3_debug():
9082 _z3_assert(is_expr(t), "Z3 expression expected")
9083 _z3_assert(
9084 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
9085 "Z3 invalid substitution, expression pairs expected.")
9086 _z3_assert(
9087 all([p[0].sort().eq(p[1].sort()) for p in m]),
9088 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
9089 num = len(m)
9090 _from = (Ast * num)()
9091 _to = (Ast * num)()
9092 for i in range(num):
9093 _from[i] = m[i][0].as_ast()
9094 _to[i] = m[i][1].as_ast()
9096
9097
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 9118 of file z3py.py.
9118def substitute_funs(t, *m):
9119 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
9120 Every occurrence in to of the function from is replaced with the expression to.
9121 The expression to can have free variables, that refer to the arguments of from.
9122 For examples, see
9123 """
9124 if isinstance(m, tuple):
9125 m1 = _get_args(m)
9126 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9127 m = m1
9128 if z3_debug():
9129 _z3_assert(is_expr(t), "Z3 expression expected")
9130 _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.")
9131 num = len(m)
9132 _from = (FuncDecl * num)()
9133 _to = (Ast * num)()
9134 for i in range(num):
9135 _from[i] = m[i][0].as_func_decl()
9136 _to[i] = m[i][1].as_ast()
9138
9139
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 9098 of file z3py.py.
9098def substitute_vars(t, *m):
9099 """Substitute the free variables in t with the expression in m.
9100
9101 >>> v0 = Var(0, IntSort())
9102 >>> v1 = Var(1, IntSort())
9103 >>> x = Int('x')
9104 >>> f = Function('f', IntSort(), IntSort(), IntSort())
9105 >>> # replace v0 with x+1 and v1 with x
9106 >>> substitute_vars(f(v0, v1), x + 1, x)
9107 f(x + 1, x)
9108 """
9109 if z3_debug():
9110 _z3_assert(is_expr(t), "Z3 expression expected")
9111 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
9112 num = len(m)
9113 _to = (Ast * num)()
9114 for i in range(num):
9115 _to[i] = m[i].as_ast()
9117
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 11217 of file z3py.py.
11217def SubString(s, offset, length):
11218 """Extract substring or subsequence starting at offset.
11219
11220 This is a convenience function that redirects to Extract(s, offset, length).
11221
11222 >>> s = StringVal("hello world")
11223 >>> SubString(s, 6, 5) # Extract "world"
11224 str.substr("hello world", 6, 5)
11225 >>> simplify(SubString(StringVal("hello"), 1, 3))
11226 "ell"
11227 """
11228 return Extract(s, offset, length)
11229
11230
◆ 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 11300 of file z3py.py.
11300def SuffixOf(a, b):
11301 """Check if 'a' is a suffix of 'b'
11302 >>> s1 = SuffixOf("ab", "abc")
11303 >>> simplify(s1)
11304 False
11305 >>> s2 = SuffixOf("bc", "abc")
11306 >>> simplify(s2)
11307 True
11308 """
11309 ctx = _get_ctx2(a, b)
11310 a = _coerce_seq(a, ctx)
11311 b = _coerce_seq(b, ctx)
11313
11314
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 9140 of file z3py.py.
9140def Sum(*args):
9141 """Create the sum of the Z3 expressions.
9142
9143 >>> a, b, c = Ints('a b c')
9144 >>> Sum(a, b, c)
9145 a + b + c
9146 >>> Sum([a, b, c])
9147 a + b + c
9148 >>> A = IntVector('a', 5)
9149 >>> Sum(A)
9150 a__0 + a__1 + a__2 + a__3 + a__4
9151 """
9152 args = _get_args(args)
9153 if len(args) == 0:
9154 return 0
9155 ctx = _ctx_from_ast_arg_list(args)
9156 if ctx is None:
9157 return _reduce(lambda a, b: a + b, args, 0)
9158 args = _coerce_expr_list(args, ctx)
9159 if is_bv(args[0]):
9160 return _reduce(lambda a, b: a + b, args, 0)
9161 else:
9162 _args, sz = _to_ast_array(args)
9164
9165
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 8719 of file z3py.py.
8719def tactic_description(name, ctx=None):
8720 """Return a short description for the tactic named `name`.
8721
8722 >>> d = tactic_description('simplify')
8723 """
8724 ctx = _get_ctx(ctx)
8726
8727
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 8708 of file z3py.py.
8708def tactics(ctx=None):
8709 """Return a list of all available tactics in Z3.
8710
8711 >>> l = tactics()
8712 >>> l.count('simplify') == 1
8713 True
8714 """
8715 ctx = _get_ctx(ctx)
8717
8718
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 8576 of file z3py.py.
8576def Then(*ts, **ks):
8577 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8578
8579 >>> x, y = Ints('x y')
8580 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8581 >>> t(And(x == 0, y > x + 1))
8582 [[Not(y <= 1)]]
8583 >>> t(And(x == 0, y > x + 1)).as_expr()
8584 Not(y <= 1)
8585 """
8586 return AndThen(*ts, **ks)
8587
8588
◆ to_Ast()
| to_Ast | ( | ptr | ) |
◆ to_AstVectorObj()
| to_AstVectorObj | ( | ptr | ) |
Definition at line 11669 of file z3py.py.
11669def to_AstVectorObj(ptr,):
11670 v = AstVectorObj(ptr)
11671 super(ctypes.c_void_p, v).__init__(ptr)
11672 return v
11673
11674# NB. my-hacky-class only works for a single instance of OnClause
11675# it should be replaced with a proper correlation between OnClause
11676# and object references that can be passed over the FFI.
11677# for UserPropagator we use a global dictionary, which isn't great code.
11678
◆ 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 3467 of file z3py.py.
3467def ToInt(a):
3468 """ Return the Z3 expression ToInt(a).
3469
3470 >>> x = Real('x')
3471 >>> x.sort()
3472 Real
3473 >>> n = ToInt(x)
3474 >>> n
3475 ToInt(x)
3476 >>> n.sort()
3477 Int
3478 """
3479 if z3_debug():
3480 _z3_assert(a.is_real(), "Z3 real expression expected.")
3481 ctx = a.ctx
3483
3484
◆ 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 3447 of file z3py.py.
3447def ToReal(a):
3448 """ Return the Z3 expression ToReal(a).
3449
3450 >>> x = Int('x')
3451 >>> x.sort()
3452 Int
3453 >>> n = ToReal(x)
3454 >>> n
3455 ToReal(x)
3456 >>> n.sort()
3457 Real
3458 """
3459 ctx = a.ctx
3460 if isinstance(a, BoolRef):
3461 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3462 if z3_debug():
3463 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3465
3466
◆ 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 11652 of file z3py.py.
11652def TransitiveClosure(f):
11653 """Given a binary relation R, such that the two arguments have the same sort
11654 create the transitive closure relation R+.
11655 The transitive closure R+ is a new relation.
11656 """
11658
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 8699 of file z3py.py.
8699def TryFor(t, ms, ctx=None):
8700 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8701
8702 If `t` does not terminate in `ms` milliseconds, then it fails.
8703 """
8704 t = _to_tactic(t, ctx)
8706
8707
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 5482 of file z3py.py.
5482def TupleSort(name, sorts, ctx=None):
5483 """Create a named tuple sort base on a set of underlying sorts
5484 Example:
5485 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5486 """
5487 tuple = Datatype(name, ctx)
5488 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5489 tuple.declare(name, *projects)
5490 tuple = tuple.create()
5491 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5492
5493
◆ 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 4355 of file z3py.py.
4355def UDiv(a, b):
4356 """Create the Z3 expression (unsigned) division `self / other`.
4357
4358 Use the operator / for signed division.
4359
4360 >>> x = BitVec('x', 32)
4361 >>> y = BitVec('y', 32)
4362 >>> UDiv(x, y)
4363 UDiv(x, y)
4364 >>> UDiv(x, y).sort()
4365 BitVec(32)
4366 >>> (x / y).sexpr()
4367 '(bvsdiv x y)'
4368 >>> UDiv(x, y).sexpr()
4369 '(bvudiv x y)'
4370 """
4371 _check_bv_args(a, b)
4372 a, b = _coerce_exprs(a, b)
4374
4375
◆ 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 4319 of file z3py.py.
4319def UGE(a, b):
4320 """Create the Z3 expression (unsigned) `other >= self`.
4321
4322 Use the operator >= for signed greater than or equal to.
4323
4324 >>> x, y = BitVecs('x y', 32)
4325 >>> UGE(x, y)
4326 UGE(x, y)
4327 >>> (x >= y).sexpr()
4328 '(bvsge x y)'
4329 >>> UGE(x, y).sexpr()
4330 '(bvuge x y)'
4331 """
4332 _check_bv_args(a, b)
4333 a, b = _coerce_exprs(a, b)
4335
4336
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 4337 of file z3py.py.
4337def UGT(a, b):
4338 """Create the Z3 expression (unsigned) `other > self`.
4339
4340 Use the operator > for signed greater than.
4341
4342 >>> x, y = BitVecs('x y', 32)
4343 >>> UGT(x, y)
4344 UGT(x, y)
4345 >>> (x > y).sexpr()
4346 '(bvsgt x y)'
4347 >>> UGT(x, y).sexpr()
4348 '(bvugt x y)'
4349 """
4350 _check_bv_args(a, b)
4351 a, b = _coerce_exprs(a, b)
4353
4354
◆ 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 4283 of file z3py.py.
4283def ULE(a, b):
4284 """Create the Z3 expression (unsigned) `other <= self`.
4285
4286 Use the operator <= for signed less than or equal to.
4287
4288 >>> x, y = BitVecs('x y', 32)
4289 >>> ULE(x, y)
4290 ULE(x, y)
4291 >>> (x <= y).sexpr()
4292 '(bvsle x y)'
4293 >>> ULE(x, y).sexpr()
4294 '(bvule x y)'
4295 """
4296 _check_bv_args(a, b)
4297 a, b = _coerce_exprs(a, b)
4299
4300
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 4301 of file z3py.py.
4301def ULT(a, b):
4302 """Create the Z3 expression (unsigned) `other < self`.
4303
4304 Use the operator < for signed less than.
4305
4306 >>> x, y = BitVecs('x y', 32)
4307 >>> ULT(x, y)
4308 ULT(x, y)
4309 >>> (x < y).sexpr()
4310 '(bvslt x y)'
4311 >>> ULT(x, y).sexpr()
4312 '(bvult x y)'
4313 """
4314 _check_bv_args(a, b)
4315 a, b = _coerce_exprs(a, b)
4317
4318
◆ 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 11502 of file z3py.py.
11502def Union(*args):
11503 """Create union of regular expressions.
11504 >>> re = Union(Re("a"), Re("b"), Re("c"))
11505 >>> print (simplify(InRe("d", re)))
11506 False
11507 """
11508 args = _get_args(args)
11509 sz = len(args)
11510 if z3_debug():
11511 _z3_assert(sz > 0, "At least one argument expected.")
11512 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11513 if sz == 1:
11514 return args[0]
11515 ctx = args[0].ctx
11516 v = (Ast * sz)()
11517 for i in range(sz):
11518 v[i] = args[i].as_ast()
11520
11521
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 4866 of file z3py.py.
4866def Update(a, *args):
4867 """Return a Z3 store array expression.
4868
4869 >>> a = Array('a', IntSort(), IntSort())
4870 >>> i, v = Ints('i v')
4871 >>> s = Update(a, i, v)
4872 >>> s.sort()
4873 Array(Int, Int)
4874 >>> prove(s[i] == v)
4875 proved
4876 >>> j = Int('j')
4877 >>> prove(Implies(i != j, s[j] == a[j]))
4878 proved
4879 """
4880 if z3_debug():
4881 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4882 args = _get_args(args)
4883 ctx = a.ctx
4884 if len(args) <= 1:
4885 raise Z3Exception("array update requires index and value arguments")
4886 if len(args) == 2:
4887 i = args[0]
4888 v = args[1]
4889 i = a.sort().domain().cast(i)
4890 v = a.sort().range().cast(v)
4892 v = a.sort().range().cast(args[-1])
4893 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4894 _args, sz = _to_ast_array(idxs)
4896
4897
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 4376 of file z3py.py.
4376def URem(a, b):
4377 """Create the Z3 expression (unsigned) remainder `self % other`.
4378
4379 Use the operator % for signed modulus, and SRem() for signed remainder.
4380
4381 >>> x = BitVec('x', 32)
4382 >>> y = BitVec('y', 32)
4383 >>> URem(x, y)
4384 URem(x, y)
4385 >>> URem(x, y).sort()
4386 BitVec(32)
4387 >>> (x % y).sexpr()
4388 '(bvsmod x y)'
4389 >>> URem(x, y).sexpr()
4390 '(bvurem x y)'
4391 """
4392 _check_bv_args(a, b)
4393 a, b = _coerce_exprs(a, b)
4395
4396
◆ user_prop_binding()
| user_prop_binding | ( | ctx, | |
| cb, | |||
| q_ref, | |||
| inst_ref ) |
Definition at line 11822 of file z3py.py.
11822def user_prop_binding(ctx, cb, q_ref, inst_ref):
11823 prop = _prop_closures.get(ctx)
11824 old_cb = prop.cb
11825 prop.cb = cb
11826 q = _to_expr_ref(to_Ast(q_ref), prop.ctx())
11827 inst = _to_expr_ref(to_Ast(inst_ref), prop.ctx())
11828 r = prop.binding(q, inst)
11829 prop.cb = old_cb
11830 return r
11831
11832
◆ 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 11805 of file z3py.py.
11805def user_prop_diseq(ctx, cb, x, y):
11806 prop = _prop_closures.get(ctx)
11807 old_cb = prop.cb
11808 prop.cb = cb
11809 x = _to_expr_ref(to_Ast(x), prop.ctx())
11810 y = _to_expr_ref(to_Ast(y), prop.ctx())
11811 prop.diseq(x, y)
11812 prop.cb = old_cb
11813
◆ 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 11771 of file z3py.py.
11771def user_prop_fixed(ctx, cb, id, value):
11772 prop = _prop_closures.get(ctx)
11773 old_cb = prop.cb
11774 prop.cb = cb
11775 id = _to_expr_ref(to_Ast(id), prop.ctx())
11776 value = _to_expr_ref(to_Ast(value), prop.ctx())
11777 prop.fixed(id, value)
11778 prop.cb = old_cb
11779
◆ user_prop_fresh()
| user_prop_fresh | ( | ctx, | |
| _new_ctx ) |
Definition at line 11757 of file z3py.py.
11757def user_prop_fresh(ctx, _new_ctx):
11758 _prop_closures.set_threaded()
11759 prop = _prop_closures.get(ctx)
11760 nctx = Context()
11761 Z3_del_context(nctx.ctx)
11762 new_ctx = to_ContextObj(_new_ctx)
11763 nctx.ctx = new_ctx
11764 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11765 nctx.owner = False
11766 new_prop = prop.fresh(nctx)
11767 _prop_closures.set(new_prop.id, new_prop)
11768 return new_prop.id
11769
11770
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 1519 of file z3py.py.
1519def Var(idx : int, s : SortRef) -> ExprRef:
1520 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1521 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1522 declarations.
1523
1524 >>> Var(0, IntSort())
1525 Var(0)
1526 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1527 False
1528 """
1529 if z3_debug():
1530 _z3_assert(is_sort(s), "Z3 sort expected")
1532
1533
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 8993 of file z3py.py.
8993def When(p, t, ctx=None):
8994 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8995 Otherwise, it returns the input goal unmodified.
8996
8997 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8998 >>> x, y = Ints('x y')
8999 >>> g = Goal()
9000 >>> g.add(x > 0)
9001 >>> g.add(y > 0)
9002 >>> t(g)
9003 [[x > 0, y > 0]]
9004 >>> g.add(x == y + 1)
9005 >>> t(g)
9006 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9007 """
9008 p = _to_probe(p, ctx)
9009 t = _to_tactic(t, ctx)
9011
9012
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 8650 of file z3py.py.
8650def With(t, *args, **keys):
8651 """Return a tactic that applies tactic `t` using the given configuration options.
8652
8653 >>> x, y = Ints('x y')
8654 >>> t = With(Tactic('simplify'), som=True)
8655 >>> t((x + 1)*(y + 2) == 0)
8656 [[2*x + y + x*y == -2]]
8657 """
8658 ctx = keys.pop("ctx", None)
8659 t = _to_tactic(t, ctx)
8660 p = args2params(args, keys, t.ctx)
8662
8663
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 8664 of file z3py.py.
8664def WithParams(t, p):
8665 """Return a tactic that applies tactic `t` using the given configuration options.
8666
8667 >>> x, y = Ints('x y')
8668 >>> p = ParamsRef()
8669 >>> p.set("som", True)
8670 >>> t = WithParams(Tactic('simplify'), p)
8671 >>> t((x + 1)*(y + 2) == 0)
8672 [[2*x + y + x*y == -2]]
8673 """
8674 t = _to_tactic(t, None)
8676
8677
◆ 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 1876 of file z3py.py.
1876def Xor(a, b, ctx=None):
1877 """Create a Z3 Xor expression.
1878
1879 >>> p, q = Bools('p q')
1880 >>> Xor(p, q)
1881 Xor(p, q)
1882 >>> simplify(Xor(p, q))
1883 Not(p == q)
1884 """
1885 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1886 s = BoolSort(ctx)
1887 a = s.cast(a)
1888 b = s.cast(b)
1890
1891
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 4512 of file z3py.py.
4512def ZeroExt(n, a):
4513 """Return a bit-vector expression with `n` extra zero-bits.
4514
4515 >>> x = BitVec('x', 16)
4516 >>> n = ZeroExt(8, x)
4517 >>> n.size()
4518 24
4519 >>> n
4520 ZeroExt(8, x)
4521 >>> n.sort()
4522 BitVec(24)
4523 >>> v0 = BitVecVal(2, 2)
4524 >>> v0
4525 2
4526 >>> v0.size()
4527 2
4528 >>> v = simplify(ZeroExt(6, v0))
4529 >>> v
4530 2
4531 >>> v.size()
4532 8
4533 """
4534 if z3_debug():
4535 _z3_assert(_is_int(n), "First argument must be an integer")
4536 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4538
4539
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 by
1.14.0