z3py Namespace Reference
Functions | |
| z3_debug () | |
| _is_int (v) | |
| enable_trace (msg) | |
| disable_trace (msg) | |
| get_version_string () | |
| get_version () | |
| get_full_version () | |
| _z3_assert (cond, msg) | |
| _z3_check_cint_overflow (n, name) | |
| open_log (fname) | |
| append_log (s) | |
| to_symbol (s, ctx=None) | |
| _symbol2py (ctx, s) | |
| _get_args (args) | |
| _get_args_ast_list (args) | |
| _to_param_value (val) | |
| z3_error_handler (c, e) | |
| Context | main_ctx () |
| Context | _get_ctx (ctx) |
| Context | get_ctx (ctx) |
| set_param (*args, **kws) | |
| None | reset_params () |
| set_option (*args, **kws) | |
| get_param (name) | |
| bool | is_ast (Any a) |
| bool | eq (AstRef a, AstRef b) |
| int | _ast_kind (Context ctx, Any a) |
| _ctx_from_ast_arg_list (args, default_ctx=None) | |
| _ctx_from_ast_args (*args) | |
| _to_func_decl_array (args) | |
| _to_ast_array (args) | |
| _to_ref_array (ref, args) | |
| _to_ast_ref (a, ctx) | |
| _sort_kind (ctx, s) | |
| Sorts. | |
| bool | is_sort (Any s) |
| _to_sort_ref (s, ctx) | |
| SortRef | _sort (Context ctx, Any a) |
| SortRef | DeclareSort (name, ctx=None) |
| DeclareTypeVar (name, ctx=None) | |
| is_func_decl (a) | |
| Function (name, *sig) | |
| FreshFunction (*sig) | |
| _to_func_decl_ref (a, ctx) | |
| RecFunction (name, *sig) | |
| RecAddDefinition (f, args, body) | |
| deserialize (st) | |
| _to_expr_ref (a, ctx) | |
| _coerce_expr_merge (s, a) | |
| _check_same_sort (a, b, ctx=None) | |
| _coerce_exprs (a, b, ctx=None) | |
| _reduce (func, sequence, initial) | |
| _coerce_expr_list (alist, ctx=None) | |
| is_expr (a) | |
| is_app (a) | |
| is_const (a) | |
| is_var (a) | |
| get_var_index (a) | |
| is_app_of (a, k) | |
| If (a, b, c, ctx=None) | |
| Distinct (*args) | |
| _mk_bin (f, a, b) | |
| Const (name, sort) | |
| Consts (names, sort) | |
| FreshConst (sort, prefix="c") | |
| ExprRef | Var (int idx, SortRef s) |
| ExprRef | RealVar (int idx, ctx=None) |
| RealVarVector (int n, ctx=None) | |
| bool | is_bool (Any a) |
| bool | is_true (Any a) |
| bool | is_false (Any a) |
| bool | is_and (Any a) |
| bool | is_or (Any a) |
| bool | is_implies (Any a) |
| bool | is_not (Any a) |
| bool | is_eq (Any a) |
| bool | is_distinct (Any a) |
| BoolSort (ctx=None) | |
| BoolVal (val, ctx=None) | |
| Bool (name, ctx=None) | |
| Bools (names, ctx=None) | |
| BoolVector (prefix, sz, ctx=None) | |
| FreshBool (prefix="b", ctx=None) | |
| Implies (a, b, ctx=None) | |
| Xor (a, b, ctx=None) | |
| Not (a, ctx=None) | |
| mk_not (a) | |
| _has_probe (args) | |
| And (*args) | |
| Or (*args) | |
| is_pattern (a) | |
| MultiPattern (*args) | |
| _to_pattern (arg) | |
| is_quantifier (a) | |
| _mk_quantifier (is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| ForAll (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| Exists (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]) | |
| Lambda (vs, body) | |
| bool | is_arith_sort (Any s) |
| is_arith (a) | |
| bool | is_int (a) |
| is_real (a) | |
| _is_numeral (ctx, a) | |
| _is_algebraic (ctx, a) | |
| is_int_value (a) | |
| is_rational_value (a) | |
| is_algebraic_value (a) | |
| bool | is_add (Any a) |
| bool | is_mul (Any a) |
| bool | is_sub (Any a) |
| bool | is_div (Any a) |
| bool | is_idiv (Any a) |
| bool | is_mod (Any a) |
| bool | is_le (Any a) |
| bool | is_lt (Any a) |
| bool | is_ge (Any a) |
| bool | is_gt (Any a) |
| bool | is_is_int (Any a) |
| bool | is_to_real (Any a) |
| bool | is_to_int (Any a) |
| _py2expr (a, ctx=None) | |
| IntSort (ctx=None) | |
| RealSort (ctx=None) | |
| _to_int_str (val) | |
| IntVal (val, ctx=None) | |
| RealVal (val, ctx=None) | |
| RatVal (a, b, ctx=None) | |
| Q (a, b, ctx=None) | |
| Int (name, ctx=None) | |
| Ints (names, ctx=None) | |
| IntVector (prefix, sz, ctx=None) | |
| FreshInt (prefix="x", ctx=None) | |
| Real (name, ctx=None) | |
| Reals (names, ctx=None) | |
| RealVector (prefix, sz, ctx=None) | |
| FreshReal (prefix="b", ctx=None) | |
| ToReal (a) | |
| ToInt (a) | |
| IsInt (a) | |
| Sqrt (a, ctx=None) | |
| Cbrt (a, ctx=None) | |
| is_bv_sort (s) | |
| is_bv (a) | |
| is_bv_value (a) | |
| BV2Int (a, is_signed=False) | |
| Int2BV (a, num_bits) | |
| BitVecSort (sz, ctx=None) | |
| BitVecVal (val, bv, ctx=None) | |
| BitVec (name, bv, ctx=None) | |
| BitVecs (names, bv, ctx=None) | |
| Concat (*args) | |
| Extract (high, low, a) | |
| _check_bv_args (a, b) | |
| ULE (a, b) | |
| ULT (a, b) | |
| UGE (a, b) | |
| UGT (a, b) | |
| UDiv (a, b) | |
| URem (a, b) | |
| SRem (a, b) | |
| LShR (a, b) | |
| RotateLeft (a, b) | |
| RotateRight (a, b) | |
| SignExt (n, a) | |
| ZeroExt (n, a) | |
| RepeatBitVec (n, a) | |
| BVRedAnd (a) | |
| BVRedOr (a) | |
| BvNand (a, b) | |
| BvNor (a, b) | |
| BvXnor (a, b) | |
| 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) | |
| AsArray (f) | |
| 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) | |
| is_finite_set (a) | |
| is_finite_set_sort (s) | |
| FiniteSetSort (elem_sort) | |
| FiniteSetEmpty (set_sort) | |
| Singleton (elem) | |
| FiniteSetUnion (s1, s2) | |
| FiniteSetIntersect (s1, s2) | |
| FiniteSetDifference (s1, s2) | |
| FiniteSetMember (elem, set) | |
| In (elem, set) | |
| FiniteSetSize (set) | |
| FiniteSetSubset (s1, s2) | |
| FiniteSetMap (f, set) | |
| FiniteSetFilter (f, set) | |
| FiniteSetRange (low, high) | |
| _valid_accessor (acc) | |
| Datatypes. | |
| CreateDatatypes (*ds) | |
| CreatePolymorphicDatatype (d, type_params) | |
| DatatypeSort (name, params=None, ctx=None) | |
| TupleSort (name, sorts, ctx=None) | |
| DisjointSum (name, sorts, ctx=None) | |
| EnumSort (name, values, ctx=None) | |
| args2params (arguments, keywords, ctx=None) | |
| Model (ctx=None, eval={}) | |
| is_as_array (n) | |
| get_as_array_func (n) | |
| SolverFor (logic, ctx=None, logFile=None) | |
| SimpleSolver (ctx=None, logFile=None) | |
| FiniteDomainSort (name, sz, ctx=None) | |
| is_finite_domain_sort (s) | |
| is_finite_domain (a) | |
| FiniteDomainVal (val, sort, ctx=None) | |
| is_finite_domain_value (a) | |
| _global_on_model (ctx) | |
| num_simplifiers (ctx=None) | |
| simplifier_name (i, ctx=None) | |
| simplifier_description (name, ctx=None) | |
| _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 9098 of file z3py.py.
9098def _and_then(t1, t2, ctx=None):
9099 t1 = _to_tactic(t1, ctx)
9100 t2 = _to_tactic(t2, ctx)
9101 if z3_debug():
9102 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9104
9105
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 4833 of file z3py.py.
4833def _array_select(ar, arg):
4834 if isinstance(arg, tuple):
4835 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4836 _args, sz = _to_ast_array(args)
4838 arg = ar.sort().domain().cast(arg)
4840
4841
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 522 of file z3py.py.
522def _ast_kind(ctx : Context, a : Any) -> int:
523 if is_ast(a):
524 a = a.as_ast()
526
527
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 4355 of file z3py.py.
4355def _check_bv_args(a, b):
4356 if z3_debug():
4357 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4358
4359
Referenced by BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BvNand(), BvNor(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), BvXnor(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().
◆ _check_fp_args()
|
protected |
◆ _check_same_sort()
|
protected |
Definition at line 1295 of file z3py.py.
1295def _check_same_sort(a, b, ctx=None):
1296 if not isinstance(a, ExprRef):
1297 return False
1298 if not isinstance(b, ExprRef):
1299 return False
1300 if ctx is None:
1301 ctx = a.ctx
1302
1303 a_sort = Z3_get_sort(ctx.ctx, a.ast)
1304 b_sort = Z3_get_sort(ctx.ctx, b.ast)
1306
1307
Referenced by _coerce_exprs().
◆ _coerce_char()
|
protected |
◆ _coerce_expr_list()
|
protected |
Definition at line 1339 of file z3py.py.
1339def _coerce_expr_list(alist, ctx=None):
1340 has_expr = False
1341 for a in alist:
1342 if is_expr(a):
1343 has_expr = True
1344 break
1345 if not has_expr:
1346 alist = [_py2expr(a, ctx) for a in alist]
1347 s = _reduce(_coerce_expr_merge, alist, None)
1348 return [s.cast(a) for a in alist]
1349
1350
Referenced by And(), Distinct(), and Or().
◆ _coerce_expr_merge()
|
protected |
Definition at line 1277 of file z3py.py.
1277def _coerce_expr_merge(s, a):
1278 if is_expr(a):
1279 s1 = a.sort()
1280 if s is None:
1281 return s1
1282 if s1.eq(s):
1283 return s
1284 elif s.subsort(s1):
1285 return s1
1286 elif s1.subsort(s):
1287 return s
1288 else:
1289 if z3_debug():
1290 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1291 _z3_assert(False, "sort mismatch")
1292 else:
1293 return s
1294
Referenced by _coerce_exprs().
◆ _coerce_exprs()
|
protected |
Definition at line 1308 of file z3py.py.
1308def _coerce_exprs(a, b, ctx=None):
1309 if not is_expr(a) and not is_expr(b):
1310 a = _py2expr(a, ctx)
1311 b = _py2expr(b, ctx)
1312 if isinstance(a, str) and isinstance(b, SeqRef):
1313 a = StringVal(a, b.ctx)
1314 if isinstance(b, str) and isinstance(a, SeqRef):
1315 b = StringVal(b, a.ctx)
1316 if isinstance(a, float) and isinstance(b, ArithRef):
1317 a = RealVal(a, b.ctx)
1318 if isinstance(b, float) and isinstance(a, ArithRef):
1319 b = RealVal(b, a.ctx)
1320
1321 if _check_same_sort(a, b, ctx):
1322 return (a, b)
1323
1324 s = None
1325 s = _coerce_expr_merge(s, a)
1326 s = _coerce_expr_merge(s, b)
1327 a = s.cast(a)
1328 b = s.cast(b)
1329 return (a, b)
1330
1331
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(), BvNand(), BvNor(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), BvXnor(), Extract(), If(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().
◆ _coerce_fp_expr_list()
|
protected |
Definition at line 10159 of file z3py.py.
10159def _coerce_fp_expr_list(alist, ctx):
10160 first_fp_sort = None
10161 for a in alist:
10162 if is_fp(a):
10163 if first_fp_sort is None:
10164 first_fp_sort = a.sort()
10165 elif first_fp_sort == a.sort():
10166 pass # OK, same as before
10167 else:
10168 # we saw at least 2 different float sorts; something will
10169 # throw a sort mismatch later, for now assume None.
10170 first_fp_sort = None
10171 break
10172
10173 r = []
10174 for i in range(len(alist)):
10175 a = alist[i]
10176 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
10177 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
10178 r.append(FPVal(a, None, first_fp_sort, ctx))
10179 else:
10180 r.append(a)
10181 return _coerce_expr_list(r, ctx)
10182
10183
10184# FP Sorts
10185
◆ _coerce_seq()
|
protected |
Definition at line 11703 of file z3py.py.
11703def _coerce_seq(s, ctx=None):
11704 if isinstance(s, str):
11705 ctx = _get_ctx(ctx)
11706 s = StringVal(s, ctx)
11707 if not is_expr(s):
11708 raise Z3Exception("Non-expression passed as a sequence")
11709 if not is_seq(s):
11710 raise Z3Exception("Non-sequence passed as a sequence")
11711 return s
11712
11713
Referenced by Concat().
◆ _ctx_from_ast_arg_list()
|
protected |
Definition at line 528 of file z3py.py.
528def _ctx_from_ast_arg_list(args, default_ctx=None):
529 ctx = None
530 for a in args:
531 if is_ast(a) or is_probe(a):
532 if ctx is None:
533 ctx = a.ctx
534 else:
535 if z3_debug():
536 _z3_assert(ctx == a.ctx, "Context mismatch")
537 if ctx is None:
538 ctx = default_ctx
539 return ctx
540
541
Referenced by _ctx_from_ast_args(), And(), Distinct(), FiniteSetDifference(), FiniteSetFilter(), FiniteSetIntersect(), FiniteSetMap(), FiniteSetMember(), FiniteSetRange(), FiniteSetSubset(), FiniteSetUnion(), 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 10024 of file z3py.py.
10024def _dict2darray(decls, ctx):
10025 sz = len(decls)
10026 _names = (Symbol * sz)()
10027 _decls = (FuncDecl * sz)()
10028 i = 0
10029 for k in decls:
10030 v = decls[k]
10031 if z3_debug():
10032 _z3_assert(isinstance(k, str), "String expected")
10033 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
10034 _names[i] = to_symbol(k, ctx)
10035 if is_const(v):
10036 _decls[i] = v.decl().ast
10037 else:
10038 _decls[i] = v.ast
10039 i = i + 1
10040 return sz, _names, _decls
10041
◆ _dict2sarray()
|
protected |
Definition at line 10008 of file z3py.py.
10008def _dict2sarray(sorts, ctx):
10009 sz = len(sorts)
10010 _names = (Symbol * sz)()
10011 _sorts = (Sort * sz)()
10012 i = 0
10013 for k in sorts:
10014 v = sorts[k]
10015 if z3_debug():
10016 _z3_assert(isinstance(k, str), "String expected")
10017 _z3_assert(is_sort(v), "Z3 sort expected")
10018 _names[i] = to_symbol(k, ctx)
10019 _sorts[i] = v.ast
10020 i = i + 1
10021 return sz, _names, _sorts
10022
10023
◆ _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 287 of file z3py.py.
287def _get_ctx(ctx) -> Context:
288 if ctx is None:
289 return main_ctx()
290 else:
291 return ctx
292
293
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 1980 of file z3py.py.
1980def _has_probe(args):
1981 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1982 for arg in args:
1983 if is_probe(arg):
1984 return True
1985 return False
1986
1987
◆ _is_algebraic()
|
protected |
Definition at line 2888 of file z3py.py.
2888def _is_algebraic(ctx, a):
2890
2891
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 2884 of file z3py.py.
2884def _is_numeral(ctx, a):
2886
2887
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 1537 of file z3py.py.
1537def _mk_bin(f, a, b):
1538 args = (Ast * 2)()
1539 if z3_debug():
1540 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1541 args[0] = a.as_ast()
1542 args[1] = b.as_ast()
1543 return f(a.ctx.ref(), 2, args)
1544
1545
Referenced by ArithRef.__add__(), ArithRef.__mul__(), ArithRef.__radd__(), ArithRef.__rmul__(), ArithRef.__rsub__(), and ArithRef.__sub__().
◆ _mk_fp_bin()
|
protected |
Definition at line 10998 of file z3py.py.
10998def _mk_fp_bin(f, rm, a, b, ctx):
10999 ctx = _get_ctx(ctx)
11000 [a, b] = _coerce_fp_expr_list([a, b], ctx)
11001 if z3_debug():
11002 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11003 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
11004 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
11005
11006
◆ _mk_fp_bin_norm()
|
protected |
Definition at line 11007 of file z3py.py.
11007def _mk_fp_bin_norm(f, a, b, ctx):
11008 ctx = _get_ctx(ctx)
11009 [a, b] = _coerce_fp_expr_list([a, b], ctx)
11010 if z3_debug():
11011 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
11012 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
11013
11014
◆ _mk_fp_bin_pred()
|
protected |
Definition at line 11015 of file z3py.py.
11015def _mk_fp_bin_pred(f, a, b, ctx):
11016 ctx = _get_ctx(ctx)
11017 [a, b] = _coerce_fp_expr_list([a, b], ctx)
11018 if z3_debug():
11019 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
11020 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
11021
11022
◆ _mk_fp_tern()
|
protected |
Definition at line 11023 of file z3py.py.
11023def _mk_fp_tern(f, rm, a, b, c, ctx):
11024 ctx = _get_ctx(ctx)
11025 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
11026 if z3_debug():
11027 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11028 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
11029 c), "Second, third or fourth argument must be a Z3 floating-point expression")
11030 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
11031
11032
◆ _mk_fp_unary()
|
protected |
Definition at line 10981 of file z3py.py.
10981def _mk_fp_unary(f, rm, a, ctx):
10982 ctx = _get_ctx(ctx)
10983 [a] = _coerce_fp_expr_list([a], ctx)
10984 if z3_debug():
10985 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10986 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10987 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10988
10989
◆ _mk_fp_unary_pred()
|
protected |
Definition at line 10990 of file z3py.py.
10990def _mk_fp_unary_pred(f, a, ctx):
10991 ctx = _get_ctx(ctx)
10992 [a] = _coerce_fp_expr_list([a], ctx)
10993 if z3_debug():
10994 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10995 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10996
10997
◆ _mk_quantifier()
|
protected |
Definition at line 2336 of file z3py.py.
2336def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2337 if z3_debug():
2338 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2339 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2340 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2341 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2342 if is_app(vs):
2343 ctx = vs.ctx
2344 vs = [vs]
2345 else:
2346 ctx = vs[0].ctx
2347 if not is_expr(body):
2348 body = BoolVal(body, ctx)
2349 num_vars = len(vs)
2350 if num_vars == 0:
2351 return body
2352 _vs = (Ast * num_vars)()
2353 for i in range(num_vars):
2354 # TODO: Check if is constant
2355 _vs[i] = vs[i].as_ast()
2356 patterns = [_to_pattern(p) for p in patterns]
2357 num_pats = len(patterns)
2358 _pats = (Pattern * num_pats)()
2359 for i in range(num_pats):
2360 _pats[i] = patterns[i].ast
2361 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2362 qid = to_symbol(qid, ctx)
2363 skid = to_symbol(skid, ctx)
2365 num_vars, _vs,
2366 num_pats, _pats,
2367 num_no_pats, _no_pats,
2368 body.as_ast()), ctx)
2369
2370
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 9106 of file z3py.py.
9106def _or_else(t1, t2, ctx=None):
9107 t1 = _to_tactic(t1, ctx)
9108 t2 = _to_tactic(t2, ctx)
9109 if z3_debug():
9110 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9112
9113
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 9797 of file z3py.py.
9797def _pb_args_coeffs(args, default_ctx=None):
9798 args = _get_args_ast_list(args)
9799 if len(args) == 0:
9800 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9801 args = [_reorder_pb_arg(arg) for arg in args]
9802 args, coeffs = zip(*args)
9803 if z3_debug():
9804 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9805 ctx = _ctx_from_ast_arg_list(args)
9806 if z3_debug():
9807 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9808 args = _coerce_expr_list(args, ctx)
9809 _args, sz = _to_ast_array(args)
9810 _coeffs = (ctypes.c_int * len(coeffs))()
9811 for i in range(len(coeffs)):
9812 _z3_check_cint_overflow(coeffs[i], "coefficient")
9813 _coeffs[i] = coeffs[i]
9814 return ctx, sz, _args, _coeffs, args
9815
9816
◆ _probe_and()
|
protected |
◆ _probe_nary()
|
protected |
Definition at line 9511 of file z3py.py.
9511def _probe_nary(f, args, ctx):
9512 if z3_debug():
9513 _z3_assert(len(args) > 0, "At least one argument expected")
9514 num = len(args)
9515 r = _to_probe(args[0], ctx)
9516 for i in range(num - 1):
9517 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
9518 return r
9519
9520
◆ _probe_or()
|
protected |
◆ _prove_html()
|
protected |
Version of function `prove` that renders HTML.
Definition at line 9988 of file z3py.py.
9988def _prove_html(claim, show=False, **keywords):
9989 """Version of function `prove` that renders HTML."""
9990 if z3_debug():
9991 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9992 s = Solver()
9993 s.set(**keywords)
9994 s.add(Not(claim))
9995 if show:
9996 print(s)
9997 r = s.check()
9998 if r == unsat:
9999 print("<b>proved</b>")
10000 elif r == unknown:
10001 print("<b>failed to prove</b>")
10002 print(s.model())
10003 else:
10004 print("<b>counterexample</b>")
10005 print(s.model())
10006
10007
◆ _py2expr()
|
protected |
Definition at line 3289 of file z3py.py.
3289def _py2expr(a, ctx=None):
3290 if isinstance(a, bool):
3291 return BoolVal(a, ctx)
3292 if _is_int(a):
3293 return IntVal(a, ctx)
3294 if isinstance(a, float):
3295 return RealVal(a, ctx)
3296 if isinstance(a, str):
3297 return StringVal(a, ctx)
3298 if is_expr(a):
3299 return a
3300 if z3_debug():
3301 _z3_assert(False, "Python bool, int, long or float expected")
3302
3303
Referenced by _coerce_expr_list(), _coerce_exprs(), FiniteSetSortRef.cast(), IsMember(), K(), SetAdd(), SetDel(), and ModelRef.update_value().
◆ _reduce()
|
protected |
Definition at line 1332 of file z3py.py.
1332def _reduce(func, sequence, initial):
1333 result = initial
1334 for element in sequence:
1335 result = func(result, element)
1336 return result
1337
1338
Referenced by _coerce_expr_list().
◆ _reorder_pb_arg()
|
protected |
◆ _solve_html()
|
protected |
Version of function `solve` that renders HTML output.
Definition at line 9939 of file z3py.py.
9939def _solve_html(*args, **keywords):
9940 """Version of function `solve` that renders HTML output."""
9941 show = keywords.pop("show", False)
9942 s = Solver()
9943 s.set(**keywords)
9944 s.add(*args)
9945 if show:
9946 print("<b>Problem:</b>")
9947 print(s)
9948 r = s.check()
9949 if r == unsat:
9950 print("<b>no solution</b>")
9951 elif r == unknown:
9952 print("<b>failed to solve</b>")
9953 try:
9954 print(s.model())
9955 except Z3Exception:
9956 return
9957 else:
9958 if show:
9959 print("<b>Solution:</b>")
9960 print(s.model())
9961
9962
◆ _solve_using_html()
|
protected |
Version of function `solve_using` that renders HTML.
Definition at line 9963 of file z3py.py.
9963def _solve_using_html(s, *args, **keywords):
9964 """Version of function `solve_using` that renders HTML."""
9965 show = keywords.pop("show", False)
9966 if z3_debug():
9967 _z3_assert(isinstance(s, Solver), "Solver object expected")
9968 s.set(**keywords)
9969 s.add(*args)
9970 if show:
9971 print("<b>Problem:</b>")
9972 print(s)
9973 r = s.check()
9974 if r == unsat:
9975 print("<b>no solution</b>")
9976 elif r == unknown:
9977 print("<b>failed to solve</b>")
9978 try:
9979 print(s.model())
9980 except Z3Exception:
9981 return
9982 else:
9983 if show:
9984 print("<b>Solution:</b>")
9985 print(s.model())
9986
9987
◆ _sort()
◆ _sort_kind()
|
protected |
Sorts.
Definition at line 586 of file z3py.py.
586def _sort_kind(ctx, s):
588
589
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(), FuncDeclRef.params(), QuantifierRef.qid(), QuantifierRef.skolem_id(), and QuantifierRef.var_name().
◆ _to_ast_array()
|
protected |
Definition at line 554 of file z3py.py.
554def _to_ast_array(args):
555 sz = len(args)
556 _args = (Ast * sz)()
557 for i in range(sz):
558 _args[i] = args[i].as_ast()
559 return _args, sz
560
561
Referenced by ExprRef.__ne__(), _array_select(), _mk_quantifier(), And(), Distinct(), Map(), MultiPattern(), Or(), SetIntersect(), SetUnion(), and Update().
◆ _to_ast_ref()
|
protected |
Definition at line 570 of file z3py.py.
570def _to_ast_ref(a, ctx):
571 k = _ast_kind(ctx, a)
572 if k == Z3_SORT_AST:
573 return _to_sort_ref(a, ctx)
574 elif k == Z3_FUNC_DECL_AST:
575 return _to_func_decl_ref(a, ctx)
576 else:
577 return _to_expr_ref(a, ctx)
578
579
Referenced by AstRef.__deepcopy__(), AstMap.__getitem__(), AstVector.__getitem__(), and AstRef.translate().
◆ _to_expr_ref()
|
protected |
Definition at line 1223 of file z3py.py.
1223def _to_expr_ref(a, ctx):
1224 if isinstance(a, Pattern):
1225 return PatternRef(a, ctx)
1226 ctx_ref = ctx.ref()
1227 k = Z3_get_ast_kind(ctx_ref, a)
1228 if k == Z3_QUANTIFIER_AST:
1229 return QuantifierRef(a, ctx)
1230 # Check for finite set sort before checking sort kind
1231 s = Z3_get_sort(ctx_ref, a)
1233 return FiniteSetRef(a, ctx)
1234 sk = Z3_get_sort_kind(ctx_ref, s)
1235 if sk == Z3_BOOL_SORT:
1236 return BoolRef(a, ctx)
1237 if sk == Z3_INT_SORT:
1238 if k == Z3_NUMERAL_AST:
1239 return IntNumRef(a, ctx)
1240 return ArithRef(a, ctx)
1241 if sk == Z3_REAL_SORT:
1242 if k == Z3_NUMERAL_AST:
1243 return RatNumRef(a, ctx)
1244 if _is_algebraic(ctx, a):
1245 return AlgebraicNumRef(a, ctx)
1246 return ArithRef(a, ctx)
1247 if sk == Z3_BV_SORT:
1248 if k == Z3_NUMERAL_AST:
1249 return BitVecNumRef(a, ctx)
1250 else:
1251 return BitVecRef(a, ctx)
1252 if sk == Z3_ARRAY_SORT:
1253 return ArrayRef(a, ctx)
1254 if sk == Z3_DATATYPE_SORT:
1255 return DatatypeRef(a, ctx)
1256 if sk == Z3_FLOATING_POINT_SORT:
1257 if k == Z3_APP_AST and _is_numeral(ctx, a):
1258 return FPNumRef(a, ctx)
1259 else:
1260 return FPRef(a, ctx)
1261 if sk == Z3_FINITE_DOMAIN_SORT:
1262 if k == Z3_NUMERAL_AST:
1263 return FiniteDomainNumRef(a, ctx)
1264 else:
1265 return FiniteDomainRef(a, ctx)
1266 if sk == Z3_ROUNDING_MODE_SORT:
1267 return FPRMRef(a, ctx)
1268 if sk == Z3_SEQ_SORT:
1269 return SeqRef(a, ctx)
1270 if sk == Z3_CHAR_SORT:
1271 return CharRef(a, ctx)
1272 if sk == Z3_RE_SORT:
1273 return ReRef(a, ctx)
1274 return ExprRef(a, ctx)
1275
1276
bool Z3_API Z3_is_finite_set_sort(Z3_context c, Z3_sort s)
Check if a sort is a finite set sort.
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(), Update(), ExprRef.update(), DatatypeRef.update_field(), FuncEntry.value(), and Var().
◆ _to_float_str()
|
protected |
Definition at line 10743 of file z3py.py.
10743def _to_float_str(val, exp=0):
10744 if isinstance(val, float):
10745 if math.isnan(val):
10746 res = "NaN"
10747 elif val == 0.0:
10748 sone = math.copysign(1.0, val)
10749 if sone < 0.0:
10750 return "-0.0"
10751 else:
10752 return "+0.0"
10753 elif val == float("+inf"):
10754 res = "+oo"
10755 elif val == float("-inf"):
10756 res = "-oo"
10757 else:
10758 v = val.as_integer_ratio()
10759 num = v[0]
10760 den = v[1]
10761 rvs = str(num) + "/" + str(den)
10762 res = rvs + "p" + _to_int_str(exp)
10763 elif isinstance(val, bool):
10764 if val:
10765 res = "1.0"
10766 else:
10767 res = "0.0"
10768 elif _is_int(val):
10769 res = str(val)
10770 elif isinstance(val, str):
10771 inx = val.find("*(2**")
10772 if inx == -1:
10773 res = val
10774 elif val[-1] == ")":
10775 res = val[0:inx]
10776 exp = str(int(val[inx + 5:-1]) + int(exp))
10777 else:
10778 _z3_assert(False, "String does not have floating-point numeral form.")
10779 elif z3_debug():
10780 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10781 if exp == 0:
10782 return res
10783 else:
10784 return res + "p" + exp
10785
10786
◆ _to_func_decl_array()
|
protected |
◆ _to_func_decl_ref()
|
protected |
Definition at line 964 of file z3py.py.
964def _to_func_decl_ref(a, ctx):
965 return FuncDeclRef(a, ctx)
966
967
Referenced by _to_ast_ref().
◆ _to_goal()
|
protected |
◆ _to_int_str()
|
protected |
Definition at line 3338 of file z3py.py.
3338def _to_int_str(val):
3339 if isinstance(val, float):
3340 return str(int(val))
3341 elif isinstance(val, bool):
3342 if val:
3343 return "1"
3344 else:
3345 return "0"
3346 else:
3347 return str(val)
3348
3349
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 2114 of file z3py.py.
2114def _to_pattern(arg):
2115 if is_pattern(arg):
2116 return arg
2117 else:
2118 return MultiPattern(arg)
2119
Referenced by _mk_quantifier().
◆ _to_probe()
|
protected |
◆ _to_ref_array()
|
protected |
◆ _to_sort_ref()
|
protected |
Definition at line 695 of file z3py.py.
695def _to_sort_ref(s, ctx):
696 if z3_debug():
697 _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
699 return FiniteSetSortRef(s, ctx)
700 k = _sort_kind(ctx, s)
701 if k == Z3_BOOL_SORT:
702 return BoolSortRef(s, ctx)
703 elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
704 return ArithSortRef(s, ctx)
705 elif k == Z3_BV_SORT:
706 return BitVecSortRef(s, ctx)
707 elif k == Z3_ARRAY_SORT:
708 return ArraySortRef(s, ctx)
709 elif k == Z3_DATATYPE_SORT:
710 return DatatypeSortRef(s, ctx)
711 elif k == Z3_FINITE_DOMAIN_SORT:
712 return FiniteDomainSortRef(s, ctx)
713 elif k == Z3_FLOATING_POINT_SORT:
714 return FPSortRef(s, ctx)
715 elif k == Z3_ROUNDING_MODE_SORT:
716 return FPRMSortRef(s, ctx)
717 elif k == Z3_RE_SORT:
718 return ReSortRef(s, ctx)
719 elif k == Z3_SEQ_SORT:
720 return SeqSortRef(s, ctx)
721 elif k == Z3_CHAR_SORT:
722 return CharSortRef(s, ctx)
723 elif k == Z3_TYPE_VAR:
724 return TypeVarRef(s, ctx)
725 return SortRef(s, ctx)
726
727
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 5519 of file z3py.py.
5519def _valid_accessor(acc):
5520 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5521 if not isinstance(acc, tuple):
5522 return False
5523 if len(acc) != 2:
5524 return False
5525 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5526
5527
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(), AsArray(), Solver.assert_and_track(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), FiniteSetSortRef.cast(), SortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), CreatePolymorphicDatatype(), 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(), ExprRef.update(), DatatypeRef.update_field(), ParamsRef.validate(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().
◆ _z3_check_cint_overflow()
|
protected |
◆ Abs()
| Abs | ( | arg | ) |
Create the absolute value of an arithmetic expression
Definition at line 9749 of file z3py.py.
9749def Abs(arg):
9750 """Create the absolute value of an arithmetic expression"""
9751 return If(arg > 0, arg, -arg)
9752
9753
Referenced by ArithRef.__abs__().
◆ AllChar()
| AllChar | ( | regex_sort, | |
| ctx = None ) |
Create a regular expression that accepts all single character strings
Definition at line 12202 of file z3py.py.
12202def AllChar(regex_sort, ctx=None):
12203 """Create a regular expression that accepts all single character strings
12204 """
12206
12207# Special Relations
12208
12209
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 1988 of file z3py.py.
1988def And(*args):
1989 """Create a Z3 and-expression or and-probe.
1990
1991 >>> p, q, r = Bools('p q r')
1992 >>> And(p, q, r)
1993 And(p, q, r)
1994 >>> P = BoolVector('p', 5)
1995 >>> And(P)
1996 And(p__0, p__1, p__2, p__3, p__4)
1997 """
1998 last_arg = None
1999 if len(args) > 0:
2000 last_arg = args[len(args) - 1]
2001 if isinstance(last_arg, Context):
2002 ctx = args[len(args) - 1]
2003 args = args[:len(args) - 1]
2004 elif len(args) == 1 and isinstance(args[0], AstVector):
2005 ctx = args[0].ctx
2006 args = [a for a in args[0]]
2007 else:
2008 ctx = None
2009 args = _get_args(args)
2010 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
2011 if z3_debug():
2012 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
2013 if _has_probe(args):
2014 return _probe_and(args, ctx)
2015 else:
2016 args = _coerce_expr_list(args, ctx)
2017 _args, sz = _to_ast_array(args)
2019
2020
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 9114 of file z3py.py.
9114def AndThen(*ts, **ks):
9115 """Return a tactic that applies the tactics in `*ts` in sequence.
9116
9117 >>> x, y = Ints('x y')
9118 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
9119 >>> t(And(x == 0, y > x + 1))
9120 [[Not(y <= 1)]]
9121 >>> t(And(x == 0, y > x + 1)).as_expr()
9122 Not(y <= 1)
9123 """
9124 if z3_debug():
9125 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9126 ctx = ks.get("ctx", None)
9127 num = len(ts)
9128 r = ts[0]
9129 for i in range(num - 1):
9130 r = _and_then(r, ts[i + 1], ctx)
9131 return r
9132
9133
◆ 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 6078 of file z3py.py.
6078def args2params(arguments, keywords, ctx=None):
6079 """Convert python arguments into a Z3_params object.
6080 A ':' is added to the keywords, and '_' is replaced with '-'
6081
6082 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
6083 (params model true relevancy 2 elim_and true)
6084 """
6085 if z3_debug():
6086 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
6087 prev = None
6088 r = ParamsRef(ctx)
6089 for a in arguments:
6090 if prev is None:
6091 prev = a
6092 else:
6093 r.set(prev, a)
6094 prev = None
6095 for k in keywords:
6096 v = keywords[k]
6097 r.set(k, v)
6098 return r
6099
6100
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 4968 of file z3py.py.
4968def Array(name, *sorts):
4969 """Return an array constant named `name` with the given domain and range sorts.
4970
4971 >>> a = Array('a', IntSort(), IntSort())
4972 >>> a.sort()
4973 Array(Int, Int)
4974 >>> a[0]
4975 a[0]
4976 """
4977 s = ArraySort(sorts)
4978 ctx = s.ctx
4980
4981
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 4935 of file z3py.py.
4935def ArraySort(*sig):
4936 """Return the Z3 array sort with the given domain and range sorts.
4937
4938 >>> A = ArraySort(IntSort(), BoolSort())
4939 >>> A
4940 Array(Int, Bool)
4941 >>> A.domain()
4942 Int
4943 >>> A.range()
4944 Bool
4945 >>> AA = ArraySort(IntSort(), A)
4946 >>> AA
4947 Array(Int, Array(Int, Bool))
4948 """
4949 sig = _get_args(sig)
4950 if z3_debug():
4951 _z3_assert(len(sig) > 1, "At least two arguments expected")
4952 arity = len(sig) - 1
4953 r = sig[arity]
4954 d = sig[0]
4955 if z3_debug():
4956 for s in sig:
4957 _z3_assert(is_sort(s), "Z3 sort expected")
4958 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4959 ctx = d.ctx
4960 if len(sig) == 2:
4962 dom = (Sort * arity)()
4963 for i in range(arity):
4964 dom[i] = sig[i].ast
4966
4967
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().
◆ AsArray()
| AsArray | ( | f | ) |
Return a Z3 as-array expression for the given function declaration.
>>> f = Function('f', IntSort(), IntSort())
>>> a = AsArray(f)
>>> a.sort()
Array(Int, Int)
>>> is_as_array(a)
True
>>> get_as_array_func(a) == f
True
Definition at line 5115 of file z3py.py.
5115def AsArray(f):
5116 """Return a Z3 as-array expression for the given function declaration.
5117
5118 >>> f = Function('f', IntSort(), IntSort())
5119 >>> a = AsArray(f)
5120 >>> a.sort()
5121 Array(Int, Int)
5122 >>> is_as_array(a)
5123 True
5124 >>> get_as_array_func(a) == f
5125 True
5126 """
5127 if z3_debug():
5128 _z3_assert(isinstance(f, FuncDeclRef), "function declaration expected")
5129 ctx = f.ctx
5131
5132
Z3_ast Z3_API Z3_mk_as_array(Z3_context c, Z3_func_decl f)
Create array with the same interpretation as a function. The array satisfies the property (f x) = (se...
Referenced by FiniteSetFilter(), and FiniteSetMap().
◆ 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 9772 of file z3py.py.
9772def AtLeast(*args):
9773 """Create an at-least Pseudo-Boolean k constraint.
9774
9775 >>> a, b, c = Bools('a b c')
9776 >>> f = AtLeast(a, b, c, 2)
9777 """
9778 args = _get_args(args)
9779 if z3_debug():
9780 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9781 ctx = _ctx_from_ast_arg_list(args)
9782 if z3_debug():
9783 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9784 args1 = _coerce_expr_list(args[:-1], ctx)
9785 k = args[-1]
9786 _args, sz = _to_ast_array(args1)
9788
9789
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 9754 of file z3py.py.
9754def AtMost(*args):
9755 """Create an at-most Pseudo-Boolean k constraint.
9756
9757 >>> a, b, c = Bools('a b c')
9758 >>> f = AtMost(a, b, c, 2)
9759 """
9760 args = _get_args(args)
9761 if z3_debug():
9762 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9763 ctx = _ctx_from_ast_arg_list(args)
9764 if z3_debug():
9765 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9766 args1 = _coerce_expr_list(args[:-1], ctx)
9767 k = args[-1]
9768 _args, sz = _to_ast_array(args1)
9770
9771
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 4210 of file z3py.py.
4210def BitVec(name, bv, ctx=None):
4211 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4212 If `ctx=None`, then the global context is used.
4213
4214 >>> x = BitVec('x', 16)
4215 >>> is_bv(x)
4216 True
4217 >>> x.size()
4218 16
4219 >>> x.sort()
4220 BitVec(16)
4221 >>> word = BitVecSort(16)
4222 >>> x2 = BitVec('x', word)
4223 >>> eq(x, x2)
4224 True
4225 """
4226 if isinstance(bv, BitVecSortRef):
4227 ctx = bv.ctx
4228 else:
4229 ctx = _get_ctx(ctx)
4230 bv = BitVecSort(bv, ctx)
4232
4233
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 4234 of file z3py.py.
4234def BitVecs(names, bv, ctx=None):
4235 """Return a tuple of bit-vector constants of size bv.
4236
4237 >>> x, y, z = BitVecs('x y z', 16)
4238 >>> x.size()
4239 16
4240 >>> x.sort()
4241 BitVec(16)
4242 >>> Sum(x, y, z)
4243 0 + x + y + z
4244 >>> Product(x, y, z)
4245 1*x*y*z
4246 >>> simplify(Product(x, y, z))
4247 x*y*z
4248 """
4249 ctx = _get_ctx(ctx)
4250 if isinstance(names, str):
4251 names = names.split(" ")
4252 return [BitVec(name, bv, ctx) for name in names]
4253
4254
◆ 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 4178 of file z3py.py.
4178def BitVecSort(sz, ctx=None):
4179 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4180
4181 >>> Byte = BitVecSort(8)
4182 >>> Word = BitVecSort(16)
4183 >>> Byte
4184 BitVec(8)
4185 >>> x = Const('x', Byte)
4186 >>> eq(x, BitVec('x', 8))
4187 True
4188 """
4189 ctx = _get_ctx(ctx)
4191
4192
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 4193 of file z3py.py.
4193def BitVecVal(val, bv, ctx=None):
4194 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4195
4196 >>> v = BitVecVal(10, 32)
4197 >>> v
4198 10
4199 >>> print("0x%.8x" % v.as_long())
4200 0x0000000a
4201 """
4202 if is_bv_sort(bv):
4203 ctx = bv.ctx
4205 else:
4206 ctx = _get_ctx(ctx)
4208
4209
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 1867 of file z3py.py.
1867def Bool(name, ctx=None):
1868 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1869
1870 >>> p = Bool('p')
1871 >>> q = Bool('q')
1872 >>> And(p, q)
1873 And(p, q)
1874 """
1875 ctx = _get_ctx(ctx)
1877
1878
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 1879 of file z3py.py.
1879def Bools(names, ctx=None):
1880 """Return a tuple of Boolean constants.
1881
1882 `names` is a single string containing all names separated by blank spaces.
1883 If `ctx=None`, then the global context is used.
1884
1885 >>> p, q, r = Bools('p q r')
1886 >>> And(p, Or(q, r))
1887 And(p, Or(q, r))
1888 """
1889 ctx = _get_ctx(ctx)
1890 if isinstance(names, str):
1891 names = names.split(" ")
1892 return [Bool(name, ctx) for name in names]
1893
1894
◆ 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 1830 of file z3py.py.
1830def BoolSort(ctx=None):
1831 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1832
1833 >>> BoolSort()
1834 Bool
1835 >>> p = Const('p', BoolSort())
1836 >>> is_bool(p)
1837 True
1838 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1839 >>> r(0, 1)
1840 r(0, 1)
1841 >>> is_bool(r(0, 1))
1842 True
1843 """
1844 ctx = _get_ctx(ctx)
1846
1847
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 1848 of file z3py.py.
1848def BoolVal(val, ctx=None):
1849 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1850
1851 >>> BoolVal(True)
1852 True
1853 >>> is_true(BoolVal(True))
1854 True
1855 >>> is_true(True)
1856 False
1857 >>> is_false(BoolVal(False))
1858 True
1859 """
1860 ctx = _get_ctx(ctx)
1861 if val:
1863 else:
1865
1866
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 1895 of file z3py.py.
1895def BoolVector(prefix, sz, ctx=None):
1896 """Return a list of Boolean constants of size `sz`.
1897
1898 The constants are named using the given prefix.
1899 If `ctx=None`, then the global context is used.
1900
1901 >>> P = BoolVector('p', 3)
1902 >>> P
1903 [p__0, p__1, p__2]
1904 >>> And(P)
1905 And(p__0, p__1, p__2)
1906 """
1907 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1908
1909
◆ 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 4146 of file z3py.py.
4146def BV2Int(a, is_signed=False):
4147 """Return the Z3 expression BV2Int(a).
4148
4149 >>> b = BitVec('b', 3)
4150 >>> BV2Int(b).sort()
4151 Int
4152 >>> x = Int('x')
4153 >>> x > BV2Int(b)
4154 x > BV2Int(b)
4155 >>> x > BV2Int(b, is_signed=False)
4156 x > BV2Int(b)
4157 >>> x > BV2Int(b, is_signed=True)
4158 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4159 >>> solve(x > BV2Int(b), b == 1, x < 3)
4160 [x = 2, b = 1]
4161 """
4162 if z3_debug():
4163 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4164 ctx = a.ctx
4165 # investigate problem with bv2int
4167
4168
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 4694 of file z3py.py.
4694def BVAddNoOverflow(a, b, signed):
4695 """A predicate the determines that bit-vector addition does not overflow"""
4696 _check_bv_args(a, b)
4697 a, b = _coerce_exprs(a, b)
4699
4700
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 4701 of file z3py.py.
4701def BVAddNoUnderflow(a, b):
4702 """A predicate the determines that signed bit-vector addition does not underflow"""
4703 _check_bv_args(a, b)
4704 a, b = _coerce_exprs(a, b)
4706
4707
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 4736 of file z3py.py.
4736def BVMulNoOverflow(a, b, signed):
4737 """A predicate the determines that bit-vector multiplication does not overflow"""
4738 _check_bv_args(a, b)
4739 a, b = _coerce_exprs(a, b)
4741
4742
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 4743 of file z3py.py.
4743def BVMulNoUnderflow(a, b):
4744 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4745 _check_bv_args(a, b)
4746 a, b = _coerce_exprs(a, b)
4748
4749
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...
◆ BvNand()
| BvNand | ( | a, | |
| b ) |
Return the bitwise NAND of `a` and `b`.
>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvNand(x, y)
bvnand(x, y)
Definition at line 4655 of file z3py.py.
4655def BvNand(a, b):
4656 """Return the bitwise NAND of `a` and `b`.
4657
4658 >>> x = BitVec('x', 8)
4659 >>> y = BitVec('y', 8)
4660 >>> BvNand(x, y)
4661 bvnand(x, y)
4662 """
4663 _check_bv_args(a, b)
4664 a, b = _coerce_exprs(a, b)
4666
4667
◆ BvNor()
| BvNor | ( | a, | |
| b ) |
Return the bitwise NOR of `a` and `b`.
>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvNor(x, y)
bvnor(x, y)
Definition at line 4668 of file z3py.py.
4668def BvNor(a, b):
4669 """Return the bitwise NOR of `a` and `b`.
4670
4671 >>> x = BitVec('x', 8)
4672 >>> y = BitVec('y', 8)
4673 >>> BvNor(x, y)
4674 bvnor(x, y)
4675 """
4676 _check_bv_args(a, b)
4677 a, b = _coerce_exprs(a, b)
4679
4680
◆ BVRedAnd()
| BVRedAnd | ( | a | ) |
Return the reduction-and expression of `a`.
Definition at line 4641 of file z3py.py.
4641def BVRedAnd(a):
4642 """Return the reduction-and expression of `a`."""
4643 if z3_debug():
4644 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4646
4647
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 4648 of file z3py.py.
4648def BVRedOr(a):
4649 """Return the reduction-or expression of `a`."""
4650 if z3_debug():
4651 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4653
4654
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 4722 of file z3py.py.
4722def BVSDivNoOverflow(a, b):
4723 """A predicate the determines that bit-vector signed division does not overflow"""
4724 _check_bv_args(a, b)
4725 a, b = _coerce_exprs(a, b)
4727
4728
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 4729 of file z3py.py.
4729def BVSNegNoOverflow(a):
4730 """A predicate the determines that bit-vector unary negation does not overflow"""
4731 if z3_debug():
4732 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4734
4735
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 4708 of file z3py.py.
4708def BVSubNoOverflow(a, b):
4709 """A predicate the determines that bit-vector subtraction does not overflow"""
4710 _check_bv_args(a, b)
4711 a, b = _coerce_exprs(a, b)
4713
4714
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 4715 of file z3py.py.
4715def BVSubNoUnderflow(a, b, signed):
4716 """A predicate the determines that bit-vector subtraction does not underflow"""
4717 _check_bv_args(a, b)
4718 a, b = _coerce_exprs(a, b)
4720
4721
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.
◆ BvXnor()
| BvXnor | ( | a, | |
| b ) |
Return the bitwise XNOR of `a` and `b`.
>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvXnor(x, y)
bvxnor(x, y)
Definition at line 4681 of file z3py.py.
4681def BvXnor(a, b):
4682 """Return the bitwise XNOR of `a` and `b`.
4683
4684 >>> x = BitVec('x', 8)
4685 >>> y = BitVec('y', 8)
4686 >>> BvXnor(x, y)
4687 bvxnor(x, y)
4688 """
4689 _check_bv_args(a, b)
4690 a, b = _coerce_exprs(a, b)
4692
4693
◆ 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 3592 of file z3py.py.
3592def Cbrt(a, ctx=None):
3593 """ Return a Z3 expression which represents the cubic root of a.
3594
3595 >>> x = Real('x')
3596 >>> Cbrt(x)
3597 x**(1/3)
3598 """
3599 if not is_expr(a):
3600 ctx = _get_ctx(ctx)
3601 a = RealVal(a, ctx)
3602 return a ** "1/3"
3603
◆ 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 4255 of file z3py.py.
4255def Concat(*args):
4256 """Create a Z3 bit-vector concatenation expression.
4257
4258 >>> v = BitVecVal(1, 4)
4259 >>> Concat(v, v+1, v)
4260 Concat(Concat(1, 1 + 1), 1)
4261 >>> simplify(Concat(v, v+1, v))
4262 289
4263 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4264 121
4265 """
4266 args = _get_args(args)
4267 sz = len(args)
4268 if z3_debug():
4269 _z3_assert(sz >= 2, "At least two arguments expected.")
4270
4271 ctx = None
4272 for a in args:
4273 if is_expr(a):
4274 ctx = a.ctx
4275 break
4276 if is_seq(args[0]) or isinstance(args[0], str):
4277 args = [_coerce_seq(s, ctx) for s in args]
4278 if z3_debug():
4279 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4280 v = (Ast * sz)()
4281 for i in range(sz):
4282 v[i] = args[i].as_ast()
4284
4285 if is_re(args[0]):
4286 if z3_debug():
4287 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4288 v = (Ast * sz)()
4289 for i in range(sz):
4290 v[i] = args[i].as_ast()
4292
4293 if z3_debug():
4294 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4295 r = args[0]
4296 for i in range(sz - 1):
4297 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4298 return r
4299
4300
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 9571 of file z3py.py.
9571def Cond(p, t1, t2, ctx=None):
9572 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
9573
9574 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
9575 """
9576 p = _to_probe(p, ctx)
9577 t1 = _to_tactic(t1, ctx)
9578 t2 = _to_tactic(t2, ctx)
9580
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 1546 of file z3py.py.
1546def Const(name, sort):
1547 """Create a constant of the given sort.
1548
1549 >>> Const('x', IntSort())
1550 x
1551 """
1552 if z3_debug():
1553 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1554 ctx = sort.ctx
1556
1557
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 1558 of file z3py.py.
1558def Consts(names, sort):
1559 """Create several constants of the given sort.
1560
1561 `names` is a string containing the names of all constants to be created.
1562 Blank spaces separate the names of different constants.
1563
1564 >>> x, y, z = Consts('x y z', IntSort())
1565 >>> x + y + z
1566 x + y + z
1567 """
1568 if isinstance(names, str):
1569 names = names.split(" ")
1570 return [Const(name, sort) for name in names]
1571
1572
◆ 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 11873 of file z3py.py.
11873def Contains(a, b):
11874 """Check if 'a' contains 'b'
11875 >>> s1 = Contains("abc", "ab")
11876 >>> simplify(s1)
11877 True
11878 >>> s2 = Contains("abc", "bc")
11879 >>> simplify(s2)
11880 True
11881 >>> x, y, z = Strings('x y z')
11882 >>> s3 = Contains(Concat(x,y,z), y)
11883 >>> simplify(s3)
11884 True
11885 """
11886 ctx = _get_ctx2(a, b)
11887 a = _coerce_seq(a, ctx)
11888 b = _coerce_seq(b, ctx)
11890
11891
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 5654 of file z3py.py.
5654def CreateDatatypes(*ds):
5655 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5656
5657 In the following example we define a Tree-List using two mutually recursive datatypes.
5658
5659 >>> TreeList = Datatype('TreeList')
5660 >>> Tree = Datatype('Tree')
5661 >>> # Tree has two constructors: leaf and node
5662 >>> Tree.declare('leaf', ('val', IntSort()))
5663 >>> # a node contains a list of trees
5664 >>> Tree.declare('node', ('children', TreeList))
5665 >>> TreeList.declare('nil')
5666 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5667 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5668 >>> Tree.val(Tree.leaf(10))
5669 val(leaf(10))
5670 >>> simplify(Tree.val(Tree.leaf(10)))
5671 10
5672 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5673 >>> n1
5674 node(cons(leaf(10), cons(leaf(20), nil)))
5675 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5676 >>> simplify(n2 == n1)
5677 False
5678 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5679 True
5680 """
5681 ds = _get_args(ds)
5682 if z3_debug():
5683 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5684 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5685 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5686 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5687 ctx = ds[0].ctx
5688 num = len(ds)
5689 names = (Symbol * num)()
5690 out = (Sort * num)()
5691 clists = (ConstructorList * num)()
5692 to_delete = []
5693 for i in range(num):
5694 d = ds[i]
5695 names[i] = to_symbol(d.name, ctx)
5696 num_cs = len(d.constructors)
5697 cs = (Constructor * num_cs)()
5698 for j in range(num_cs):
5699 c = d.constructors[j]
5700 cname = to_symbol(c[0], ctx)
5701 rname = to_symbol(c[1], ctx)
5702 fs = c[2]
5703 num_fs = len(fs)
5704 fnames = (Symbol * num_fs)()
5705 sorts = (Sort * num_fs)()
5706 refs = (ctypes.c_uint * num_fs)()
5707 for k in range(num_fs):
5708 fname = fs[k][0]
5709 ftype = fs[k][1]
5710 fnames[k] = to_symbol(fname, ctx)
5711 if isinstance(ftype, Datatype):
5712 if z3_debug():
5713 _z3_assert(
5714 ds.count(ftype) == 1,
5715 "One and only one occurrence of each datatype is expected",
5716 )
5717 sorts[k] = None
5718 refs[k] = ds.index(ftype)
5719 else:
5720 if z3_debug():
5721 _z3_assert(is_sort(ftype), "Z3 sort expected")
5722 sorts[k] = ftype.ast
5723 refs[k] = 0
5724 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5725 to_delete.append(ScopedConstructor(cs[j], ctx))
5726 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5727 to_delete.append(ScopedConstructorList(clists[i], ctx))
5728 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5729 result = []
5730 # Create a field for every constructor, recognizer and accessor
5731 for i in range(num):
5732 dref = DatatypeSortRef(out[i], ctx)
5733 num_cs = dref.num_constructors()
5734 for j in range(num_cs):
5735 cref = dref.constructor(j)
5736 cref_name = cref.name()
5737 cref_arity = cref.arity()
5738 if cref.arity() == 0:
5739 cref = cref()
5740 setattr(dref, cref_name, cref)
5741 rref = dref.recognizer(j)
5742 setattr(dref, "is_" + cref_name, rref)
5743 for k in range(cref_arity):
5744 aref = dref.accessor(j, k)
5745 setattr(dref, aref.name(), aref)
5746 result.append(dref)
5747 return tuple(result)
5748
5749
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().
◆ CreatePolymorphicDatatype()
| CreatePolymorphicDatatype | ( | d, | |
| type_params ) |
Create a single polymorphic Z3 datatype with explicit type parameters.
`d` is a `Datatype` helper object whose constructors have been declared.
`type_params` is a list of type variables created with `DeclareTypeVar`.
Constructor field sorts may reference these type variables, and self-recursive
fields may reference `d` directly.
>>> A = DeclareTypeVar('A')
>>> Pair = Datatype('Pair')
>>> Pair.declare('pair', ('fst', A), ('snd', A))
>>> Pair = CreatePolymorphicDatatype(Pair, [A])
Definition at line 5750 of file z3py.py.
5750def CreatePolymorphicDatatype(d, type_params):
5751 """Create a single polymorphic Z3 datatype with explicit type parameters.
5752
5753 `d` is a `Datatype` helper object whose constructors have been declared.
5754 `type_params` is a list of type variables created with `DeclareTypeVar`.
5755 Constructor field sorts may reference these type variables, and self-recursive
5756 fields may reference `d` directly.
5757
5758 >>> A = DeclareTypeVar('A')
5759 >>> Pair = Datatype('Pair')
5760 >>> Pair.declare('pair', ('fst', A), ('snd', A))
5761 >>> Pair = CreatePolymorphicDatatype(Pair, [A])
5762 """
5763 if z3_debug():
5764 _z3_assert(isinstance(d, Datatype), "Datatype expected")
5765 _z3_assert(d.constructors != [], "Non-empty Datatype expected")
5766 ctx = d.ctx
5767 name = to_symbol(d.name, ctx)
5768 num_params = len(type_params)
5769 params_arr = (Sort * num_params)()
5770 for i, p in enumerate(type_params):
5771 if z3_debug():
5772 _z3_assert(is_sort(p), "Z3 sort expected for type parameter")
5773 params_arr[i] = p.ast
5774 num_cs = len(d.constructors)
5775 cs = (Constructor * num_cs)()
5776 to_delete = []
5777 for j in range(num_cs):
5778 c = d.constructors[j]
5779 cname = to_symbol(c[0], ctx)
5780 rname = to_symbol(c[1], ctx)
5781 fs = c[2]
5782 num_fs = len(fs)
5783 fnames = (Symbol * num_fs)()
5784 sorts = (Sort * num_fs)()
5785 refs = (ctypes.c_uint * num_fs)()
5786 for k in range(num_fs):
5787 fname = fs[k][0]
5788 ftype = fs[k][1]
5789 fnames[k] = to_symbol(fname, ctx)
5790 if isinstance(ftype, Datatype):
5791 if z3_debug():
5792 _z3_assert(ftype is d, "Only self-recursive references are supported in polymorphic datatypes. Use CreateDatatypes for mutually recursive datatypes.")
5793 sorts[k] = None
5794 refs[k] = 0
5795 else:
5796 if z3_debug():
5797 _z3_assert(is_sort(ftype), "Z3 sort expected")
5798 sorts[k] = ftype.ast
5799 refs[k] = 0
5800 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5801 to_delete.append(ScopedConstructor(cs[j], ctx))
5802 out = Z3_mk_polymorphic_datatype(ctx.ref(), name, num_params, params_arr, num_cs, cs)
5803 dref = DatatypeSortRef(out, ctx)
5804 num_cs_actual = dref.num_constructors()
5805 for j in range(num_cs_actual):
5806 cref = dref.constructor(j)
5807 cref_name = cref.name()
5808 cref_arity = cref.arity()
5809 if cref_arity == 0:
5810 cref = cref()
5811 setattr(dref, cref_name, cref)
5812 rref = dref.recognizer(j)
5813 setattr(dref, "is_" + cref_name, rref)
5814 for k in range(cref_arity):
5815 aref = dref.accessor(j, k)
5816 setattr(dref, aref.name(), aref)
5817 return dref
5818
5819
Z3_sort Z3_API Z3_mk_polymorphic_datatype(Z3_context c, Z3_symbol name, unsigned num_parameters, Z3_sort parameters[], unsigned num_constructors, Z3_constructor constructors[])
Create a parametric datatype with explicit type parameters.
Referenced by Datatype.create_polymorphic().
◆ DatatypeSort()
| DatatypeSort | ( | name, | |
| params = None, | |||
| ctx = None ) |
Create a reference to a sort that was declared, or will be declared, as a recursive datatype.
Args:
name: name of the datatype sort
params: optional list/tuple of sort parameters for parametric datatypes
ctx: Z3 context (optional)
Example:
>>> # Non-parametric datatype
>>> TreeRef = DatatypeSort('Tree')
>>> # Parametric datatype with one parameter
>>> ListIntRef = DatatypeSort('List', [IntSort()])
>>> # Parametric datatype with multiple parameters
>>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])
Definition at line 5950 of file z3py.py.
5950def DatatypeSort(name, params=None, ctx=None):
5951 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype.
5952
5953 Args:
5954 name: name of the datatype sort
5955 params: optional list/tuple of sort parameters for parametric datatypes
5956 ctx: Z3 context (optional)
5957
5958 Example:
5959 >>> # Non-parametric datatype
5960 >>> TreeRef = DatatypeSort('Tree')
5961 >>> # Parametric datatype with one parameter
5962 >>> ListIntRef = DatatypeSort('List', [IntSort()])
5963 >>> # Parametric datatype with multiple parameters
5964 >>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])
5965 """
5966 ctx = _get_ctx(ctx)
5967 if params is None or len(params) == 0:
5968 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), 0, (Sort * 0)()), ctx)
5969 else:
5970 _params = (Sort * len(params))()
5971 for i in range(len(params)):
5972 _params[i] = params[i].ast
5973 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), len(params), _params), ctx)
5974
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name, unsigned num_params, Z3_sort const params[])
create a forward reference to a recursive datatype being declared. The forward reference can be used ...
◆ DeclareSort()
| SortRef DeclareSort | ( | name, | |
| ctx = None ) |
Create a new uninterpreted sort named `name`.
If `ctx=None`, then the new sort is declared in the global Z3Py context.
>>> A = DeclareSort('A')
>>> a = Const('a', A)
>>> b = Const('b', A)
>>> a.sort() == A
True
>>> b.sort() == A
True
>>> a == b
a == b
Definition at line 732 of file z3py.py.
732def DeclareSort(name, ctx= None) -> SortRef:
733 """Create a new uninterpreted sort named `name`.
734
735 If `ctx=None`, then the new sort is declared in the global Z3Py context.
736
737 >>> A = DeclareSort('A')
738 >>> a = Const('a', A)
739 >>> b = Const('b', A)
740 >>> a.sort() == A
741 True
742 >>> b.sort() == A
743 True
744 >>> a == b
745 a == b
746 """
747 ctx = _get_ctx(ctx)
749
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 760 of file z3py.py.
760def DeclareTypeVar(name, ctx=None):
761 """Create a new type variable named `name`.
762
763 If `ctx=None`, then the new sort is declared in the global Z3Py context.
764
765 """
766 ctx = _get_ctx(ctx)
768
769
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 5014 of file z3py.py.
5014def Default(a):
5015 """ Return a default value for array expression.
5016 >>> b = K(IntSort(), 1)
5017 >>> prove(Default(b) == 1)
5018 proved
5019 """
5020 if z3_debug():
5021 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
5022 return a.default()
5023
5024
◆ describe_probes()
| describe_probes | ( | ) |
Display a (tabular) description of all available probes in Z3.
Definition at line 9492 of file z3py.py.
9492def describe_probes():
9493 """Display a (tabular) description of all available probes in Z3."""
9494 if in_html_mode():
9495 even = True
9496 print('<table border="1" cellpadding="2" cellspacing="0">')
9497 for p in probes():
9498 if even:
9499 print('<tr style="background-color:#CFCFCF">')
9500 even = False
9501 else:
9502 print("<tr>")
9503 even = True
9504 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
9505 print("</table>")
9506 else:
9507 for p in probes():
9508 print("%s : %s" % (p, probe_description(p)))
9509
9510
◆ describe_tactics()
| describe_tactics | ( | ) |
Display a (tabular) description of all available tactics in Z3.
Definition at line 9286 of file z3py.py.
9286def describe_tactics():
9287 """Display a (tabular) description of all available tactics in Z3."""
9288 if in_html_mode():
9289 even = True
9290 print('<table border="1" cellpadding="2" cellspacing="0">')
9291 for t in tactics():
9292 if even:
9293 print('<tr style="background-color:#CFCFCF">')
9294 even = False
9295 else:
9296 print("<tr>")
9297 even = True
9298 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
9299 print("</table>")
9300 else:
9301 for t in tactics():
9302 print("%s : %s" % (t, tactic_description(t)))
9303
9304
◆ 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 1209 of file z3py.py.
1209def deserialize(st):
1210 """inverse function to the serialize method on ExprRef.
1211 It is made available to make it easier for users to serialize expressions back and forth between
1212 strings. Solvers can be serialized using the 'sexpr()' method.
1213 """
1214 s = Solver()
1215 s.from_string(st)
1216 if len(s.assertions()) != 1:
1217 raise Z3Exception("single assertion expected")
1218 fml = s.assertions()[0]
1219 if fml.num_args() != 1:
1220 raise Z3Exception("dummy function 'F' expected")
1221 return fml.arg(0)
1222
◆ Diff()
| Diff | ( | a, | |
| b, | |||
| ctx = None ) |
Create the difference regular expression
Definition at line 12194 of file z3py.py.
12194def Diff(a, b, ctx=None):
12195 """Create the difference regular expression
12196 """
12197 if z3_debug():
12198 _z3_assert(is_expr(a), "expression expected")
12199 _z3_assert(is_expr(b), "expression expected")
12201
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 5987 of file z3py.py.
5987def DisjointSum(name, sorts, ctx=None):
5988 """Create a named tagged union sort base on a set of underlying sorts
5989 Example:
5990 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5991 """
5992 sum = Datatype(name, ctx)
5993 for i in range(len(sorts)):
5994 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5995 sum = sum.create()
5996 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5997
5998
◆ 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 1513 of file z3py.py.
1513def Distinct(*args):
1514 """Create a Z3 distinct expression.
1515
1516 >>> x = Int('x')
1517 >>> y = Int('y')
1518 >>> Distinct(x, y)
1519 x != y
1520 >>> z = Int('z')
1521 >>> Distinct(x, y, z)
1522 Distinct(x, y, z)
1523 >>> simplify(Distinct(x, y, z))
1524 Distinct(x, y, z)
1525 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1526 And(Not(x == y), Not(x == z), Not(y == z))
1527 """
1528 args = _get_args(args)
1529 ctx = _ctx_from_ast_arg_list(args)
1530 if z3_debug():
1531 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1532 args = _coerce_expr_list(args, ctx)
1533 _args, sz = _to_ast_array(args)
1535
1536
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 11803 of file z3py.py.
11803def Empty(s):
11804 """Create the empty sequence of the given sort
11805 >>> e = Empty(StringSort())
11806 >>> e2 = StringVal("")
11807 >>> print(e.eq(e2))
11808 True
11809 >>> e3 = Empty(SeqSort(IntSort()))
11810 >>> print(e3)
11811 Empty(Seq(Int))
11812 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11813 >>> print(e4)
11814 Empty(ReSort(Seq(Int)))
11815 """
11816 if isinstance(s, SeqSortRef):
11818 if isinstance(s, ReSortRef):
11820 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11821
11822
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 5999 of file z3py.py.
5999def EnumSort(name, values, ctx=None):
6000 """Return a new enumeration sort named `name` containing the given values.
6001
6002 The result is a pair (sort, list of constants).
6003 Example:
6004 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
6005 """
6006 if z3_debug():
6007 _z3_assert(isinstance(name, str), "Name must be a string")
6008 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
6009 _z3_assert(len(values) > 0, "At least one value expected")
6010 ctx = _get_ctx(ctx)
6011 num = len(values)
6012 _val_names = (Symbol * num)()
6013 for i in range(num):
6014 _val_names[i] = to_symbol(values[i], ctx)
6015 _values = (FuncDecl * num)()
6016 _testers = (FuncDecl * num)()
6017 name = to_symbol(name, ctx)
6018 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
6019 V = []
6020 for i in range(num):
6021 V.append(FuncDeclRef(_values[i], ctx))
6022 V = [a() for a in V]
6023 return S, V
6024
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 503 of file z3py.py.
503def eq(a : AstRef, b : AstRef) -> bool:
504 """Return `True` if `a` and `b` are structurally identical AST nodes.
505
506 >>> x = Int('x')
507 >>> y = Int('y')
508 >>> eq(x, y)
509 False
510 >>> eq(x + 1, x + 1)
511 True
512 >>> eq(x + 1, 1 + x)
513 False
514 >>> eq(simplify(x + 1), simplify(1 + x))
515 True
516 """
517 if z3_debug():
518 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
519 return a.eq(b)
520
521
◆ 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 2389 of file z3py.py.
2389def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2390 """Create a Z3 exists formula.
2391
2392 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2393
2394
2395 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2396 >>> x = Int('x')
2397 >>> y = Int('y')
2398 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2399 >>> q
2400 Exists([x, y], f(x, y) >= x)
2401 >>> is_quantifier(q)
2402 True
2403 >>> r = Tactic('nnf')(q).as_expr()
2404 >>> is_quantifier(r)
2405 False
2406 """
2407 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2408
2409
◆ 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 5103 of file z3py.py.
5103def Ext(a, b):
5104 """Return extensionality index for one-dimensional arrays.
5105 >> a, b = Consts('a b', SetSort(IntSort()))
5106 >> Ext(a, b)
5107 Ext(a, b)
5108 """
5109 ctx = a.ctx
5110 if z3_debug():
5111 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
5113
5114
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 4301 of file z3py.py.
4301def Extract(high, low, a):
4302 """Create a Z3 bit-vector extraction expression or sequence extraction expression.
4303
4304 Extract is overloaded to work with both bit-vectors and sequences:
4305
4306 **Bit-vector extraction**: Extract(high, low, bitvector)
4307 Extracts bits from position `high` down to position `low` (both inclusive).
4308 - high: int - the highest bit position to extract (0-indexed from right)
4309 - low: int - the lowest bit position to extract (0-indexed from right)
4310 - bitvector: BitVecRef - the bit-vector to extract from
4311 Returns a new bit-vector containing bits [high:low]
4312
4313 **Sequence extraction**: Extract(sequence, offset, length)
4314 Extracts a subsequence starting at the given offset with the specified length.
4315 The functions SubString and SubSeq are redirected to this form of Extract.
4316 - sequence: SeqRef or str - the sequence to extract from
4317 - offset: int - the starting position (0-indexed)
4318 - length: int - the number of elements to extract
4319 Returns a new sequence containing the extracted subsequence
4320
4321 >>> # Bit-vector extraction examples
4322 >>> x = BitVec('x', 8)
4323 >>> Extract(6, 2, x) # Extract bits 6 down to 2 (5 bits total)
4324 Extract(6, 2, x)
4325 >>> Extract(6, 2, x).sort() # Result is a 5-bit vector
4326 BitVec(5)
4327 >>> Extract(7, 0, x) # Extract all 8 bits
4328 Extract(7, 0, x)
4329 >>> Extract(3, 3, x) # Extract single bit at position 3
4330 Extract(3, 3, x)
4331
4332 >>> # Sequence extraction examples
4333 >>> s = StringVal("hello")
4334 >>> Extract(s, 1, 3) # Extract 3 characters starting at position 1
4335 str.substr("hello", 1, 3)
4336 >>> simplify(Extract(StringVal("abcd"), 2, 1)) # Extract 1 character at position 2
4337 "c"
4338 >>> simplify(Extract(StringVal("abcd"), 0, 2)) # Extract first 2 characters
4339 "ab"
4340 """
4341 if isinstance(high, str):
4342 high = StringVal(high)
4343 if is_seq(high):
4344 s = high
4345 offset, length = _coerce_exprs(low, a, s.ctx)
4346 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4347 if z3_debug():
4348 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4349 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4350 "First and second arguments must be non negative integers")
4351 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4353
4354
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 9529 of file z3py.py.
9529def FailIf(p, ctx=None):
9530 """Return a tactic that fails if the probe `p` evaluates to true.
9531 Otherwise, it returns the input goal unmodified.
9532
9533 In the following example, the tactic applies 'simplify' if and only if there are
9534 more than 2 constraints in the goal.
9535
9536 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
9537 >>> x, y = Ints('x y')
9538 >>> g = Goal()
9539 >>> g.add(x > 0)
9540 >>> g.add(y > 0)
9541 >>> t(g)
9542 [[x > 0, y > 0]]
9543 >>> g.add(x == y + 1)
9544 >>> t(g)
9545 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9546 """
9547 p = _to_probe(p, ctx)
9549
9550
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 8427 of file z3py.py.
8427def FiniteDomainSort(name, sz, ctx=None):
8428 """Create a named finite domain sort of a given size sz"""
8429 if not isinstance(name, Symbol):
8430 name = to_symbol(name)
8431 ctx = _get_ctx(ctx)
8433
8434
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 8497 of file z3py.py.
8497def FiniteDomainVal(val, sort, ctx=None):
8498 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
8499
8500 >>> s = FiniteDomainSort('S', 256)
8501 >>> FiniteDomainVal(255, s)
8502 255
8503 >>> FiniteDomainVal('100', s)
8504 100
8505 """
8506 if z3_debug():
8507 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
8508 ctx = sort.ctx
8510
8511
◆ FiniteSetDifference()
| FiniteSetDifference | ( | s1, | |
| s2 ) |
Create the set difference of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetDifference(a, b)
set.difference(a, b)
Definition at line 5434 of file z3py.py.
5434def FiniteSetDifference(s1, s2):
5435 """Create the set difference of two finite sets.
5436 >>> a = Const('a', FiniteSetSort(IntSort()))
5437 >>> b = Const('b', FiniteSetSort(IntSort()))
5438 >>> FiniteSetDifference(a, b)
5439 set.difference(a, b)
5440 """
5441 ctx = _ctx_from_ast_arg_list([s1, s2])
5443
5444
Z3_ast Z3_API Z3_mk_finite_set_difference(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the set difference of two finite sets.
Referenced by FiniteSetRef.__sub__(), and SetDifference().
◆ FiniteSetEmpty()
| FiniteSetEmpty | ( | set_sort | ) |
Create an empty finite set of the given sort. >>> s = FiniteSetSort(IntSort()) >>> FiniteSetEmpty(s) set.empty
Definition at line 5393 of file z3py.py.
5393def FiniteSetEmpty(set_sort):
5394 """Create an empty finite set of the given sort.
5395 >>> s = FiniteSetSort(IntSort())
5396 >>> FiniteSetEmpty(s)
5397 set.empty
5398 """
5399 ctx = set_sort.ctx
5401
5402
Z3_ast Z3_API Z3_mk_finite_set_empty(Z3_context c, Z3_sort set_sort)
Create an empty finite set of the given sort.
Referenced by FiniteSetSortRef.cast(), and EmptySet().
◆ FiniteSetFilter()
| FiniteSetFilter | ( | f, | |
| set ) |
Filter a finite set using predicate f.
>>> f = Array('f', IntSort(), BoolSort())
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetFilter(f, a)
set.filter(f, a)
Definition at line 5491 of file z3py.py.
5491def FiniteSetFilter(f, set):
5492 """Filter a finite set using predicate f.
5493 >>> f = Array('f', IntSort(), BoolSort())
5494 >>> a = Const('a', FiniteSetSort(IntSort()))
5495 >>> FiniteSetFilter(f, a)
5496 set.filter(f, a)
5497 """
5498 if isinstance(f, FuncDeclRef):
5499 f = AsArray(f)
5500 ctx = _ctx_from_ast_arg_list([f, set])
5502
5503
Z3_ast Z3_API Z3_mk_finite_set_filter(Z3_context c, Z3_ast f, Z3_ast set)
Filter a finite set using a predicate.
◆ FiniteSetIntersect()
| FiniteSetIntersect | ( | s1, | |
| s2 ) |
Create the intersection of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetIntersect(a, b)
set.intersect(a, b)
Definition at line 5423 of file z3py.py.
5423def FiniteSetIntersect(s1, s2):
5424 """Create the intersection of two finite sets.
5425 >>> a = Const('a', FiniteSetSort(IntSort()))
5426 >>> b = Const('b', FiniteSetSort(IntSort()))
5427 >>> FiniteSetIntersect(a, b)
5428 set.intersect(a, b)
5429 """
5430 ctx = _ctx_from_ast_arg_list([s1, s2])
5432
5433
Z3_ast Z3_API Z3_mk_finite_set_intersect(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the intersection of two finite sets.
Referenced by FiniteSetRef.__and__().
◆ FiniteSetMap()
| FiniteSetMap | ( | f, | |
| set ) |
Apply function f to all elements of the finite set.
>>> f = Array('f', IntSort(), IntSort())
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetMap(f, a)
set.map(f, a)
Definition at line 5478 of file z3py.py.
5478def FiniteSetMap(f, set):
5479 """Apply function f to all elements of the finite set.
5480 >>> f = Array('f', IntSort(), IntSort())
5481 >>> a = Const('a', FiniteSetSort(IntSort()))
5482 >>> FiniteSetMap(f, a)
5483 set.map(f, a)
5484 """
5485 if isinstance(f, FuncDeclRef):
5486 f = AsArray(f)
5487 ctx = _ctx_from_ast_arg_list([f, set])
5489
5490
Z3_ast Z3_API Z3_mk_finite_set_map(Z3_context c, Z3_ast f, Z3_ast set)
Apply a function to all elements of a finite set.
◆ FiniteSetMember()
| FiniteSetMember | ( | elem, | |
| set ) |
Check if elem is a member of the finite set.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetMember(IntVal(1), a)
set.in(1, a)
Definition at line 5445 of file z3py.py.
5445def FiniteSetMember(elem, set):
5446 """Check if elem is a member of the finite set.
5447 >>> a = Const('a', FiniteSetSort(IntSort()))
5448 >>> FiniteSetMember(IntVal(1), a)
5449 set.in(1, a)
5450 """
5451 ctx = _ctx_from_ast_arg_list([elem, set])
5453
Z3_ast Z3_API Z3_mk_finite_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check if an element is a member of a finite set.
Referenced by In().
◆ FiniteSetRange()
| FiniteSetRange | ( | low, | |
| high ) |
Create a finite set of integers in the range [low, high). >>> FiniteSetRange(IntVal(0), IntVal(5)) set.range(0, 5)
Definition at line 5504 of file z3py.py.
5504def FiniteSetRange(low, high):
5505 """Create a finite set of integers in the range [low, high).
5506 >>> FiniteSetRange(IntVal(0), IntVal(5))
5507 set.range(0, 5)
5508 """
5509 ctx = _ctx_from_ast_arg_list([low, high])
5511
5512
Z3_ast Z3_API Z3_mk_finite_set_range(Z3_context c, Z3_ast low, Z3_ast high)
Create a finite set of integers in the range [low, high].
◆ FiniteSetSize()
| FiniteSetSize | ( | set | ) |
Get the size (cardinality) of a finite set.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetSize(a)
set.size(a)
Definition at line 5457 of file z3py.py.
5457def FiniteSetSize(set):
5458 """Get the size (cardinality) of a finite set.
5459 >>> a = Const('a', FiniteSetSort(IntSort()))
5460 >>> FiniteSetSize(a)
5461 set.size(a)
5462 """
5463 ctx = set.ctx
5465
5466
Z3_ast Z3_API Z3_mk_finite_set_size(Z3_context c, Z3_ast set)
Get the size (cardinality) of a finite set.
◆ FiniteSetSort()
| FiniteSetSort | ( | elem_sort | ) |
Create a finite set sort over element sort elem_sort. >>> s = FiniteSetSort(IntSort()) >>> s FiniteSet(Int)
Definition at line 5384 of file z3py.py.
5384def FiniteSetSort(elem_sort):
5385 """Create a finite set sort over element sort elem_sort.
5386 >>> s = FiniteSetSort(IntSort())
5387 >>> s
5388 FiniteSet(Int)
5389 """
5390 return FiniteSetSortRef(Z3_mk_finite_set_sort(elem_sort.ctx_ref(), elem_sort.ast), elem_sort.ctx)
5391
5392
Z3_sort Z3_API Z3_mk_finite_set_sort(Z3_context c, Z3_sort elem_sort)
Create a finite set sort.
◆ FiniteSetSubset()
| FiniteSetSubset | ( | s1, | |
| s2 ) |
Check if s1 is a subset of s2.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetSubset(a, b)
set.subset(a, b)
Definition at line 5467 of file z3py.py.
5467def FiniteSetSubset(s1, s2):
5468 """Check if s1 is a subset of s2.
5469 >>> a = Const('a', FiniteSetSort(IntSort()))
5470 >>> b = Const('b', FiniteSetSort(IntSort()))
5471 >>> FiniteSetSubset(a, b)
5472 set.subset(a, b)
5473 """
5474 ctx = _ctx_from_ast_arg_list([s1, s2])
5476
5477
Z3_ast Z3_API Z3_mk_finite_set_subset(Z3_context c, Z3_ast s1, Z3_ast s2)
Check if one finite set is a subset of another.
◆ FiniteSetUnion()
| FiniteSetUnion | ( | s1, | |
| s2 ) |
Create the union of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetUnion(a, b)
set.union(a, b)
Definition at line 5412 of file z3py.py.
5412def FiniteSetUnion(s1, s2):
5413 """Create the union of two finite sets.
5414 >>> a = Const('a', FiniteSetSort(IntSort()))
5415 >>> b = Const('b', FiniteSetSort(IntSort()))
5416 >>> FiniteSetUnion(a, b)
5417 set.union(a, b)
5418 """
5419 ctx = _ctx_from_ast_arg_list([s1, s2])
5421
5422
Z3_ast Z3_API Z3_mk_finite_set_union(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the union of two finite sets.
Referenced by FiniteSetRef.__or__(), and FiniteSetSortRef.cast().
◆ Float128()
| Float128 | ( | ctx = None | ) |
Floating-point 128-bit (quadruple) sort.
Definition at line 10257 of file z3py.py.
10257def Float128(ctx=None):
10258 """Floating-point 128-bit (quadruple) sort."""
10259 ctx = _get_ctx(ctx)
10261
10262
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 | ) |
Floating-point 64-bit (double) sort.
Definition at line 10251 of file z3py.py.
10251def FloatDouble(ctx=None):
10252 """Floating-point 64-bit (double) sort."""
10253 ctx = _get_ctx(ctx)
10255
10256
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
◆ FloatHalf()
| FloatHalf | ( | ctx = None | ) |
◆ FloatQuadruple()
| FloatQuadruple | ( | ctx = None | ) |
Floating-point 128-bit (quadruple) sort.
Definition at line 10263 of file z3py.py.
10263def FloatQuadruple(ctx=None):
10264 """Floating-point 128-bit (quadruple) sort."""
10265 ctx = _get_ctx(ctx)
10267
10268
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
◆ FloatSingle()
| FloatSingle | ( | ctx = None | ) |
Floating-point 32-bit (single) sort.
Definition at line 10239 of file z3py.py.
10239def FloatSingle(ctx=None):
10240 """Floating-point 32-bit (single) sort."""
10241 ctx = _get_ctx(ctx)
10243
10244
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
◆ 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 2371 of file z3py.py.
2371def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2372 """Create a Z3 forall formula.
2373
2374 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2375
2376 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2377 >>> x = Int('x')
2378 >>> y = Int('y')
2379 >>> ForAll([x, y], f(x, y) >= x)
2380 ForAll([x, y], f(x, y) >= x)
2381 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2382 ForAll([x, y], f(x, y) >= x)
2383 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2384 ForAll([x, y], f(x, y) >= x)
2385 """
2386 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2387
2388
◆ 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 10899 of file z3py.py.
10899def FP(name, fpsort, ctx=None):
10900 """Return a floating-point constant named `name`.
10901 `fpsort` is the floating-point sort.
10902 If `ctx=None`, then the global context is used.
10903
10904 >>> x = FP('x', FPSort(8, 24))
10905 >>> is_fp(x)
10906 True
10907 >>> x.ebits()
10908 8
10909 >>> x.sort()
10910 FPSort(8, 24)
10911 >>> word = FPSort(8, 24)
10912 >>> x2 = FP('x', word)
10913 >>> eq(x, x2)
10914 True
10915 """
10916 if isinstance(fpsort, FPSortRef) and ctx is None:
10917 ctx = fpsort.ctx
10918 else:
10919 ctx = _get_ctx(ctx)
10921
10922
◆ 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 10942 of file z3py.py.
10942def fpAbs(a, ctx=None):
10943 """Create a Z3 floating-point absolute value expression.
10944
10945 >>> s = FPSort(8, 24)
10946 >>> rm = RNE()
10947 >>> x = FPVal(1.0, s)
10948 >>> fpAbs(x)
10949 fpAbs(1)
10950 >>> y = FPVal(-20.0, s)
10951 >>> y
10952 -1.25*(2**4)
10953 >>> fpAbs(y)
10954 fpAbs(-1.25*(2**4))
10955 >>> fpAbs(-1.25*(2**4))
10956 fpAbs(-1.25*(2**4))
10957 >>> fpAbs(x).sort()
10958 FPSort(8, 24)
10959 """
10960 ctx = _get_ctx(ctx)
10961 [a] = _coerce_fp_expr_list([a], ctx)
10963
10964
◆ 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 11033 of file z3py.py.
11033def fpAdd(rm, a, b, ctx=None):
11034 """Create a Z3 floating-point addition expression.
11035
11036 >>> s = FPSort(8, 24)
11037 >>> rm = RNE()
11038 >>> x = FP('x', s)
11039 >>> y = FP('y', s)
11040 >>> fpAdd(rm, x, y)
11041 x + y
11042 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
11043 fpAdd(RTZ(), x, y)
11044 >>> fpAdd(rm, x, y).sort()
11045 FPSort(8, 24)
11046 """
11047 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
11048
11049
◆ 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 11355 of file z3py.py.
11355def fpBVToFP(v, sort, ctx=None):
11356 """Create a Z3 floating-point conversion expression that represents the
11357 conversion from a bit-vector term to a floating-point term.
11358
11359 >>> x_bv = BitVecVal(0x3F800000, 32)
11360 >>> x_fp = fpBVToFP(x_bv, Float32())
11361 >>> x_fp
11362 fpToFP(1065353216)
11363 >>> simplify(x_fp)
11364 1
11365 """
11366 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
11367 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
11368 ctx = _get_ctx(ctx)
11370
11371
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 11080 of file z3py.py.
11080def fpDiv(rm, a, b, ctx=None):
11081 """Create a Z3 floating-point division expression.
11082
11083 >>> s = FPSort(8, 24)
11084 >>> rm = RNE()
11085 >>> x = FP('x', s)
11086 >>> y = FP('y', s)
11087 >>> fpDiv(rm, x, y)
11088 x / y
11089 >>> fpDiv(rm, x, y).sort()
11090 FPSort(8, 24)
11091 """
11092 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
11093
11094
◆ 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 11263 of file z3py.py.
11263def fpEQ(a, b, ctx=None):
11264 """Create the Z3 floating-point expression `fpEQ(other, self)`.
11265
11266 >>> x, y = FPs('x y', FPSort(8, 24))
11267 >>> fpEQ(x, y)
11268 fpEQ(x, y)
11269 >>> fpEQ(x, y).sexpr()
11270 '(fp.eq x y)'
11271 """
11272 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
11273
11274
◆ 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 11287 of file z3py.py.
11287def fpFP(sgn, exp, sig, ctx=None):
11288 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
11289
11290 >>> s = FPSort(8, 24)
11291 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
11292 >>> print(x)
11293 fpFP(1, 127, 4194304)
11294 >>> xv = FPVal(-1.5, s)
11295 >>> print(xv)
11296 -1.5
11297 >>> slvr = Solver()
11298 >>> slvr.add(fpEQ(x, xv))
11299 >>> slvr.check()
11300 sat
11301 >>> xv = FPVal(+1.5, s)
11302 >>> print(xv)
11303 1.5
11304 >>> slvr = Solver()
11305 >>> slvr.add(fpEQ(x, xv))
11306 >>> slvr.check()
11307 unsat
11308 """
11309 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
11310 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
11311 ctx = _get_ctx(ctx)
11312 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
11313 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
11314
11315
◆ 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 11372 of file z3py.py.
11372def fpFPToFP(rm, v, sort, ctx=None):
11373 """Create a Z3 floating-point conversion expression that represents the
11374 conversion from a floating-point term to a floating-point term of different precision.
11375
11376 >>> x_sgl = FPVal(1.0, Float32())
11377 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
11378 >>> x_dbl
11379 fpToFP(RNE(), 1)
11380 >>> simplify(x_dbl)
11381 1
11382 >>> x_dbl.sort()
11383 FPSort(11, 53)
11384 """
11385 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11386 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
11387 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11388 ctx = _get_ctx(ctx)
11390
11391
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 11251 of file z3py.py.
11251def fpGEQ(a, b, ctx=None):
11252 """Create the Z3 floating-point expression `other >= self`.
11253
11254 >>> x, y = FPs('x y', FPSort(8, 24))
11255 >>> fpGEQ(x, y)
11256 x >= y
11257 >>> (x >= y).sexpr()
11258 '(fp.geq x y)'
11259 """
11260 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
11261
11262
◆ 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 11239 of file z3py.py.
11239def fpGT(a, b, ctx=None):
11240 """Create the Z3 floating-point expression `other > self`.
11241
11242 >>> x, y = FPs('x y', FPSort(8, 24))
11243 >>> fpGT(x, y)
11244 x > y
11245 >>> (x > y).sexpr()
11246 '(fp.gt x y)'
11247 """
11248 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
11249
11250
◆ fpInfinity()
| fpInfinity | ( | s, | |
| negative ) |
Create a Z3 floating-point +oo or -oo term.
Definition at line 10827 of file z3py.py.
10827def fpInfinity(s, negative):
10828 """Create a Z3 floating-point +oo or -oo term."""
10829 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10830 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10832
10833
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 11169 of file z3py.py.
11169def fpIsInf(a, ctx=None):
11170 """Create a Z3 floating-point isInfinite expression.
11171
11172 >>> s = FPSort(8, 24)
11173 >>> x = FP('x', s)
11174 >>> fpIsInf(x)
11175 fpIsInf(x)
11176 """
11177 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
11178
11179
◆ 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 11157 of file z3py.py.
11157def fpIsNaN(a, ctx=None):
11158 """Create a Z3 floating-point isNaN expression.
11159
11160 >>> s = FPSort(8, 24)
11161 >>> x = FP('x', s)
11162 >>> y = FP('y', s)
11163 >>> fpIsNaN(x)
11164 fpIsNaN(x)
11165 """
11166 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
11167
11168
◆ 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 11227 of file z3py.py.
11227def fpLEQ(a, b, ctx=None):
11228 """Create the Z3 floating-point expression `other <= self`.
11229
11230 >>> x, y = FPs('x y', FPSort(8, 24))
11231 >>> fpLEQ(x, y)
11232 x <= y
11233 >>> (x <= y).sexpr()
11234 '(fp.leq x y)'
11235 """
11236 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
11237
11238
◆ 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 11215 of file z3py.py.
11215def fpLT(a, b, ctx=None):
11216 """Create the Z3 floating-point expression `other < self`.
11217
11218 >>> x, y = FPs('x y', FPSort(8, 24))
11219 >>> fpLT(x, y)
11220 x < y
11221 >>> (x < y).sexpr()
11222 '(fp.lt x y)'
11223 """
11224 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
11225
11226
◆ 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 11124 of file z3py.py.
11124def fpMax(a, b, ctx=None):
11125 """Create a Z3 floating-point maximum expression.
11126
11127 >>> s = FPSort(8, 24)
11128 >>> rm = RNE()
11129 >>> x = FP('x', s)
11130 >>> y = FP('y', s)
11131 >>> fpMax(x, y)
11132 fpMax(x, y)
11133 >>> fpMax(x, y).sort()
11134 FPSort(8, 24)
11135 """
11136 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
11137
11138
◆ 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 11109 of file z3py.py.
11109def fpMin(a, b, ctx=None):
11110 """Create a Z3 floating-point minimum expression.
11111
11112 >>> s = FPSort(8, 24)
11113 >>> rm = RNE()
11114 >>> x = FP('x', s)
11115 >>> y = FP('y', s)
11116 >>> fpMin(x, y)
11117 fpMin(x, y)
11118 >>> fpMin(x, y).sort()
11119 FPSort(8, 24)
11120 """
11121 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
11122
11123
◆ fpMinusInfinity()
| fpMinusInfinity | ( | s | ) |
◆ fpMinusZero()
| fpMinusZero | ( | s | ) |
Create a Z3 floating-point -0.0 term.
Definition at line 10840 of file z3py.py.
10840def fpMinusZero(s):
10841 """Create a Z3 floating-point -0.0 term."""
10842 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10844
10845
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 11065 of file z3py.py.
11065def fpMul(rm, a, b, ctx=None):
11066 """Create a Z3 floating-point multiplication expression.
11067
11068 >>> s = FPSort(8, 24)
11069 >>> rm = RNE()
11070 >>> x = FP('x', s)
11071 >>> y = FP('y', s)
11072 >>> fpMul(rm, x, y)
11073 x * y
11074 >>> fpMul(rm, x, y).sort()
11075 FPSort(8, 24)
11076 """
11077 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
11078
11079
◆ 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 10787 of file z3py.py.
10787def fpNaN(s):
10788 """Create a Z3 floating-point NaN term.
10789
10790 >>> s = FPSort(8, 24)
10791 >>> set_fpa_pretty(True)
10792 >>> fpNaN(s)
10793 NaN
10794 >>> pb = get_fpa_pretty()
10795 >>> set_fpa_pretty(False)
10796 >>> fpNaN(s)
10797 fpNaN(FPSort(8, 24))
10798 >>> set_fpa_pretty(pb)
10799 """
10800 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10802
10803
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 10965 of file z3py.py.
10965def fpNeg(a, ctx=None):
10966 """Create a Z3 floating-point addition expression.
10967
10968 >>> s = FPSort(8, 24)
10969 >>> rm = RNE()
10970 >>> x = FP('x', s)
10971 >>> fpNeg(x)
10972 -x
10973 >>> fpNeg(x).sort()
10974 FPSort(8, 24)
10975 """
10976 ctx = _get_ctx(ctx)
10977 [a] = _coerce_fp_expr_list([a], ctx)
10979
10980
◆ 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 11275 of file z3py.py.
11275def fpNEQ(a, b, ctx=None):
11276 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
11277
11278 >>> x, y = FPs('x y', FPSort(8, 24))
11279 >>> fpNEQ(x, y)
11280 Not(fpEQ(x, y))
11281 >>> (x != y).sexpr()
11282 '(distinct x y)'
11283 """
11284 return Not(fpEQ(a, b, ctx))
11285
11286
◆ 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 10804 of file z3py.py.
10804def fpPlusInfinity(s):
10805 """Create a Z3 floating-point +oo term.
10806
10807 >>> s = FPSort(8, 24)
10808 >>> pb = get_fpa_pretty()
10809 >>> set_fpa_pretty(True)
10810 >>> fpPlusInfinity(s)
10811 +oo
10812 >>> set_fpa_pretty(False)
10813 >>> fpPlusInfinity(s)
10814 fpPlusInfinity(FPSort(8, 24))
10815 >>> set_fpa_pretty(pb)
10816 """
10817 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10819
10820
◆ 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 11392 of file z3py.py.
11392def fpRealToFP(rm, v, sort, ctx=None):
11393 """Create a Z3 floating-point conversion expression that represents the
11394 conversion from a real term to a floating-point term.
11395
11396 >>> x_r = RealVal(1.5)
11397 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
11398 >>> x_fp
11399 fpToFP(RNE(), 3/2)
11400 >>> simplify(x_fp)
11401 1.5
11402 """
11403 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11404 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
11405 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11406 ctx = _get_ctx(ctx)
11408
11409
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 11095 of file z3py.py.
11095def fpRem(a, b, ctx=None):
11096 """Create a Z3 floating-point remainder expression.
11097
11098 >>> s = FPSort(8, 24)
11099 >>> x = FP('x', s)
11100 >>> y = FP('y', s)
11101 >>> fpRem(x, y)
11102 fpRem(x, y)
11103 >>> fpRem(x, y).sort()
11104 FPSort(8, 24)
11105 """
11106 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
11107
11108
◆ 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 10923 of file z3py.py.
10923def FPs(names, fpsort, ctx=None):
10924 """Return an array of floating-point constants.
10925
10926 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10927 >>> x.sort()
10928 FPSort(8, 24)
10929 >>> x.sbits()
10930 24
10931 >>> x.ebits()
10932 8
10933 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10934 (x + y) * z
10935 """
10936 ctx = _get_ctx(ctx)
10937 if isinstance(names, str):
10938 names = names.split(" ")
10939 return [FP(name, fpsort, ctx) for name in names]
10940
10941
◆ 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 11410 of file z3py.py.
11410def fpSignedToFP(rm, v, sort, ctx=None):
11411 """Create a Z3 floating-point conversion expression that represents the
11412 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
11413
11414 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11415 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
11416 >>> x_fp
11417 fpToFP(RNE(), 4294967291)
11418 >>> simplify(x_fp)
11419 -1.25*(2**2)
11420 """
11421 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11422 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
11423 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11424 ctx = _get_ctx(ctx)
11426
11427
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 10728 of file z3py.py.
10728def FPSort(ebits, sbits, ctx=None):
10729 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10730
10731 >>> Single = FPSort(8, 24)
10732 >>> Double = FPSort(11, 53)
10733 >>> Single
10734 FPSort(8, 24)
10735 >>> x = Const('x', Single)
10736 >>> eq(x, FP('x', FPSort(8, 24)))
10737 True
10738 """
10739 ctx = _get_ctx(ctx)
10741
10742
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 11050 of file z3py.py.
11050def fpSub(rm, a, b, ctx=None):
11051 """Create a Z3 floating-point subtraction expression.
11052
11053 >>> s = FPSort(8, 24)
11054 >>> rm = RNE()
11055 >>> x = FP('x', s)
11056 >>> y = FP('y', s)
11057 >>> fpSub(rm, x, y)
11058 x - y
11059 >>> fpSub(rm, x, y).sort()
11060 FPSort(8, 24)
11061 """
11062 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
11063
11064
◆ 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 11316 of file z3py.py.
11316def fpToFP(a1, a2=None, a3=None, ctx=None):
11317 """Create a Z3 floating-point conversion expression from other term sorts
11318 to floating-point.
11319
11320 From a bit-vector term in IEEE 754-2008 format:
11321 >>> x = FPVal(1.0, Float32())
11322 >>> x_bv = fpToIEEEBV(x)
11323 >>> simplify(fpToFP(x_bv, Float32()))
11324 1
11325
11326 From a floating-point term with different precision:
11327 >>> x = FPVal(1.0, Float32())
11328 >>> x_db = fpToFP(RNE(), x, Float64())
11329 >>> x_db.sort()
11330 FPSort(11, 53)
11331
11332 From a real term:
11333 >>> x_r = RealVal(1.5)
11334 >>> simplify(fpToFP(RNE(), x_r, Float32()))
11335 1.5
11336
11337 From a signed bit-vector term:
11338 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11339 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
11340 -1.25*(2**2)
11341 """
11342 ctx = _get_ctx(ctx)
11343 if is_bv(a1) and is_fp_sort(a2):
11345 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
11347 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
11349 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
11351 else:
11352 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
11353
11354
◆ 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 11446 of file z3py.py.
11446def fpToFPUnsigned(rm, x, s, ctx=None):
11447 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
11448 if z3_debug():
11449 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11450 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
11451 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
11452 ctx = _get_ctx(ctx)
11454
11455
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 11520 of file z3py.py.
11520def fpToIEEEBV(x, ctx=None):
11521 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
11522
11523 The size of the resulting bit-vector is automatically determined.
11524
11525 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
11526 knows only one NaN and it will always produce the same bit-vector representation of
11527 that NaN.
11528
11529 >>> x = FP('x', FPSort(8, 24))
11530 >>> y = fpToIEEEBV(x)
11531 >>> print(is_fp(x))
11532 True
11533 >>> print(is_bv(y))
11534 True
11535 >>> print(is_fp(y))
11536 False
11537 >>> print(is_bv(x))
11538 False
11539 """
11540 if z3_debug():
11541 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
11542 ctx = _get_ctx(ctx)
11544
11545
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 11500 of file z3py.py.
11500def fpToReal(x, ctx=None):
11501 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
11502
11503 >>> x = FP('x', FPSort(8, 24))
11504 >>> y = fpToReal(x)
11505 >>> print(is_fp(x))
11506 True
11507 >>> print(is_real(y))
11508 True
11509 >>> print(is_fp(y))
11510 False
11511 >>> print(is_real(x))
11512 False
11513 """
11514 if z3_debug():
11515 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
11516 ctx = _get_ctx(ctx)
11518
11519
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 11456 of file z3py.py.
11456def fpToSBV(rm, x, s, ctx=None):
11457 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
11458
11459 >>> x = FP('x', FPSort(8, 24))
11460 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
11461 >>> print(is_fp(x))
11462 True
11463 >>> print(is_bv(y))
11464 True
11465 >>> print(is_fp(y))
11466 False
11467 >>> print(is_bv(x))
11468 False
11469 """
11470 if z3_debug():
11471 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11472 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
11473 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
11474 ctx = _get_ctx(ctx)
11476
11477
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 11478 of file z3py.py.
11478def fpToUBV(rm, x, s, ctx=None):
11479 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
11480
11481 >>> x = FP('x', FPSort(8, 24))
11482 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
11483 >>> print(is_fp(x))
11484 True
11485 >>> print(is_bv(y))
11486 True
11487 >>> print(is_fp(y))
11488 False
11489 >>> print(is_bv(x))
11490 False
11491 """
11492 if z3_debug():
11493 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11494 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
11495 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
11496 ctx = _get_ctx(ctx)
11498
11499
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 11428 of file z3py.py.
11428def fpUnsignedToFP(rm, v, sort, ctx=None):
11429 """Create a Z3 floating-point conversion expression that represents the
11430 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
11431
11432 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11433 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
11434 >>> x_fp
11435 fpToFPUnsigned(RNE(), 4294967291)
11436 >>> simplify(x_fp)
11437 1*(2**32)
11438 """
11439 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11440 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
11441 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11442 ctx = _get_ctx(ctx)
11444
11445
◆ 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 10853 of file z3py.py.
10853def FPVal(sig, exp=None, fps=None, ctx=None):
10854 """Return a floating-point value of value `val` and sort `fps`.
10855 If `ctx=None`, then the global context is used.
10856
10857 >>> v = FPVal(20.0, FPSort(8, 24))
10858 >>> v
10859 1.25*(2**4)
10860 >>> print("0x%.8x" % v.exponent_as_long(False))
10861 0x00000004
10862 >>> v = FPVal(2.25, FPSort(8, 24))
10863 >>> v
10864 1.125*(2**1)
10865 >>> v = FPVal(-2.25, FPSort(8, 24))
10866 >>> v
10867 -1.125*(2**1)
10868 >>> FPVal(-0.0, FPSort(8, 24))
10869 -0.0
10870 >>> FPVal(0.0, FPSort(8, 24))
10871 +0.0
10872 >>> FPVal(+0.0, FPSort(8, 24))
10873 +0.0
10874 """
10875 ctx = _get_ctx(ctx)
10876 if is_fp_sort(exp):
10877 fps = exp
10878 exp = None
10879 elif fps is None:
10880 fps = _dflt_fps(ctx)
10881 _z3_assert(is_fp_sort(fps), "sort mismatch")
10882 if exp is None:
10883 exp = 0
10884 val = _to_float_str(sig)
10885 if val == "NaN" or val == "nan":
10886 return fpNaN(fps)
10887 elif val == "-0.0":
10888 return fpMinusZero(fps)
10889 elif val == "0.0" or val == "+0.0":
10890 return fpPlusZero(fps)
10891 elif val == "+oo" or val == "+inf" or val == "+Inf":
10892 return fpPlusInfinity(fps)
10893 elif val == "-oo" or val == "-inf" or val == "-Inf":
10894 return fpMinusInfinity(fps)
10895 else:
10897
10898
◆ fpZero()
| fpZero | ( | s, | |
| negative ) |
Create a Z3 floating-point +0.0 or -0.0 term.
Definition at line 10846 of file z3py.py.
10846def fpZero(s, negative):
10847 """Create a Z3 floating-point +0.0 or -0.0 term."""
10848 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10849 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10851
10852
◆ 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 1910 of file z3py.py.
1910def FreshBool(prefix="b", ctx=None):
1911 """Return a fresh Boolean constant in the given context using the given prefix.
1912
1913 If `ctx=None`, then the global context is used.
1914
1915 >>> b1 = FreshBool()
1916 >>> b2 = FreshBool()
1917 >>> eq(b1, b2)
1918 False
1919 """
1920 ctx = _get_ctx(ctx)
1922
1923
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 1573 of file z3py.py.
1573def FreshConst(sort, prefix="c"):
1574 """Create a fresh constant of a specified sort"""
1575 if z3_debug():
1576 _z3_assert(is_sort(sort), f"Z3 sort expected, got {type(sort)}")
1577 ctx = _get_ctx(sort.ctx)
1579
1580
◆ FreshFunction()
| FreshFunction | ( | * | sig | ) |
Create a new fresh Z3 uninterpreted function with the given sorts.
Definition at line 945 of file z3py.py.
945def FreshFunction(*sig):
946 """Create a new fresh Z3 uninterpreted function with the given sorts.
947 """
948 sig = _get_args(sig)
949 if z3_debug():
950 _z3_assert(len(sig) > 0, "At least two arguments expected")
951 arity = len(sig) - 1
952 rng = sig[arity]
953 if z3_debug():
954 _z3_assert(is_sort(rng), "Z3 sort expected")
955 dom = (z3.Sort * arity)()
956 for i in range(arity):
957 if z3_debug():
958 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
959 dom[i] = sig[i].ast
960 ctx = rng.ctx
962
963
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 3453 of file z3py.py.
3453def FreshInt(prefix="x", ctx=None):
3454 """Return a fresh integer constant in the given context using the given prefix.
3455
3456 >>> x = FreshInt()
3457 >>> y = FreshInt()
3458 >>> eq(x, y)
3459 False
3460 >>> x.sort()
3461 Int
3462 """
3463 ctx = _get_ctx(ctx)
3465
3466
◆ 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 3510 of file z3py.py.
3510def FreshReal(prefix="b", ctx=None):
3511 """Return a fresh real constant in the given context using the given prefix.
3512
3513 >>> x = FreshReal()
3514 >>> y = FreshReal()
3515 >>> eq(x, y)
3516 False
3517 >>> x.sort()
3518 Real
3519 """
3520 ctx = _get_ctx(ctx)
3522
3523
◆ 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 11823 of file z3py.py.
11823def Full(s):
11824 """Create the regular expression that accepts the universal language
11825 >>> e = Full(ReSort(SeqSort(IntSort())))
11826 >>> print(e)
11827 Full(ReSort(Seq(Int)))
11828 >>> e1 = Full(ReSort(StringSort()))
11829 >>> print(e1)
11830 Full(ReSort(String))
11831 """
11832 if isinstance(s, ReSortRef):
11834 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11835
11836
11837
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 922 of file z3py.py.
922def Function(name, *sig):
923 """Create a new Z3 uninterpreted function with the given sorts.
924
925 >>> f = Function('f', IntSort(), IntSort())
926 >>> f(f(0))
927 f(f(0))
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 = (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_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 7344 of file z3py.py.
7344def get_as_array_func(n):
7345 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
7346 if z3_debug():
7347 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
7349
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 10107 of file z3py.py.
10107def get_default_rounding_mode(ctx=None):
10108 """Retrieves the global default rounding mode."""
10109 global _dflt_rounding_mode
10110 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
10111 return RTZ(ctx)
10112 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
10113 return RTN(ctx)
10114 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
10115 return RTP(ctx)
10116 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
10117 return RNE(ctx)
10118 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
10119 return RNA(ctx)
10120
10121
◆ 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 4911 of file z3py.py.
4911def get_map_func(a):
4912 """Return the function declaration associated with a Z3 map array expression.
4913
4914 >>> f = Function('f', IntSort(), IntSort())
4915 >>> b = Array('b', IntSort(), IntSort())
4916 >>> a = Map(f, b)
4917 >>> eq(f, get_map_func(a))
4918 True
4919 >>> get_map_func(a)
4920 f
4921 >>> get_map_func(a)(0)
4922 f(0)
4923 """
4924 if z3_debug():
4925 _z3_assert(is_map(a), "Z3 array map expression expected.")
4926 return FuncDeclRef(
4927 Z3_to_func_decl(
4928 a.ctx_ref(),
4929 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4930 ),
4931 ctx=a.ctx,
4932 )
4933
4934
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 334 of file z3py.py.
334def get_param(name):
335 """Return the value of a Z3 global (or module) parameter
336
337 >>> get_param('nlsat.reorder')
338 'true'
339 """
340 ptr = (ctypes.c_char_p * 1)()
342 r = z3core._to_pystr(ptr[0])
343 return r
344 raise Z3Exception("failed to retrieve value for '%s'" % name)
345
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 1444 of file z3py.py.
1444def get_var_index(a):
1445 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1446
1447 >>> x = Int('x')
1448 >>> y = Int('y')
1449 >>> is_var(x)
1450 False
1451 >>> is_const(x)
1452 True
1453 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1454 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1455 >>> q = ForAll([x, y], f(x, y) == x + y)
1456 >>> q.body()
1457 f(Var(1), Var(0)) == Var(1) + Var(0)
1458 >>> b = q.body()
1459 >>> b.arg(0)
1460 f(Var(1), Var(0))
1461 >>> v1 = b.arg(0).arg(0)
1462 >>> v2 = b.arg(0).arg(1)
1463 >>> v1
1464 Var(1)
1465 >>> v2
1466 Var(0)
1467 >>> get_var_index(v1)
1468 1
1469 >>> get_var_index(v2)
1470 0
1471 """
1472 if z3_debug():
1473 _z3_assert(is_var(a), "Z3 bound variable expected")
1475
1476
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 9613 of file z3py.py.
9613def help_simplify():
9614 """Return a string describing all options available for Z3 `simplify` procedure."""
9615 print(Z3_simplify_get_help(main_ctx().ref()))
9616
9617
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 1490 of file z3py.py.
1490def If(a, b, c, ctx=None):
1491 """Create a Z3 if-then-else expression.
1492
1493 >>> x = Int('x')
1494 >>> y = Int('y')
1495 >>> max = If(x > y, x, y)
1496 >>> max
1497 If(x > y, x, y)
1498 >>> simplify(max)
1499 If(x <= y, y, x)
1500 """
1501 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1502 return Cond(a, b, c, ctx)
1503 else:
1504 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1505 s = BoolSort(ctx)
1506 a = s.cast(a)
1507 b, c = _coerce_exprs(b, c, ctx)
1508 if z3_debug():
1509 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1511
1512
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 1924 of file z3py.py.
1924def Implies(a, b, ctx=None):
1925 """Create a Z3 implies expression.
1926
1927 >>> p, q = Bools('p q')
1928 >>> Implies(p, q)
1929 Implies(p, q)
1930 """
1931 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1932 s = BoolSort(ctx)
1933 a = s.cast(a)
1934 b = s.cast(b)
1936
1937
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
◆ In()
| In | ( | elem, | |
| set ) |
◆ 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 11907 of file z3py.py.
11907def IndexOf(s, substr, offset=None):
11908 """Retrieve the index of substring within a string starting at a specified offset.
11909 >>> simplify(IndexOf("abcabc", "bc", 0))
11910 1
11911 >>> simplify(IndexOf("abcabc", "bc", 2))
11912 4
11913 """
11914 if offset is None:
11915 offset = IntVal(0)
11916 ctx = None
11917 if is_expr(offset):
11918 ctx = offset.ctx
11919 ctx = _get_ctx2(s, substr, ctx)
11920 s = _coerce_seq(s, ctx)
11921 substr = _coerce_seq(substr, ctx)
11922 if _is_int(offset):
11923 offset = IntVal(offset, ctx)
11924 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11925
11926
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 12046 of file z3py.py.
12046def InRe(s, re):
12047 """Create regular expression membership test
12048 >>> re = Union(Re("a"),Re("b"))
12049 >>> print (simplify(InRe("a", re)))
12050 True
12051 >>> print (simplify(InRe("b", re)))
12052 True
12053 >>> print (simplify(InRe("c", re)))
12054 False
12055 """
12056 s = _coerce_seq(s, re.ctx)
12058
12059
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 3414 of file z3py.py.
3414def Int(name, ctx=None):
3415 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3416
3417 >>> x = Int('x')
3418 >>> is_int(x)
3419 True
3420 >>> is_int(x + 1)
3421 True
3422 """
3423 ctx = _get_ctx(ctx)
3425
3426
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 4169 of file z3py.py.
4169def Int2BV(a, num_bits):
4170 """Return the z3 expression Int2BV(a, num_bits).
4171 It is a bit-vector of width num_bits and represents the
4172 modulo of a by 2^num_bits
4173 """
4174 ctx = a.ctx
4176
4177
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 12088 of file z3py.py.
12088def Intersect(*args):
12089 """Create intersection of regular expressions.
12090 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
12091 """
12092 args = _get_args(args)
12093 sz = len(args)
12094 if z3_debug():
12095 _z3_assert(sz > 0, "At least one argument expected.")
12096 arg0 = args[0]
12097 if is_finite_set(arg0):
12098 for a in args[1:]:
12099 if not is_finite_set(a):
12100 raise Z3Exception("All arguments must be regular expressions or finite sets.")
12101 arg0 = arg0 & a
12102 return arg0
12103 if z3_debug():
12104 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
12105 if sz == 1:
12106 return args[0]
12107 ctx = args[0].ctx
12108 v = (Ast * sz)()
12109 for i in range(sz):
12110 v[i] = args[i].as_ast()
12112
12113
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 3427 of file z3py.py.
3427def Ints(names, ctx=None):
3428 """Return a tuple of Integer constants.
3429
3430 >>> x, y, z = Ints('x y z')
3431 >>> Sum(x, y, z)
3432 x + y + z
3433 """
3434 ctx = _get_ctx(ctx)
3435 if isinstance(names, str):
3436 names = names.split(" ")
3437 return [Int(name, ctx) for name in names]
3438
3439
◆ 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 3304 of file z3py.py.
3304def IntSort(ctx=None):
3305 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3306
3307 >>> IntSort()
3308 Int
3309 >>> x = Const('x', IntSort())
3310 >>> is_int(x)
3311 True
3312 >>> x.sort() == IntSort()
3313 True
3314 >>> x.sort() == BoolSort()
3315 False
3316 """
3317 ctx = _get_ctx(ctx)
3319
3320
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 3350 of file z3py.py.
3350def IntVal(val, ctx=None):
3351 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3352
3353 >>> IntVal(1)
3354 1
3355 >>> IntVal("100")
3356 100
3357 """
3358 ctx = _get_ctx(ctx)
3360
3361
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 3440 of file z3py.py.
3440def IntVector(prefix, sz, ctx=None):
3441 """Return a list of integer constants of size `sz`.
3442
3443 >>> X = IntVector('x', 3)
3444 >>> X
3445 [x__0, x__1, x__2]
3446 >>> Sum(X)
3447 x__0 + x__1 + x__2
3448 """
3449 ctx = _get_ctx(ctx)
3450 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3451
3452
◆ 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 2952 of file z3py.py.
2952def is_add(a : Any) -> bool:
2953 """Return `True` if `a` is an expression of the form b + c.
2954
2955 >>> x, y = Ints('x y')
2956 >>> is_add(x + y)
2957 True
2958 >>> is_add(x - y)
2959 False
2960 """
2961 return is_app_of(a, Z3_OP_ADD)
2962
2963
◆ 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 2938 of file z3py.py.
2938def is_algebraic_value(a):
2939 """Return `True` if `a` is an algebraic value of sort Real.
2940
2941 >>> is_algebraic_value(RealVal("3/5"))
2942 False
2943 >>> n = simplify(Sqrt(2))
2944 >>> n
2945 1.4142135623?
2946 >>> is_algebraic_value(n)
2947 True
2948 """
2949 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2950
2951
◆ 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 1760 of file z3py.py.
1760def is_and(a : Any) -> bool:
1761 """Return `True` if `a` is a Z3 and expression.
1762
1763 >>> p, q = Bools('p q')
1764 >>> is_and(And(p, q))
1765 True
1766 >>> is_and(Or(p, q))
1767 False
1768 """
1769 return is_app_of(a, Z3_OP_AND)
1770
1771
◆ 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 1374 of file z3py.py.
1374def is_app(a):
1375 """Return `True` if `a` is a Z3 function application.
1376
1377 Note that, constants are function applications with 0 arguments.
1378
1379 >>> a = Int('a')
1380 >>> is_app(a)
1381 True
1382 >>> is_app(a + 1)
1383 True
1384 >>> is_app(IntSort())
1385 False
1386 >>> is_app(1)
1387 False
1388 >>> is_app(IntVal(1))
1389 True
1390 >>> x = Int('x')
1391 >>> is_app(ForAll(x, x >= 0))
1392 False
1393 """
1394 if not isinstance(a, ExprRef):
1395 return False
1396 k = _ast_kind(a.ctx, a)
1397 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1398
1399
Referenced by _mk_quantifier(), ExprRef.arg(), ExprRef.children(), ExprRef.decl(), is_app_of(), is_const(), ExprRef.kind(), Lambda(), ExprRef.num_args(), RecAddDefinition(), and ExprRef.update().
◆ 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 1477 of file z3py.py.
1477def is_app_of(a, k):
1478 """Return `True` if `a` is an application of the given kind `k`.
1479
1480 >>> x = Int('x')
1481 >>> n = x + 1
1482 >>> is_app_of(n, Z3_OP_ADD)
1483 True
1484 >>> is_app_of(n, Z3_OP_MUL)
1485 False
1486 """
1487 return is_app(a) and a.kind() == k
1488
1489
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 2825 of file z3py.py.
2825def is_arith(a):
2826 """Return `True` if `a` is an arithmetical expression.
2827
2828 >>> x = Int('x')
2829 >>> is_arith(x)
2830 True
2831 >>> is_arith(x + 1)
2832 True
2833 >>> is_arith(1)
2834 False
2835 >>> is_arith(IntVal(1))
2836 True
2837 >>> y = Real('y')
2838 >>> is_arith(y)
2839 True
2840 >>> is_arith(y + 1)
2841 True
2842 """
2843 return isinstance(a, ArithRef)
2844
2845
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 2513 of file z3py.py.
2513def is_arith_sort(s : Any) -> bool:
2514 """Return `True` if s is an arithmetical sort (type).
2515
2516 >>> is_arith_sort(IntSort())
2517 True
2518 >>> is_arith_sort(RealSort())
2519 True
2520 >>> is_arith_sort(BoolSort())
2521 False
2522 >>> n = Int('x') + 1
2523 >>> is_arith_sort(n.sort())
2524 True
2525 """
2526 return isinstance(s, ArithSortRef)
2527
2528
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 4846 of file z3py.py.
4846def is_array(a : Any) -> bool:
4847 """Return `True` if `a` is a Z3 array expression.
4848
4849 >>> a = Array('a', IntSort(), IntSort())
4850 >>> is_array(a)
4851 True
4852 >>> is_array(Store(a, 0, 1))
4853 True
4854 >>> is_array(a[0])
4855 False
4856 """
4857 return isinstance(a, ArrayRef)
4858
4859
◆ 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 7339 of file z3py.py.
7339def is_as_array(n):
7340 """Return true if n is a Z3 expression of the form (_ as-array f)."""
7342
7343
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 482 of file z3py.py.
482def is_ast(a : Any) -> bool:
483 """Return `True` if `a` is an AST node.
484
485 >>> is_ast(10)
486 False
487 >>> is_ast(IntVal(10))
488 True
489 >>> is_ast(Int('x'))
490 True
491 >>> is_ast(BoolSort())
492 True
493 >>> is_ast(Function('f', IntSort(), IntSort()))
494 True
495 >>> is_ast("x")
496 False
497 >>> is_ast(Solver())
498 False
499 """
500 return isinstance(a, AstRef)
501
502
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 1710 of file z3py.py.
1710def is_bool(a : Any) -> bool:
1711 """Return `True` if `a` is a Z3 Boolean expression.
1712
1713 >>> p = Bool('p')
1714 >>> is_bool(p)
1715 True
1716 >>> q = Bool('q')
1717 >>> is_bool(And(p, q))
1718 True
1719 >>> x = Real('x')
1720 >>> is_bool(x)
1721 False
1722 >>> is_bool(x == 0)
1723 True
1724 """
1725 return isinstance(a, BoolRef)
1726
1727
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 4117 of file z3py.py.
4117def is_bv(a):
4118 """Return `True` if `a` is a Z3 bit-vector expression.
4119
4120 >>> b = BitVec('b', 32)
4121 >>> is_bv(b)
4122 True
4123 >>> is_bv(b + 10)
4124 True
4125 >>> is_bv(Int('x'))
4126 False
4127 """
4128 return isinstance(a, BitVecRef)
4129
4130
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 3644 of file z3py.py.
3644def is_bv_sort(s):
3645 """Return True if `s` is a Z3 bit-vector sort.
3646
3647 >>> is_bv_sort(BitVecSort(32))
3648 True
3649 >>> is_bv_sort(IntSort())
3650 False
3651 """
3652 return isinstance(s, BitVecSortRef)
3653
3654
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 4131 of file z3py.py.
4131def is_bv_value(a):
4132 """Return `True` if `a` is a Z3 bit-vector numeral value.
4133
4134 >>> b = BitVec('b', 32)
4135 >>> is_bv_value(b)
4136 False
4137 >>> b = BitVecVal(10, 32)
4138 >>> b
4139 10
4140 >>> is_bv_value(b)
4141 True
4142 """
4143 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4144
4145
◆ 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 1400 of file z3py.py.
1400def is_const(a):
1401 """Return `True` if `a` is Z3 constant/variable expression.
1402
1403 >>> a = Int('a')
1404 >>> is_const(a)
1405 True
1406 >>> is_const(a + 1)
1407 False
1408 >>> is_const(1)
1409 False
1410 >>> is_const(IntVal(1))
1411 True
1412 >>> x = Int('x')
1413 >>> is_const(ForAll(x, x >= 0))
1414 False
1415 """
1416 return is_app(a) and a.num_args() == 0
1417
1418
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 4860 of file z3py.py.
4860def is_const_array(a):
4861 """Return `True` if `a` is a Z3 constant array.
4862
4863 >>> a = K(IntSort(), 10)
4864 >>> is_const_array(a)
4865 True
4866 >>> a = Array('a', IntSort(), IntSort())
4867 >>> is_const_array(a)
4868 False
4869 """
4870 return is_app_of(a, Z3_OP_CONST_ARRAY)
4871
4872
◆ 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 4902 of file z3py.py.
4902def is_default(a):
4903 """Return `True` if `a` is a Z3 default array expression.
4904 >>> d = Default(K(IntSort(), 10))
4905 >>> is_default(d)
4906 True
4907 """
4908 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4909
4910
◆ 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 1818 of file z3py.py.
1818def is_distinct(a : Any) -> bool:
1819 """Return `True` if `a` is a Z3 distinct expression.
1820
1821 >>> x, y, z = Ints('x y z')
1822 >>> is_distinct(x == y)
1823 False
1824 >>> is_distinct(Distinct(x, y, z))
1825 True
1826 """
1827 return is_app_of(a, Z3_OP_DISTINCT)
1828
1829
◆ 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 2988 of file z3py.py.
2988def is_div(a : Any) -> bool:
2989 """Return `True` if `a` is an expression of the form b / c.
2990
2991 >>> x, y = Reals('x y')
2992 >>> is_div(x / y)
2993 True
2994 >>> is_div(x + y)
2995 False
2996 >>> x, y = Ints('x y')
2997 >>> is_div(x / y)
2998 False
2999 >>> is_idiv(x / y)
3000 True
3001 """
3002 return is_app_of(a, Z3_OP_DIV)
3003
3004
◆ 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 1808 of file z3py.py.
1808def is_eq(a : Any) -> bool:
1809 """Return `True` if `a` is a Z3 equality expression.
1810
1811 >>> x, y = Ints('x y')
1812 >>> is_eq(x == y)
1813 True
1814 """
1815 return is_app_of(a, Z3_OP_EQ)
1816
1817
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 1351 of file z3py.py.
1351def is_expr(a):
1352 """Return `True` if `a` is a Z3 expression.
1353
1354 >>> a = Int('a')
1355 >>> is_expr(a)
1356 True
1357 >>> is_expr(a + 1)
1358 True
1359 >>> is_expr(IntSort())
1360 False
1361 >>> is_expr(1)
1362 False
1363 >>> is_expr(IntVal(1))
1364 True
1365 >>> x = Int('x')
1366 >>> is_expr(ForAll(x, x >= 0))
1367 True
1368 >>> is_expr(FPVal(1.0))
1369 True
1370 """
1371 return isinstance(a, ExprRef)
1372
1373
Referenced by _coerce_expr_list(), _coerce_expr_merge(), _coerce_exprs(), _mk_quantifier(), _py2expr(), ArithSortRef.cast(), BitVecSortRef.cast(), FiniteSetSortRef.cast(), SortRef.cast(), Cbrt(), Concat(), is_var(), K(), MultiPattern(), Sqrt(), ExprRef.update(), DatatypeRef.update_field(), 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 1746 of file z3py.py.
1746def is_false(a : Any) -> bool:
1747 """Return `True` if `a` is the Z3 false expression.
1748
1749 >>> p = Bool('p')
1750 >>> is_false(p)
1751 False
1752 >>> is_false(False)
1753 False
1754 >>> is_false(BoolVal(False))
1755 True
1756 """
1757 return is_app_of(a, Z3_OP_FALSE)
1758
1759
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 8458 of file z3py.py.
8458def is_finite_domain(a):
8459 """Return `True` if `a` is a Z3 finite-domain expression.
8460
8461 >>> s = FiniteDomainSort('S', 100)
8462 >>> b = Const('b', s)
8463 >>> is_finite_domain(b)
8464 True
8465 >>> is_finite_domain(Int('x'))
8466 False
8467 """
8468 return isinstance(a, FiniteDomainRef)
8469
8470
◆ 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 8435 of file z3py.py.
8435def is_finite_domain_sort(s):
8436 """Return True if `s` is a Z3 finite-domain sort.
8437
8438 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
8439 True
8440 >>> is_finite_domain_sort(IntSort())
8441 False
8442 """
8443 return isinstance(s, FiniteDomainSortRef)
8444
8445
◆ 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 8512 of file z3py.py.
8512def is_finite_domain_value(a):
8513 """Return `True` if `a` is a Z3 finite-domain value.
8514
8515 >>> s = FiniteDomainSort('S', 100)
8516 >>> b = Const('b', s)
8517 >>> is_finite_domain_value(b)
8518 False
8519 >>> b = FiniteDomainVal(10, s)
8520 >>> b
8521 10
8522 >>> is_finite_domain_value(b)
8523 True
8524 """
8525 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
8526
8527
◆ is_finite_set()
| is_finite_set | ( | a | ) |
Return True if a is a Z3 finite set expression. >>> s = FiniteSetSort(IntSort()) >>> is_finite_set(FiniteSetEmpty(s)) True >>> is_finite_set(IntVal(1)) False
Definition at line 5344 of file z3py.py.
5344def is_finite_set(a):
5345 """Return True if a is a Z3 finite set expression.
5346 >>> s = FiniteSetSort(IntSort())
5347 >>> is_finite_set(FiniteSetEmpty(s))
5348 True
5349 >>> is_finite_set(IntVal(1))
5350 False
5351 """
5352 return isinstance(a, FiniteSetRef)
5353
5354
Referenced by IsMember(), IsSubset(), SetAdd(), SetDel(), SetDifference(), SetIntersect(), and SetUnion().
◆ is_finite_set_sort()
| is_finite_set_sort | ( | s | ) |
Return True if s is a Z3 finite set sort. >>> is_finite_set_sort(FiniteSetSort(IntSort())) True >>> is_finite_set_sort(IntSort()) False
Definition at line 5355 of file z3py.py.
5355def is_finite_set_sort(s):
5356 """Return True if s is a Z3 finite set sort.
5357 >>> is_finite_set_sort(FiniteSetSort(IntSort()))
5358 True
5359 >>> is_finite_set_sort(IntSort())
5360 False
5361 """
5362 return isinstance(s, FiniteSetSortRef)
5363
5364
Referenced by EmptySet().
◆ 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 10699 of file z3py.py.
10699def is_fp(a):
10700 """Return `True` if `a` is a Z3 floating-point expression.
10701
10702 >>> b = FP('b', FPSort(8, 24))
10703 >>> is_fp(b)
10704 True
10705 >>> is_fp(b + 1.0)
10706 True
10707 >>> is_fp(Int('x'))
10708 False
10709 """
10710 return isinstance(a, FPRef)
10711
10712
◆ 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 10273 of file z3py.py.
10273def is_fp_sort(s):
10274 """Return True if `s` is a Z3 floating-point sort.
10275
10276 >>> is_fp_sort(FPSort(8, 24))
10277 True
10278 >>> is_fp_sort(IntSort())
10279 False
10280 """
10281 return isinstance(s, FPSortRef)
10282
10283
◆ 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 10713 of file z3py.py.
10713def is_fp_value(a):
10714 """Return `True` if `a` is a Z3 floating-point numeral value.
10715
10716 >>> b = FP('b', FPSort(8, 24))
10717 >>> is_fp_value(b)
10718 False
10719 >>> b = FPVal(1.0, FPSort(8, 24))
10720 >>> b
10721 1
10722 >>> is_fp_value(b)
10723 True
10724 """
10725 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10726
10727
◆ 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 10533 of file z3py.py.
10533def is_fprm(a):
10534 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
10535
10536 >>> rm = RNE()
10537 >>> is_fprm(rm)
10538 True
10539 >>> rm = 1.0
10540 >>> is_fprm(rm)
10541 False
10542 """
10543 return isinstance(a, FPRMRef)
10544
10545
◆ 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 10284 of file z3py.py.
10284def is_fprm_sort(s):
10285 """Return True if `s` is a Z3 floating-point rounding mode sort.
10286
10287 >>> is_fprm_sort(FPSort(8, 24))
10288 False
10289 >>> is_fprm_sort(RNE().sort())
10290 True
10291 """
10292 return isinstance(s, FPRMSortRef)
10293
10294# FP Expressions
10295
10296
◆ is_fprm_value()
| is_fprm_value | ( | a | ) |
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.
Definition at line 10546 of file z3py.py.
10546def is_fprm_value(a):
10547 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
10548 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
10549
10550# FP Numerals
10551
10552
◆ 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 909 of file z3py.py.
909def is_func_decl(a):
910 """Return `True` if `a` is a Z3 function declaration.
911
912 >>> f = Function('f', IntSort(), IntSort())
913 >>> is_func_decl(f)
914 True
915 >>> x = Real('x')
916 >>> is_func_decl(x)
917 False
918 """
919 return isinstance(a, FuncDeclRef)
920
921
Referenced by Map(), DatatypeRef.update_field(), 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 3053 of file z3py.py.
3053def is_ge(a : Any) -> bool:
3054 """Return `True` if `a` is an expression of the form b >= c.
3055
3056 >>> x, y = Ints('x y')
3057 >>> is_ge(x >= y)
3058 True
3059 >>> is_ge(x == y)
3060 False
3061 """
3062 return is_app_of(a, Z3_OP_GE)
3063
3064
◆ 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 3065 of file z3py.py.
3065def is_gt(a : Any) -> bool:
3066 """Return `True` if `a` is an expression of the form b > c.
3067
3068 >>> x, y = Ints('x y')
3069 >>> is_gt(x > y)
3070 True
3071 >>> is_gt(x == y)
3072 False
3073 """
3074 return is_app_of(a, Z3_OP_GT)
3075
3076
◆ 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 3005 of file z3py.py.
3005def is_idiv(a : Any) -> bool:
3006 """Return `True` if `a` is an expression of the form b div c.
3007
3008 >>> x, y = Ints('x y')
3009 >>> is_idiv(x / y)
3010 True
3011 >>> is_idiv(x + y)
3012 False
3013 """
3014 return is_app_of(a, Z3_OP_IDIV)
3015
3016
◆ 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 1784 of file z3py.py.
1784def is_implies(a : Any) -> bool:
1785 """Return `True` if `a` is a Z3 implication expression.
1786
1787 >>> p, q = Bools('p q')
1788 >>> is_implies(Implies(p, q))
1789 True
1790 >>> is_implies(And(p, q))
1791 False
1792 """
1793 return is_app_of(a, Z3_OP_IMPLIES)
1794
1795
◆ 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 2846 of file z3py.py.
2846def is_int(a) -> bool:
2847 """Return `True` if `a` is an integer expression.
2848
2849 >>> x = Int('x')
2850 >>> is_int(x + 1)
2851 True
2852 >>> is_int(1)
2853 False
2854 >>> is_int(IntVal(1))
2855 True
2856 >>> y = Real('y')
2857 >>> is_int(y)
2858 False
2859 >>> is_int(y + 1)
2860 False
2861 """
2862 return is_arith(a) and a.is_int()
2863
2864
◆ 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 2892 of file z3py.py.
2892def is_int_value(a):
2893 """Return `True` if `a` is an integer value of sort Int.
2894
2895 >>> is_int_value(IntVal(1))
2896 True
2897 >>> is_int_value(1)
2898 False
2899 >>> is_int_value(Int('x'))
2900 False
2901 >>> n = Int('x') + 1
2902 >>> n
2903 x + 1
2904 >>> n.arg(1)
2905 1
2906 >>> is_int_value(n.arg(1))
2907 True
2908 >>> is_int_value(RealVal("1/3"))
2909 False
2910 >>> is_int_value(RealVal(1))
2911 False
2912 """
2913 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2914
2915
◆ 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 3077 of file z3py.py.
3077def is_is_int(a : Any) -> bool:
3078 """Return `True` if `a` is an expression of the form IsInt(b).
3079
3080 >>> x = Real('x')
3081 >>> is_is_int(IsInt(x))
3082 True
3083 >>> is_is_int(x)
3084 False
3085 """
3086 return is_app_of(a, Z3_OP_IS_INT)
3087
3088
◆ 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 4873 of file z3py.py.
4873def is_K(a):
4874 """Return `True` if `a` is a Z3 constant array.
4875
4876 >>> a = K(IntSort(), 10)
4877 >>> is_K(a)
4878 True
4879 >>> a = Array('a', IntSort(), IntSort())
4880 >>> is_K(a)
4881 False
4882 """
4883 return is_app_of(a, Z3_OP_CONST_ARRAY)
4884
4885
◆ 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 3029 of file z3py.py.
3029def is_le(a : Any) -> bool:
3030 """Return `True` if `a` is an expression of the form b <= c.
3031
3032 >>> x, y = Ints('x y')
3033 >>> is_le(x <= y)
3034 True
3035 >>> is_le(x < y)
3036 False
3037 """
3038 return is_app_of(a, Z3_OP_LE)
3039
3040
◆ 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 3041 of file z3py.py.
3041def is_lt(a : Any) -> bool:
3042 """Return `True` if `a` is an expression of the form b < c.
3043
3044 >>> x, y = Ints('x y')
3045 >>> is_lt(x < y)
3046 True
3047 >>> is_lt(x == y)
3048 False
3049 """
3050 return is_app_of(a, Z3_OP_LT)
3051
3052
◆ 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 4886 of file z3py.py.
4886def is_map(a):
4887 """Return `True` if `a` is a Z3 map array expression.
4888
4889 >>> f = Function('f', IntSort(), IntSort())
4890 >>> b = Array('b', IntSort(), IntSort())
4891 >>> a = Map(f, b)
4892 >>> a
4893 Map(f, b)
4894 >>> is_map(a)
4895 True
4896 >>> is_map(b)
4897 False
4898 """
4899 return is_app_of(a, Z3_OP_ARRAY_MAP)
4900
4901
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 3017 of file z3py.py.
3017def is_mod(a : Any) -> bool:
3018 """Return `True` if `a` is an expression of the form b % c.
3019
3020 >>> x, y = Ints('x y')
3021 >>> is_mod(x % y)
3022 True
3023 >>> is_mod(x + y)
3024 False
3025 """
3026 return is_app_of(a, Z3_OP_MOD)
3027
3028
◆ 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 2964 of file z3py.py.
2964def is_mul(a : Any) -> bool:
2965 """Return `True` if `a` is an expression of the form b * c.
2966
2967 >>> x, y = Ints('x y')
2968 >>> is_mul(x * y)
2969 True
2970 >>> is_mul(x - y)
2971 False
2972 """
2973 return is_app_of(a, Z3_OP_MUL)
2974
2975
◆ 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 1796 of file z3py.py.
1796def is_not(a : Any) -> bool:
1797 """Return `True` if `a` is a Z3 not expression.
1798
1799 >>> p = Bool('p')
1800 >>> is_not(p)
1801 False
1802 >>> is_not(Not(p))
1803 True
1804 """
1805 return is_app_of(a, Z3_OP_NOT)
1806
1807
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 1772 of file z3py.py.
1772def is_or(a : Any) -> bool:
1773 """Return `True` if `a` is a Z3 or expression.
1774
1775 >>> p, q = Bools('p q')
1776 >>> is_or(Or(p, q))
1777 True
1778 >>> is_or(And(p, q))
1779 False
1780 """
1781 return is_app_of(a, Z3_OP_OR)
1782
1783
◆ 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 2072 of file z3py.py.
2072def is_pattern(a):
2073 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
2074
2075 >>> f = Function('f', IntSort(), IntSort())
2076 >>> x = Int('x')
2077 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2078 >>> q
2079 ForAll(x, f(x) == 0)
2080 >>> q.num_patterns()
2081 1
2082 >>> is_pattern(q.pattern(0))
2083 True
2084 >>> q.pattern(0)
2085 f(Var(0))
2086 """
2087 return isinstance(a, PatternRef)
2088
2089
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 9454 of file z3py.py.
9454def is_probe(p):
9455 """Return `True` if `p` is a Z3 probe.
9456
9457 >>> is_probe(Int('x'))
9458 False
9459 >>> is_probe(Probe('memory'))
9460 True
9461 """
9462 return isinstance(p, Probe)
9463
9464
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 2322 of file z3py.py.
2322def is_quantifier(a):
2323 """Return `True` if `a` is a Z3 quantifier.
2324
2325 >>> f = Function('f', IntSort(), IntSort())
2326 >>> x = Int('x')
2327 >>> q = ForAll(x, f(x) == 0)
2328 >>> is_quantifier(q)
2329 True
2330 >>> is_quantifier(f(x))
2331 False
2332 """
2333 return isinstance(a, QuantifierRef)
2334
2335
◆ 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 2916 of file z3py.py.
2916def is_rational_value(a):
2917 """Return `True` if `a` is rational value of sort Real.
2918
2919 >>> is_rational_value(RealVal(1))
2920 True
2921 >>> is_rational_value(RealVal("3/5"))
2922 True
2923 >>> is_rational_value(IntVal(1))
2924 False
2925 >>> is_rational_value(1)
2926 False
2927 >>> n = Real('x') + 1
2928 >>> n.arg(1)
2929 1
2930 >>> is_rational_value(n.arg(1))
2931 True
2932 >>> is_rational_value(Real('x'))
2933 False
2934 """
2935 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2936
2937
◆ 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 2865 of file z3py.py.
2865def is_real(a):
2866 """Return `True` if `a` is a real expression.
2867
2868 >>> x = Int('x')
2869 >>> is_real(x + 1)
2870 False
2871 >>> y = Real('y')
2872 >>> is_real(y)
2873 True
2874 >>> is_real(y + 1)
2875 True
2876 >>> is_real(1)
2877 False
2878 >>> is_real(RealVal(1))
2879 True
2880 """
2881 return is_arith(a) and a.is_real()
2882
2883
◆ 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 5133 of file z3py.py.
5133def is_select(a):
5134 """Return `True` if `a` is a Z3 array select application.
5135
5136 >>> a = Array('a', IntSort(), IntSort())
5137 >>> is_select(a)
5138 False
5139 >>> i = Int('i')
5140 >>> is_select(a[i])
5141 True
5142 """
5143 return is_app_of(a, Z3_OP_SELECT)
5144
5145
◆ 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 11724 of file z3py.py.
11724def is_seq(a):
11725 """Return `True` if `a` is a Z3 sequence expression.
11726 >>> print (is_seq(Unit(IntVal(0))))
11727 True
11728 >>> print (is_seq(StringVal("abc")))
11729 True
11730 """
11731 return isinstance(a, SeqRef)
11732
11733
◆ 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 682 of file z3py.py.
682def is_sort(s : Any) -> bool:
683 """Return `True` if `s` is a Z3 sort.
684
685 >>> is_sort(IntSort())
686 True
687 >>> is_sort(Int('x'))
688 False
689 >>> is_expr(Int('x'))
690 True
691 """
692 return isinstance(s, SortRef)
693
694
Referenced by _valid_accessor(), ArraySort(), CreateDatatypes(), CreatePolymorphicDatatype(), 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 5146 of file z3py.py.
5146def is_store(a):
5147 """Return `True` if `a` is a Z3 array store application.
5148
5149 >>> a = Array('a', IntSort(), IntSort())
5150 >>> is_store(a)
5151 False
5152 >>> is_store(Store(a, 0, 1))
5153 True
5154 """
5155 return is_app_of(a, Z3_OP_STORE)
5156
◆ 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 11734 of file z3py.py.
11734def is_string(a: Any) -> bool:
11735 """Return `True` if `a` is a Z3 string expression.
11736 >>> print (is_string(StringVal("ab")))
11737 True
11738 """
11739 return isinstance(a, SeqRef) and a.is_string()
11740
11741
◆ 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 11742 of file z3py.py.
11742def is_string_value(a: Any) -> bool:
11743 """return 'True' if 'a' is a Z3 string constant expression.
11744 >>> print (is_string_value(StringVal("a")))
11745 True
11746 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11747 False
11748 """
11749 return isinstance(a, SeqRef) and a.is_string_value()
11750
◆ 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 2976 of file z3py.py.
2976def is_sub(a : Any) -> bool:
2977 """Return `True` if `a` is an expression of the form b - c.
2978
2979 >>> x, y = Ints('x y')
2980 >>> is_sub(x - y)
2981 True
2982 >>> is_sub(x + y)
2983 False
2984 """
2985 return is_app_of(a, Z3_OP_SUB)
2986
2987
◆ 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 3104 of file z3py.py.
3104def is_to_int(a : Any) -> bool:
3105 """Return `True` if `a` is an expression of the form ToInt(b).
3106
3107 >>> x = Real('x')
3108 >>> n = ToInt(x)
3109 >>> n
3110 ToInt(x)
3111 >>> is_to_int(n)
3112 True
3113 >>> is_to_int(x)
3114 False
3115 """
3116 return is_app_of(a, Z3_OP_TO_INT)
3117
3118
◆ 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 3089 of file z3py.py.
3089def is_to_real(a : Any) -> bool:
3090 """Return `True` if `a` is an expression of the form ToReal(b).
3091
3092 >>> x = Int('x')
3093 >>> n = ToReal(x)
3094 >>> n
3095 ToReal(x)
3096 >>> is_to_real(n)
3097 True
3098 >>> is_to_real(x)
3099 False
3100 """
3101 return is_app_of(a, Z3_OP_TO_REAL)
3102
3103
◆ 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 1728 of file z3py.py.
1728def is_true(a : Any) -> bool:
1729 """Return `True` if `a` is the Z3 true expression.
1730
1731 >>> p = Bool('p')
1732 >>> is_true(p)
1733 False
1734 >>> is_true(simplify(p == p))
1735 True
1736 >>> x = Real('x')
1737 >>> is_true(x == 0)
1738 False
1739 >>> # True is a Python Boolean expression
1740 >>> is_true(True)
1741 False
1742 """
1743 return is_app_of(a, Z3_OP_TRUE)
1744
1745
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 1419 of file z3py.py.
1419def is_var(a):
1420 """Return `True` if `a` is variable.
1421
1422 Z3 uses de-Bruijn indices for representing bound variables in
1423 quantifiers.
1424
1425 >>> x = Int('x')
1426 >>> is_var(x)
1427 False
1428 >>> is_const(x)
1429 True
1430 >>> f = Function('f', IntSort(), IntSort())
1431 >>> # Z3 replaces x with bound variables when ForAll is executed.
1432 >>> q = ForAll(x, f(x) == x)
1433 >>> b = q.body()
1434 >>> b
1435 f(Var(0)) == Var(0)
1436 >>> b.arg(1)
1437 Var(0)
1438 >>> is_var(b.arg(1))
1439 True
1440 """
1441 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1442
1443
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 3562 of file z3py.py.
3562def IsInt(a):
3563 """ Return the Z3 predicate IsInt(a).
3564
3565 >>> x = Real('x')
3566 >>> IsInt(x + "1/2")
3567 IsInt(x + 1/2)
3568 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3569 [x = 1/2]
3570 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3571 no solution
3572 """
3573 if z3_debug():
3574 _z3_assert(a.is_real(), "Z3 real expression expected.")
3575 ctx = a.ctx
3577
3578
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 5270 of file z3py.py.
5270def IsMember(e, s):
5271 """ Check if e is a member of set s
5272 >>> a = Const('a', SetSort(IntSort()))
5273 >>> IsMember(1, a)
5274 a[1]
5275 """
5276 ctx = _ctx_from_ast_arg_list([s, e])
5277 e = _py2expr(e, ctx)
5278 if is_finite_set(s):
5279 return FiniteSetIsMember(e, s)
5281
5282
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 5283 of file z3py.py.
5283def IsSubset(a, b):
5284 """ Check if a is a subset of b
5285 >>> a = Const('a', SetSort(IntSort()))
5286 >>> b = Const('b', SetSort(IntSort()))
5287 >>> IsSubset(a, b)
5288 subset(a, b)
5289 """
5290 ctx = _ctx_from_ast_arg_list([a, b])
5291 if is_finite_set(a):
5292 return FiniteSetIsSubset(a, b)
5294
5295
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 5081 of file z3py.py.
5081def K(dom, v):
5082 """Return a Z3 constant array expression.
5083
5084 >>> a = K(IntSort(), 10)
5085 >>> a
5086 K(Int, 10)
5087 >>> a.sort()
5088 Array(Int, Int)
5089 >>> i = Int('i')
5090 >>> a[i]
5091 K(Int, 10)[i]
5092 >>> simplify(a[i])
5093 10
5094 """
5095 if z3_debug():
5096 _z3_assert(is_sort(dom), "Z3 sort expected")
5097 ctx = dom.ctx
5098 if not is_expr(v):
5099 v = _py2expr(v, ctx)
5101
5102
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 2410 of file z3py.py.
2410def Lambda(vs, body):
2411 """Create a Z3 lambda expression.
2412
2413 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2414 >>> mem0 = Array('mem0', IntSort(), IntSort())
2415 >>> lo, hi, e, i = Ints('lo hi e i')
2416 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2417 >>> mem1
2418 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2419 """
2420 ctx = body.ctx
2421 if is_app(vs):
2422 vs = [vs]
2423 num_vars = len(vs)
2424 _vs = (Ast * num_vars)()
2425 for i in range(num_vars):
2426 # TODO: Check if is constant
2427 _vs[i] = vs[i].as_ast()
2429
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 11927 of file z3py.py.
11927def LastIndexOf(s, substr):
11928 """Retrieve the last index of substring within a string"""
11929 ctx = None
11930 ctx = _get_ctx2(s, substr, ctx)
11931 s = _coerce_seq(s, ctx)
11932 substr = _coerce_seq(substr, ctx)
11934
11935
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 11936 of file z3py.py.
11936def Length(s):
11937 """Obtain the length of a sequence 's'
11938 >>> l = Length(StringVal("abc"))
11939 >>> simplify(l)
11940 3
11941 """
11942 s = _coerce_seq(s)
11944
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 12164 of file z3py.py.
12164def Loop(re, lo, hi=0):
12165 """Create the regular expression accepting between a lower and upper bound repetitions
12166 >>> re = Loop(Re("a"), 1, 3)
12167 >>> print(simplify(InRe("aa", re)))
12168 True
12169 >>> print(simplify(InRe("aaaa", re)))
12170 False
12171 >>> print(simplify(InRe("", re)))
12172 False
12173 """
12174 if z3_debug():
12175 _z3_assert(is_expr(re), "expression expected")
12177
12178
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 4495 of file z3py.py.
4495def LShR(a, b):
4496 """Create the Z3 expression logical right shift.
4497
4498 Use the operator >> for the arithmetical right shift.
4499
4500 >>> x, y = BitVecs('x y', 32)
4501 >>> LShR(x, y)
4502 LShR(x, y)
4503 >>> (x >> y).sexpr()
4504 '(bvashr x y)'
4505 >>> LShR(x, y).sexpr()
4506 '(bvlshr x y)'
4507 >>> BitVecVal(4, 3)
4508 4
4509 >>> BitVecVal(4, 3).as_signed_long()
4510 -4
4511 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4512 -2
4513 >>> simplify(BitVecVal(4, 3) >> 1)
4514 6
4515 >>> simplify(LShR(BitVecVal(4, 3), 1))
4516 2
4517 >>> simplify(BitVecVal(2, 3) >> 1)
4518 1
4519 >>> simplify(LShR(BitVecVal(2, 3), 1))
4520 1
4521 """
4522 _check_bv_args(a, b)
4523 a, b = _coerce_exprs(a, b)
4525
4526
◆ 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 266 of file z3py.py.
266def main_ctx() -> Context:
267 """Return a reference to the global Z3 context.
268
269 >>> x = Real('x')
270 >>> x.ctx == main_ctx()
271 True
272 >>> c = Context()
273 >>> c == main_ctx()
274 False
275 >>> x2 = Real('x', c)
276 >>> x2.ctx == c
277 True
278 >>> eq(x, x2)
279 False
280 """
281 global _main_ctx
282 if _main_ctx is None:
283 _main_ctx = Context()
284 return _main_ctx
285
286
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 5058 of file z3py.py.
5058def Map(f, *args):
5059 """Return a Z3 map array expression.
5060
5061 >>> f = Function('f', IntSort(), IntSort(), IntSort())
5062 >>> a1 = Array('a1', IntSort(), IntSort())
5063 >>> a2 = Array('a2', IntSort(), IntSort())
5064 >>> b = Map(f, a1, a2)
5065 >>> b
5066 Map(f, a1, a2)
5067 >>> prove(b[0] == f(a1[0], a2[0]))
5068 proved
5069 """
5070 args = _get_args(args)
5071 if z3_debug():
5072 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
5073 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
5074 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
5075 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
5076 _args, sz = _to_ast_array(args)
5077 ctx = f.ctx
5079
5080
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 7331 of file z3py.py.
7331def Model(ctx=None, eval = {}):
7332 ctx = _get_ctx(ctx)
7333 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
7334 for k, v in eval.items():
7335 mdl.update_value(k, v)
7336 return mdl
7337
7338
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 2090 of file z3py.py.
2090def MultiPattern(*args):
2091 """Create a Z3 multi-pattern using the given expressions `*args`
2092
2093 >>> f = Function('f', IntSort(), IntSort())
2094 >>> g = Function('g', IntSort(), IntSort())
2095 >>> x = Int('x')
2096 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
2097 >>> q
2098 ForAll(x, f(x) != g(x))
2099 >>> q.num_patterns()
2100 1
2101 >>> is_pattern(q.pattern(0))
2102 True
2103 >>> q.pattern(0)
2104 MultiPattern(f(Var(0)), g(Var(0)))
2105 """
2106 if z3_debug():
2107 _z3_assert(len(args) > 0, "At least one argument expected")
2108 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2109 ctx = args[0].ctx
2110 args, sz = _to_ast_array(args)
2112
2113
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 1954 of file z3py.py.
1954def Not(a, ctx=None):
1955 """Create a Z3 not expression or probe.
1956
1957 >>> p = Bool('p')
1958 >>> Not(Not(p))
1959 Not(Not(p))
1960 >>> simplify(Not(Not(p)))
1961 p
1962 """
1963 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1964 if is_probe(a):
1965 # Not is also used to build probes
1967 else:
1968 s = BoolSort(ctx)
1969 a = s.cast(a)
1971
1972
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().
◆ num_simplifiers()
| num_simplifiers | ( | ctx = None | ) |
Return the number of simplifiers supported by the given context.
Definition at line 8928 of file z3py.py.
8928def num_simplifiers(ctx=None):
8929 """Return the number of simplifiers supported by the given context."""
8931
8932
unsigned Z3_API Z3_get_num_simplifiers(Z3_context c)
Return the number of builtin simplifiers available in Z3.
◆ on_clause_eh()
| on_clause_eh | ( | ctx, | |
| p, | |||
| n, | |||
| dep, | |||
| clause ) |
Definition at line 12254 of file z3py.py.
12254def on_clause_eh(ctx, p, n, dep, clause):
12255 onc = _my_hacky_class
12256 p = _to_expr_ref(to_Ast(p), onc.ctx)
12257 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
12258 deps = [dep[i] for i in range(n)]
12259 onc.on_clause(p, deps, clause)
12260
◆ 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 12129 of file z3py.py.
12129def Option(re):
12130 """Create the regular expression that optionally accepts the argument.
12131 >>> re = Option(Re("a"))
12132 >>> print(simplify(InRe("a", re)))
12133 True
12134 >>> print(simplify(InRe("", re)))
12135 True
12136 >>> print(simplify(InRe("aa", re)))
12137 False
12138 """
12139 if z3_debug():
12140 _z3_assert(is_expr(re), "expression expected")
12142
12143
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 2021 of file z3py.py.
2021def Or(*args):
2022 """Create a Z3 or-expression or or-probe.
2023
2024 >>> p, q, r = Bools('p q r')
2025 >>> Or(p, q, r)
2026 Or(p, q, r)
2027 >>> P = BoolVector('p', 5)
2028 >>> Or(P)
2029 Or(p__0, p__1, p__2, p__3, p__4)
2030 """
2031 last_arg = None
2032 if len(args) > 0:
2033 last_arg = args[len(args) - 1]
2034 if isinstance(last_arg, Context):
2035 ctx = args[len(args) - 1]
2036 args = args[:len(args) - 1]
2037 elif len(args) == 1 and isinstance(args[0], AstVector):
2038 ctx = args[0].ctx
2039 args = [a for a in args[0]]
2040 else:
2041 ctx = None
2042 args = _get_args(args)
2043 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
2044 if z3_debug():
2045 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
2046 if _has_probe(args):
2047 return _probe_or(args, ctx)
2048 else:
2049 args = _coerce_expr_list(args, ctx)
2050 _args, sz = _to_ast_array(args)
2052
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 9147 of file z3py.py.
9147def OrElse(*ts, **ks):
9148 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
9149
9150 >>> x = Int('x')
9151 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
9152 >>> # Tactic split-clause fails if there is no clause in the given goal.
9153 >>> t(x == 0)
9154 [[x == 0]]
9155 >>> t(Or(x == 0, x == 1))
9156 [[x == 0], [x == 1]]
9157 """
9158 if z3_debug():
9159 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9160 ctx = ks.get("ctx", None)
9161 num = len(ts)
9162 r = ts[0]
9163 for i in range(num - 1):
9164 r = _or_else(r, ts[i + 1], ctx)
9165 return r
9166
9167
◆ 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 9168 of file z3py.py.
9168def ParOr(*ts, **ks):
9169 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
9170
9171 >>> x = Int('x')
9172 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
9173 >>> t(x + 1 == 2)
9174 [[x == 1]]
9175 """
9176 if z3_debug():
9177 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9178 ctx = _get_ctx(ks.get("ctx", None))
9179 ts = [_to_tactic(t, ctx) for t in ts]
9180 sz = len(ts)
9181 _args = (TacticObj * sz)()
9182 for i in range(sz):
9183 _args[i] = ts[i].tactic
9185
9186
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 10083 of file z3py.py.
10083def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
10084 """Parse a file in SMT 2.0 format using the given sorts and decls.
10085
10086 This function is similar to parse_smt2_string().
10087 """
10088 ctx = _get_ctx(ctx)
10089 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
10090 dsz, dnames, ddecls = _dict2darray(decls, ctx)
10091 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
10092
10093
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 10062 of file z3py.py.
10062def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
10063 """Parse a string in SMT 2.0 format using the given sorts and decls.
10064
10065 The arguments sorts and decls are Python dictionaries used to initialize
10066 the symbol table used for the SMT 2.0 parser.
10067
10068 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
10069 [x > 0, x < 10]
10070 >>> x, y = Ints('x y')
10071 >>> f = Function('f', IntSort(), IntSort())
10072 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
10073 [x + f(y) > 0]
10074 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
10075 [a > 0]
10076 """
10077 ctx = _get_ctx(ctx)
10078 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
10079 dsz, dnames, ddecls = _dict2darray(decls, ctx)
10080 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
10081
10082
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 9187 of file z3py.py.
9187def ParThen(t1, t2, ctx=None):
9188 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
9189 The subgoals are processed in parallel.
9190
9191 >>> x, y = Ints('x y')
9192 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
9193 >>> t(And(Or(x == 1, x == 2), y == x + 1))
9194 [[x == 1, y == 2], [x == 2, y == 3]]
9195 """
9196 t1 = _to_tactic(t1, ctx)
9197 t2 = _to_tactic(t2, ctx)
9198 if z3_debug():
9199 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9201
9202
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 9839 of file z3py.py.
9839def PbEq(args, k, ctx=None):
9840 """Create a Pseudo-Boolean equality k constraint.
9841
9842 >>> a, b, c = Bools('a b c')
9843 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9844 """
9845 _z3_check_cint_overflow(k, "k")
9846 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9848
9849
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 9828 of file z3py.py.
9828def PbGe(args, k):
9829 """Create a Pseudo-Boolean inequality k constraint.
9830
9831 >>> a, b, c = Bools('a b c')
9832 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9833 """
9834 _z3_check_cint_overflow(k, "k")
9835 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9837
9838
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 9817 of file z3py.py.
9817def PbLe(args, k):
9818 """Create a Pseudo-Boolean inequality k constraint.
9819
9820 >>> a, b, c = Bools('a b c')
9821 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9822 """
9823 _z3_check_cint_overflow(k, "k")
9824 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9826
9827
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 12114 of file z3py.py.
12114def Plus(re):
12115 """Create the regular expression accepting one or more repetitions of argument.
12116 >>> re = Plus(Re("a"))
12117 >>> print(simplify(InRe("aa", re)))
12118 True
12119 >>> print(simplify(InRe("ab", re)))
12120 False
12121 >>> print(simplify(InRe("", re)))
12122 False
12123 """
12124 if z3_debug():
12125 _z3_assert(is_expr(re), "expression expected")
12127
12128
◆ 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 11843 of file z3py.py.
11843def PrefixOf(a, b):
11844 """Check if 'a' is a prefix of 'b'
11845 >>> s1 = PrefixOf("ab", "abc")
11846 >>> simplify(s1)
11847 True
11848 >>> s2 = PrefixOf("bc", "abc")
11849 >>> simplify(s2)
11850 False
11851 """
11852 ctx = _get_ctx2(a, b)
11853 a = _coerce_seq(a, ctx)
11854 b = _coerce_seq(b, ctx)
11856
11857
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 9483 of file z3py.py.
9483def probe_description(name, ctx=None):
9484 """Return a short description for the probe named `name`.
9485
9486 >>> d = probe_description('memory')
9487 """
9488 ctx = _get_ctx(ctx)
9490
9491
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 9472 of file z3py.py.
9472def probes(ctx=None):
9473 """Return a list of all available probes in Z3.
9474
9475 >>> l = probes()
9476 >>> l.count('memory') == 1
9477 True
9478 """
9479 ctx = _get_ctx(ctx)
9481
9482
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 9724 of file z3py.py.
9724def Product(*args):
9725 """Create the product of the Z3 expressions.
9726
9727 >>> a, b, c = Ints('a b c')
9728 >>> Product(a, b, c)
9729 a*b*c
9730 >>> Product([a, b, c])
9731 a*b*c
9732 >>> A = IntVector('a', 5)
9733 >>> Product(A)
9734 a__0*a__1*a__2*a__3*a__4
9735 """
9736 args = _get_args(args)
9737 if len(args) == 0:
9738 return 1
9739 ctx = _ctx_from_ast_arg_list(args)
9740 if ctx is None:
9741 return _reduce(lambda a, b: a * b, args, 1)
9742 args = _coerce_expr_list(args, ctx)
9743 if is_bv(args[0]):
9744 return _reduce(lambda a, b: a * b, args, 1)
9745 else:
9746 _args, sz = _to_ast_array(args)
9748
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 12419 of file z3py.py.
12419def PropagateFunction(name, *sig):
12420 """Create a function that gets tracked by user propagator.
12421 Every term headed by this function symbol is tracked.
12422 If a term is fixed and the fixed callback is registered a
12423 callback is invoked that the term headed by this function is fixed.
12424 """
12425 sig = _get_args(sig)
12426 if z3_debug():
12427 _z3_assert(len(sig) > 0, "At least two arguments expected")
12428 arity = len(sig) - 1
12429 rng = sig[arity]
12430 if z3_debug():
12431 _z3_assert(is_sort(rng), "Z3 sort expected")
12432 dom = (Sort * arity)()
12433 for i in range(arity):
12434 if z3_debug():
12435 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
12436 dom[i] = sig[i].ast
12437 ctx = rng.ctx
12438 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
12439
12440
12441
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 9911 of file z3py.py.
9911def prove(claim, show=False, **keywords):
9912 """Try to prove the given claim.
9913
9914 This is a simple function for creating demonstrations. It tries to prove
9915 `claim` by showing the negation is unsatisfiable.
9916
9917 >>> p, q = Bools('p q')
9918 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9919 proved
9920 """
9921 if z3_debug():
9922 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9923 s = Solver()
9924 s.set(**keywords)
9925 s.add(Not(claim))
9926 if show:
9927 print(s)
9928 r = s.check()
9929 if r == unsat:
9930 print("proved")
9931 elif r == unknown:
9932 print("failed to prove")
9933 print(s.model())
9934 else:
9935 print("counterexample")
9936 print(s.model())
9937
9938
◆ 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 3401 of file z3py.py.
3401def Q(a, b, ctx=None):
3402 """Return a Z3 rational a/b.
3403
3404 If `ctx=None`, then the global context is used.
3405
3406 >>> Q(3,5)
3407 3/5
3408 >>> Q(3,5).sort()
3409 Real
3410 """
3411 return simplify(RatVal(a, b, ctx=ctx))
3412
3413
◆ 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 12179 of file z3py.py.
12179def Range(lo, hi, ctx=None):
12180 """Create the range regular expression over two sequences of length 1
12181 >>> range = Range("a","z")
12182 >>> print(simplify(InRe("b", range)))
12183 True
12184 >>> print(simplify(InRe("bb", range)))
12185 False
12186 """
12187 lo = _coerce_seq(lo, ctx)
12188 hi = _coerce_seq(hi, ctx)
12189 if z3_debug():
12190 _z3_assert(is_expr(lo), "expression expected")
12191 _z3_assert(is_expr(hi), "expression expected")
12193
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. Note: Division by zero (b == 0) is allowed in Z3 symbolic expressions. Z3 can reason about such expressions symbolically. >>> RatVal(3,5) 3/5 >>> RatVal(3,5).sort() Real
Definition at line 3381 of file z3py.py.
3381def RatVal(a, b, ctx=None):
3382 """Return a Z3 rational a/b.
3383
3384 If `ctx=None`, then the global context is used.
3385
3386 Note: Division by zero (b == 0) is allowed in Z3 symbolic expressions.
3387 Z3 can reason about such expressions symbolically.
3388
3389 >>> RatVal(3,5)
3390 3/5
3391 >>> RatVal(3,5).sort()
3392 Real
3393 """
3394 if z3_debug():
3395 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3396 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3397 # Division by 0 is intentionally allowed - Z3 handles it symbolically
3398 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3399
3400
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 12007 of file z3py.py.
12007def Re(s, ctx=None):
12008 """The regular expression that accepts sequence 's'
12009 >>> s1 = Re("ab")
12010 >>> s2 = Re(StringVal("ab"))
12011 >>> s3 = Re(Unit(BoolVal(True)))
12012 """
12013 s = _coerce_seq(s, ctx)
12015
12016
12017# Regular expressions
12018
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 3467 of file z3py.py.
3467def Real(name, ctx=None):
3468 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3469
3470 >>> x = Real('x')
3471 >>> is_real(x)
3472 True
3473 >>> is_real(x + 1)
3474 True
3475 """
3476 ctx = _get_ctx(ctx)
3478
3479
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 3480 of file z3py.py.
3480def Reals(names, ctx=None):
3481 """Return a tuple of real constants.
3482
3483 >>> x, y, z = Reals('x y z')
3484 >>> Sum(x, y, z)
3485 x + y + z
3486 >>> Sum(x, y, z).sort()
3487 Real
3488 """
3489 ctx = _get_ctx(ctx)
3490 if isinstance(names, str):
3491 names = names.split(" ")
3492 return [Real(name, ctx) for name in names]
3493
3494
◆ 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 3321 of file z3py.py.
3321def RealSort(ctx=None):
3322 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3323
3324 >>> RealSort()
3325 Real
3326 >>> x = Const('x', RealSort())
3327 >>> is_real(x)
3328 True
3329 >>> is_int(x)
3330 False
3331 >>> x.sort() == RealSort()
3332 True
3333 """
3334 ctx = _get_ctx(ctx)
3336
3337
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 3362 of file z3py.py.
3362def RealVal(val, ctx=None):
3363 """Return a Z3 real value.
3364
3365 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3366 If `ctx=None`, then the global context is used.
3367
3368 >>> RealVal(1)
3369 1
3370 >>> RealVal(1).sort()
3371 Real
3372 >>> RealVal("3/5")
3373 3/5
3374 >>> RealVal("1.5")
3375 3/2
3376 """
3377 ctx = _get_ctx(ctx)
3379
3380
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 1596 of file z3py.py.
1596def RealVar(idx: int, ctx=None) -> ExprRef:
1597 """
1598 Create a real free variable. Free variables are used to create quantified formulas.
1599 They are also used to create polynomials.
1600
1601 >>> RealVar(0)
1602 Var(0)
1603 """
1604 return Var(idx, RealSort(ctx))
1605
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 1606 of file z3py.py.
1606def RealVarVector(n: int, ctx= None):
1607 """
1608 Create a list of Real free variables.
1609 The variables have ids: 0, 1, ..., n-1
1610
1611 >>> x0, x1, x2, x3 = RealVarVector(4)
1612 >>> x2
1613 Var(2)
1614 """
1615 return [RealVar(i, ctx) for i in range(n)]
1616
◆ 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 3495 of file z3py.py.
3495def RealVector(prefix, sz, ctx=None):
3496 """Return a list of real constants of size `sz`.
3497
3498 >>> X = RealVector('x', 3)
3499 >>> X
3500 [x__0, x__1, x__2]
3501 >>> Sum(X)
3502 x__0 + x__1 + x__2
3503 >>> Sum(X).sort()
3504 Real
3505 """
3506 ctx = _get_ctx(ctx)
3507 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3508
3509
◆ 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 986 of file z3py.py.
986def RecAddDefinition(f, args, body):
987 """Set the body of a recursive function.
988 Recursive definitions can be simplified if they are applied to ground
989 arguments.
990 >>> ctx = Context()
991 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
992 >>> n = Int('n', ctx)
993 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
994 >>> simplify(fac(5))
995 120
996 >>> s = Solver(ctx=ctx)
997 >>> s.add(fac(n) < 3)
998 >>> s.check()
999 sat
1000 >>> s.model().eval(fac(5))
1001 120
1002 """
1003 if is_app(args):
1004 args = [args]
1005 ctx = body.ctx
1006 args = _get_args(args)
1007 n = len(args)
1008 _args = (Ast * n)()
1009 for i in range(n):
1010 _args[i] = args[i].ast
1011 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
1012
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 968 of file z3py.py.
968def RecFunction(name, *sig):
969 """Create a new Z3 recursive with the given sorts."""
970 sig = _get_args(sig)
971 if z3_debug():
972 _z3_assert(len(sig) > 0, "At least two arguments expected")
973 arity = len(sig) - 1
974 rng = sig[arity]
975 if z3_debug():
976 _z3_assert(is_sort(rng), "Z3 sort expected")
977 dom = (Sort * arity)()
978 for i in range(arity):
979 if z3_debug():
980 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
981 dom[i] = sig[i].ast
982 ctx = rng.ctx
983 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
984
985
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 9236 of file z3py.py.
9236def Repeat(t, max=4294967295, ctx=None):
9237 """Return a tactic that keeps applying `t` until the goal is not modified anymore
9238 or the maximum number of iterations `max` is reached.
9239
9240 >>> x, y = Ints('x y')
9241 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
9242 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
9243 >>> r = t(c)
9244 >>> for subgoal in r: print(subgoal)
9245 [x == 0, y == 0, x > y]
9246 [x == 0, y == 1, x > y]
9247 [x == 1, y == 0, x > y]
9248 [x == 1, y == 1, x > y]
9249 >>> t = Then(t, Tactic('propagate-values'))
9250 >>> t(c)
9251 [[x == 1, y == 0]]
9252 """
9253 t = _to_tactic(t, ctx)
9255
9256
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 4617 of file z3py.py.
4617def RepeatBitVec(n, a):
4618 """Return an expression representing `n` copies of `a`.
4619
4620 >>> x = BitVec('x', 8)
4621 >>> n = RepeatBitVec(4, x)
4622 >>> n
4623 RepeatBitVec(4, x)
4624 >>> n.size()
4625 32
4626 >>> v0 = BitVecVal(10, 4)
4627 >>> print("%.x" % v0.as_long())
4628 a
4629 >>> v = simplify(RepeatBitVec(4, v0))
4630 >>> v.size()
4631 16
4632 >>> print("%.x" % v.as_long())
4633 aaaa
4634 """
4635 if z3_debug():
4636 _z3_assert(_is_int(n), "First argument must be an integer")
4637 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4639
4640
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 11892 of file z3py.py.
11892def Replace(s, src, dst):
11893 """Replace the first occurrence of 'src' by 'dst' in 's'
11894 >>> r = Replace("aaa", "a", "b")
11895 >>> simplify(r)
11896 "baa"
11897 """
11898 ctx = _get_ctx2(dst, s)
11899 if ctx is None and is_expr(src):
11900 ctx = src.ctx
11901 src = _coerce_seq(src, ctx)
11902 dst = _coerce_seq(dst, ctx)
11903 s = _coerce_seq(s, ctx)
11904 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11905
11906
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 322 of file z3py.py.
322def reset_params() -> None:
323 """Reset all global (or module) parameters.
324 """
326
327
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 12026 of file z3py.py.
12026def ReSort(s):
12027 if is_ast(s):
12029 if s is None or isinstance(s, Context):
12030 ctx = _get_ctx(s)
12032 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
12033
12034
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 4527 of file z3py.py.
4527def RotateLeft(a, b):
4528 """Return an expression representing `a` rotated to the left `b` times.
4529
4530 >>> a, b = BitVecs('a b', 16)
4531 >>> RotateLeft(a, b)
4532 RotateLeft(a, b)
4533 >>> simplify(RotateLeft(a, 0))
4534 a
4535 >>> simplify(RotateLeft(a, 16))
4536 a
4537 """
4538 _check_bv_args(a, b)
4539 a, b = _coerce_exprs(a, b)
4541
4542
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 4543 of file z3py.py.
4543def RotateRight(a, b):
4544 """Return an expression representing `a` rotated to the right `b` times.
4545
4546 >>> a, b = BitVecs('a b', 16)
4547 >>> RotateRight(a, b)
4548 RotateRight(a, b)
4549 >>> simplify(RotateRight(a, 0))
4550 a
4551 >>> simplify(RotateRight(a, 16))
4552 a
4553 """
4554 _check_bv_args(a, b)
4555 a, b = _coerce_exprs(a, b)
4557
4558
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 5042 of file z3py.py.
5042def Select(a, *args):
5043 """Return a Z3 select array expression.
5044
5045 >>> a = Array('a', IntSort(), IntSort())
5046 >>> i = Int('i')
5047 >>> Select(a, i)
5048 a[i]
5049 >>> eq(Select(a, i), a[i])
5050 True
5051 """
5052 args = _get_args(args)
5053 if z3_debug():
5054 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
5055 return a[args]
5056
5057
◆ SeqFoldLeft()
| SeqFoldLeft | ( | f, | |
| a, | |||
| s ) |
Definition at line 11959 of file z3py.py.
11959def SeqFoldLeft(f, a, s):
11960 ctx = _get_ctx2(f, s)
11961 s = _coerce_seq(s, ctx)
11962 a = _py2expr(a)
11964
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 11965 of file z3py.py.
11965def SeqFoldLeftI(f, i, a, s):
11966 ctx = _get_ctx2(f, s)
11967 s = _coerce_seq(s, ctx)
11968 a = _py2expr(a)
11969 i = _py2expr(i)
11970 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11971
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 11945 of file z3py.py.
11945def SeqMap(f, s):
11946 """Map function 'f' over sequence 's'"""
11947 ctx = _get_ctx2(f, s)
11948 s = _coerce_seq(s, ctx)
11950
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 11951 of file z3py.py.
11951def SeqMapI(f, i, s):
11952 """Map function 'f' over sequence 's' at index 'i'"""
11953 ctx = _get_ctx2(f, s)
11954 s = _coerce_seq(s, ctx)
11955 if not is_expr(i):
11956 i = _py2expr(i)
11958
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 11592 of file z3py.py.
11592def SeqSort(s):
11593 """Create a sequence sort over elements provided in the argument
11594 >>> s = SeqSort(IntSort())
11595 >>> s == Unit(IntVal(1)).sort()
11596 True
11597 """
11599
11600
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 10131 of file z3py.py.
10131def set_default_rounding_mode(rm, ctx=None):
10132 global _dflt_rounding_mode
10133 if is_fprm_value(rm):
10134 _dflt_rounding_mode = rm.kind()
10135 else:
10136 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
10137 _dflt_rounding_mode = rm
10138
10139
◆ 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 298 of file z3py.py.
298def set_param(*args, **kws):
299 """Set Z3 global (or module) parameters.
300
301 >>> set_param(precision=10)
302 """
303 if z3_debug():
304 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
305 new_kws = {}
306 for k in kws:
307 v = kws[k]
308 if not set_pp_option(k, v):
309 new_kws[k] = v
310 for key in new_kws:
311 value = new_kws[key]
312 Z3_global_param_set(str(key).upper(), _to_param_value(value))
313 prev = None
314 for a in args:
315 if prev is None:
316 prev = a
317 else:
318 Z3_global_param_set(str(prev), _to_param_value(a))
319 prev = None
320
321
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 5221 of file z3py.py.
5221def SetAdd(s, e):
5222 """ Add element e to set s
5223 >>> a = Const('a', SetSort(IntSort()))
5224 >>> SetAdd(a, 1)
5225 Store(a, 1, True)
5226 """
5227 ctx = _ctx_from_ast_arg_list([s, e])
5228 e = _py2expr(e, ctx)
5229 if is_finite_set(s):
5230 return FiniteSetSingleton(e) | s
5232
5233
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 5247 of file z3py.py.
5247def SetComplement(s):
5248 """ The complement of set s
5249 >>> a = Const('a', SetSort(IntSort()))
5250 >>> SetComplement(a)
5251 complement(a)
5252 """
5253 ctx = s.ctx
5255
5256
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 5234 of file z3py.py.
5234def SetDel(s, e):
5235 """ Remove element e to set s
5236 >>> a = Const('a', SetSort(IntSort()))
5237 >>> SetDel(a, 1)
5238 Store(a, 1, False)
5239 """
5240 ctx = _ctx_from_ast_arg_list([s, e])
5241 e = _py2expr(e, ctx)
5242 if is_finite_set(s):
5243 return s - FiniteSetSingleton(e)
5245
5246
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 5257 of file z3py.py.
5257def SetDifference(a, b):
5258 """ The set difference of a and b
5259 >>> a = Const('a', SetSort(IntSort()))
5260 >>> b = Const('b', SetSort(IntSort()))
5261 >>> SetDifference(a, b)
5262 setminus(a, b)
5263 """
5264 ctx = _ctx_from_ast_arg_list([a, b])
5265 if is_finite_set(a):
5266 return FiniteSetDifference(a, b)
5268
5269
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
◆ 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 5205 of file z3py.py.
5205def SetIntersect(*args):
5206 """ Take the union of sets
5207 >>> a = Const('a', SetSort(IntSort()))
5208 >>> b = Const('b', SetSort(IntSort()))
5209 >>> SetIntersect(a, b)
5210 intersection(a, b)
5211 """
5212 args = _get_args(args)
5213 ctx = _ctx_from_ast_arg_list(args)
5214 if len(args) > 0 and is_finite_set(args[0]):
5215 from functools import reduce
5216 return reduce(FiniteSetIntersect, args)
5217 _args, sz = _to_ast_array(args)
5219
5220
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 5189 of file z3py.py.
5189def SetUnion(*args):
5190 """ Take the union of sets
5191 >>> a = Const('a', SetSort(IntSort()))
5192 >>> b = Const('b', SetSort(IntSort()))
5193 >>> SetUnion(a, b)
5194 union(a, b)
5195 """
5196 args = _get_args(args)
5197 if len(args) > 0 and is_finite_set(args[0]):
5198 from functools import reduce
5199 return reduce(FiniteSetUnion, args)
5200 ctx = _ctx_from_ast_arg_list(args)
5201 _args, sz = _to_ast_array(args)
5203
5204
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 4559 of file z3py.py.
4559def SignExt(n, a):
4560 """Return a bit-vector expression with `n` extra sign-bits.
4561
4562 >>> x = BitVec('x', 16)
4563 >>> n = SignExt(8, x)
4564 >>> n.size()
4565 24
4566 >>> n
4567 SignExt(8, x)
4568 >>> n.sort()
4569 BitVec(24)
4570 >>> v0 = BitVecVal(2, 2)
4571 >>> v0
4572 2
4573 >>> v0.size()
4574 2
4575 >>> v = simplify(SignExt(6, v0))
4576 >>> v
4577 254
4578 >>> v.size()
4579 8
4580 >>> print("%.x" % v.as_long())
4581 fe
4582 """
4583 if z3_debug():
4584 _z3_assert(_is_int(n), "First argument must be an integer")
4585 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4587
4588
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 8130 of file z3py.py.
8130def SimpleSolver(ctx=None, logFile=None):
8131 """Return a simple general purpose solver with limited amount of preprocessing.
8132
8133 >>> s = SimpleSolver()
8134 >>> x = Int('x')
8135 >>> s.add(x > 0)
8136 >>> s.check()
8137 sat
8138 """
8139 ctx = _get_ctx(ctx)
8141
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
◆ simplifier_description()
| simplifier_description | ( | name, | |
| ctx = None ) |
Return the description of the simplifier identified by name.
Definition at line 8938 of file z3py.py.
8938def simplifier_description(name, ctx=None):
8939 """Return the description of the simplifier identified by name."""
8941
8942
Z3_string Z3_API Z3_simplifier_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the simplifier with the given name.
◆ simplifier_name()
| simplifier_name | ( | i, | |
| ctx = None ) |
Return the name of the i-th simplifier supported by the given context.
Definition at line 8933 of file z3py.py.
8933def simplifier_name(i, ctx=None):
8934 """Return the name of the i-th simplifier supported by the given context."""
8936
8937
Z3_string Z3_API Z3_get_simplifier_name(Z3_context c, unsigned i)
Return the name of the idx simplifier.
◆ 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 9588 of file z3py.py.
9588def simplify(a, *arguments, **keywords):
9589 """Simplify the expression `a` using the given options.
9590
9591 This function has many options. Use `help_simplify` to obtain the complete list.
9592
9593 >>> x = Int('x')
9594 >>> y = Int('y')
9595 >>> simplify(x + 1 + y + x + 1)
9596 2 + 2*x + y
9597 >>> simplify((x + 1)*(y + 1), som=True)
9598 1 + x + y + x*y
9599 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9600 And(Not(x == y), Not(x == 1), Not(y == 1))
9601 >>> simplify(And(x == 0, y == 1), elim_and=True)
9602 Not(Or(Not(x == 0), Not(y == 1)))
9603 """
9604 if z3_debug():
9605 _z3_assert(is_expr(a), "Z3 expression expected")
9606 if len(arguments) > 0 or len(keywords) > 0:
9607 p = args2params(arguments, keywords, a.ctx)
9609 else:
9611
9612
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 9618 of file z3py.py.
9618def simplify_param_descrs():
9619 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9621
9622
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
◆ Singleton()
| Singleton | ( | elem | ) |
Create a singleton finite set containing elem. >>> Singleton(IntVal(1)) set.singleton(1)
Definition at line 5403 of file z3py.py.
5403def Singleton(elem):
5404 """Create a singleton finite set containing elem.
5405 >>> Singleton(IntVal(1))
5406 set.singleton(1)
5407 """
5408 ctx = elem.ctx
5410
5411
Z3_ast Z3_API Z3_mk_finite_set_singleton(Z3_context c, Z3_ast elem)
Create a singleton finite set.
Referenced by FiniteSetSortRef.cast().
◆ 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 9850 of file z3py.py.
9850def solve(*args, **keywords):
9851 """Solve the constraints `*args`.
9852
9853 This is a simple function for creating demonstrations. It creates a solver,
9854 configure it using the options in `keywords`, adds the constraints
9855 in `args`, and invokes check.
9856
9857 >>> a = Int('a')
9858 >>> solve(a > 0, a < 2)
9859 [a = 1]
9860 """
9861 show = keywords.pop("show", False)
9862 s = Solver()
9863 s.set(**keywords)
9864 s.add(*args)
9865 if show:
9866 print(s)
9867 r = s.check()
9868 if r == unsat:
9869 print("no solution")
9870 elif r == unknown:
9871 print("failed to solve")
9872 try:
9873 print(s.model())
9874 except Z3Exception:
9875 return
9876 else:
9877 print(s.model())
9878
9879
◆ 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 9880 of file z3py.py.
9880def solve_using(s, *args, **keywords):
9881 """Solve the constraints `*args` using solver `s`.
9882
9883 This is a simple function for creating demonstrations. It is similar to `solve`,
9884 but it uses the given solver `s`.
9885 It configures solver `s` using the options in `keywords`, adds the constraints
9886 in `args`, and invokes check.
9887 """
9888 show = keywords.pop("show", False)
9889 if z3_debug():
9890 _z3_assert(isinstance(s, Solver), "Solver object expected")
9891 s.set(**keywords)
9892 s.add(*args)
9893 if show:
9894 print("Problem:")
9895 print(s)
9896 r = s.check()
9897 if r == unsat:
9898 print("no solution")
9899 elif r == unknown:
9900 print("failed to solve")
9901 try:
9902 print(s.model())
9903 except Z3Exception:
9904 return
9905 else:
9906 if show:
9907 print("Solution:")
9908 print(s.model())
9909
9910
◆ 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 8109 of file z3py.py.
8109def SolverFor(logic, ctx=None, logFile=None):
8110 """Create a solver customized for the given logic.
8111
8112 The parameter `logic` is a string. It should be contains
8113 the name of a SMT-LIB logic.
8114 See http://www.smtlib.org/ for the name of all available logics.
8115
8116 >>> s = SolverFor("QF_LIA")
8117 >>> x = Int('x')
8118 >>> s.add(x > 0)
8119 >>> s.add(x < 2)
8120 >>> s.check()
8121 sat
8122 >>> s.model()
8123 [x = 1]
8124 """
8125 ctx = _get_ctx(ctx)
8126 logic = to_symbol(logic)
8128
8129
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 3579 of file z3py.py.
3579def Sqrt(a, ctx=None):
3580 """ Return a Z3 expression which represents the square root of a.
3581
3582 >>> x = Real('x')
3583 >>> Sqrt(x)
3584 x**(1/2)
3585 """
3586 if not is_expr(a):
3587 ctx = _get_ctx(ctx)
3588 a = RealVal(a, ctx)
3589 return a ** "1/2"
3590
3591
◆ 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 4474 of file z3py.py.
4474def SRem(a, b):
4475 """Create the Z3 expression signed remainder.
4476
4477 Use the operator % for signed modulus, and URem() for unsigned remainder.
4478
4479 >>> x = BitVec('x', 32)
4480 >>> y = BitVec('y', 32)
4481 >>> SRem(x, y)
4482 SRem(x, y)
4483 >>> SRem(x, y).sort()
4484 BitVec(32)
4485 >>> (x % y).sexpr()
4486 '(bvsmod x y)'
4487 >>> SRem(x, y).sexpr()
4488 '(bvsrem x y)'
4489 """
4490 _check_bv_args(a, b)
4491 a, b = _coerce_exprs(a, b)
4493
4494
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 12149 of file z3py.py.
12149def Star(re):
12150 """Create the regular expression accepting zero or more repetitions of argument.
12151 >>> re = Star(Re("a"))
12152 >>> print(simplify(InRe("aa", re)))
12153 True
12154 >>> print(simplify(InRe("ab", re)))
12155 False
12156 >>> print(simplify(InRe("", re)))
12157 True
12158 """
12159 if z3_debug():
12160 _z3_assert(is_expr(re), "expression expected")
12162
12163
◆ 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 5025 of file z3py.py.
5025def Store(a, *args):
5026 """Return a Z3 store array expression.
5027
5028 >>> a = Array('a', IntSort(), IntSort())
5029 >>> i, v = Ints('i v')
5030 >>> s = Store(a, i, v)
5031 >>> s.sort()
5032 Array(Int, Int)
5033 >>> prove(s[i] == v)
5034 proved
5035 >>> j = Int('j')
5036 >>> prove(Implies(i != j, s[j] == a[j]))
5037 proved
5038 """
5039 return Update(a, args)
5040
5041
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 11758 of file z3py.py.
11758def String(name, ctx=None):
11759 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11760
11761 >>> x = String('x')
11762 """
11763 ctx = _get_ctx(ctx)
11765
11766
◆ Strings()
| Strings | ( | names, | |
| ctx = None ) |
Return a tuple of String constants.
Definition at line 11767 of file z3py.py.
11767def Strings(names, ctx=None):
11768 """Return a tuple of String constants. """
11769 ctx = _get_ctx(ctx)
11770 if isinstance(names, str):
11771 names = names.split(" ")
11772 return [String(name, ctx) for name in names]
11773
11774
◆ StringSort()
| StringSort | ( | ctx = None | ) |
◆ StringVal()
| StringVal | ( | s, | |
| ctx = None ) |
create a string expression
Definition at line 11751 of file z3py.py.
11751def StringVal(s, ctx=None):
11752 """create a string expression"""
11753 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11754 ctx = _get_ctx(ctx)
11756
11757
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 11995 of file z3py.py.
11995def StrToCode(s):
11996 """Convert a unit length string to integer code"""
11997 if not is_expr(s):
11998 s = _py2expr(s)
12000
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 11972 of file z3py.py.
11972def StrToInt(s):
11973 """Convert string expression to integer
11974 >>> a = StrToInt("1")
11975 >>> simplify(1 == a)
11976 True
11977 >>> b = StrToInt("2")
11978 >>> simplify(1 == b)
11979 False
11980 >>> c = StrToInt(IntToStr(2))
11981 >>> simplify(1 == c)
11982 False
11983 """
11984 s = _coerce_seq(s)
11986
11987
◆ 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 11789 of file z3py.py.
11789def SubSeq(s, offset, length):
11790 """Extract substring or subsequence starting at offset.
11791
11792 This is a convenience function that redirects to Extract(s, offset, length).
11793
11794 >>> s = StringVal("hello world")
11795 >>> SubSeq(s, 0, 5) # Extract "hello"
11796 str.substr("hello world", 0, 5)
11797 >>> simplify(SubSeq(StringVal("testing"), 2, 4))
11798 "stin"
11799 """
11800 return Extract(s, offset, length)
11801
11802
◆ 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 9623 of file z3py.py.
9623def substitute(t, *m):
9624 """Apply substitution m on t, m is a list of pairs of the form (from, to).
9625 Every occurrence in t of from is replaced with to.
9626
9627 >>> x = Int('x')
9628 >>> y = Int('y')
9629 >>> substitute(x + 1, (x, y + 1))
9630 y + 1 + 1
9631 >>> f = Function('f', IntSort(), IntSort())
9632 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
9633 1 + 1
9634 """
9635 if isinstance(m, tuple):
9636 m1 = _get_args(m)
9637 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9638 m = m1
9639 if z3_debug():
9640 _z3_assert(is_expr(t), "Z3 expression expected")
9641 _z3_assert(
9642 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
9643 "Z3 invalid substitution, expression pairs expected.")
9644 _z3_assert(
9645 all([p[0].sort().eq(p[1].sort()) for p in m]),
9646 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
9647 num = len(m)
9648 _from = (Ast * num)()
9649 _to = (Ast * num)()
9650 for i in range(num):
9651 _from[i] = m[i][0].as_ast()
9652 _to[i] = m[i][1].as_ast()
9654
9655
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 9676 of file z3py.py.
9676def substitute_funs(t, *m):
9677 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
9678 Every occurrence in to of the function from is replaced with the expression to.
9679 The expression to can have free variables, that refer to the arguments of from.
9680 For examples, see
9681 """
9682 if isinstance(m, tuple):
9683 m1 = _get_args(m)
9684 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9685 m = m1
9686 if z3_debug():
9687 _z3_assert(is_expr(t), "Z3 expression expected")
9688 _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.")
9689 num = len(m)
9690 _from = (FuncDecl * num)()
9691 _to = (Ast * num)()
9692 for i in range(num):
9693 _from[i] = m[i][0].as_func_decl()
9694 _to[i] = m[i][1].as_ast()
9696
9697
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 9656 of file z3py.py.
9656def substitute_vars(t, *m):
9657 """Substitute the free variables in t with the expression in m.
9658
9659 >>> v0 = Var(0, IntSort())
9660 >>> v1 = Var(1, IntSort())
9661 >>> x = Int('x')
9662 >>> f = Function('f', IntSort(), IntSort(), IntSort())
9663 >>> # replace v0 with x+1 and v1 with x
9664 >>> substitute_vars(f(v0, v1), x + 1, x)
9665 f(x + 1, x)
9666 """
9667 if z3_debug():
9668 _z3_assert(is_expr(t), "Z3 expression expected")
9669 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
9670 num = len(m)
9671 _to = (Ast * num)()
9672 for i in range(num):
9673 _to[i] = m[i].as_ast()
9675
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 11775 of file z3py.py.
11775def SubString(s, offset, length):
11776 """Extract substring or subsequence starting at offset.
11777
11778 This is a convenience function that redirects to Extract(s, offset, length).
11779
11780 >>> s = StringVal("hello world")
11781 >>> SubString(s, 6, 5) # Extract "world"
11782 str.substr("hello world", 6, 5)
11783 >>> simplify(SubString(StringVal("hello"), 1, 3))
11784 "ell"
11785 """
11786 return Extract(s, offset, length)
11787
11788
◆ 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 11858 of file z3py.py.
11858def SuffixOf(a, b):
11859 """Check if 'a' is a suffix of 'b'
11860 >>> s1 = SuffixOf("ab", "abc")
11861 >>> simplify(s1)
11862 False
11863 >>> s2 = SuffixOf("bc", "abc")
11864 >>> simplify(s2)
11865 True
11866 """
11867 ctx = _get_ctx2(a, b)
11868 a = _coerce_seq(a, ctx)
11869 b = _coerce_seq(b, ctx)
11871
11872
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 9698 of file z3py.py.
9698def Sum(*args):
9699 """Create the sum of the Z3 expressions.
9700
9701 >>> a, b, c = Ints('a b c')
9702 >>> Sum(a, b, c)
9703 a + b + c
9704 >>> Sum([a, b, c])
9705 a + b + c
9706 >>> A = IntVector('a', 5)
9707 >>> Sum(A)
9708 a__0 + a__1 + a__2 + a__3 + a__4
9709 """
9710 args = _get_args(args)
9711 if len(args) == 0:
9712 return 0
9713 ctx = _ctx_from_ast_arg_list(args)
9714 if ctx is None:
9715 return _reduce(lambda a, b: a + b, args, 0)
9716 args = _coerce_expr_list(args, ctx)
9717 if is_bv(args[0]):
9718 return _reduce(lambda a, b: a + b, args, 0)
9719 else:
9720 _args, sz = _to_ast_array(args)
9722
9723
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 9277 of file z3py.py.
9277def tactic_description(name, ctx=None):
9278 """Return a short description for the tactic named `name`.
9279
9280 >>> d = tactic_description('simplify')
9281 """
9282 ctx = _get_ctx(ctx)
9284
9285
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 9266 of file z3py.py.
9266def tactics(ctx=None):
9267 """Return a list of all available tactics in Z3.
9268
9269 >>> l = tactics()
9270 >>> l.count('simplify') == 1
9271 True
9272 """
9273 ctx = _get_ctx(ctx)
9275
9276
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 9134 of file z3py.py.
9134def Then(*ts, **ks):
9135 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
9136
9137 >>> x, y = Ints('x y')
9138 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
9139 >>> t(And(x == 0, y > x + 1))
9140 [[Not(y <= 1)]]
9141 >>> t(And(x == 0, y > x + 1)).as_expr()
9142 Not(y <= 1)
9143 """
9144 return AndThen(*ts, **ks)
9145
9146
◆ to_Ast()
| to_Ast | ( | ptr | ) |
◆ to_AstVectorObj()
| to_AstVectorObj | ( | ptr | ) |
Definition at line 12243 of file z3py.py.
12243def to_AstVectorObj(ptr,):
12244 v = AstVectorObj(ptr)
12245 super(ctypes.c_void_p, v).__init__(ptr)
12246 return v
12247
12248# NB. my-hacky-class only works for a single instance of OnClause
12249# it should be replaced with a proper correlation between OnClause
12250# and object references that can be passed over the FFI.
12251# for UserPropagator we use a global dictionary, which isn't great code.
12252
◆ 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(), CreatePolymorphicDatatype(), 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 3544 of file z3py.py.
3544def ToInt(a):
3545 """ Return the Z3 expression ToInt(a).
3546
3547 >>> x = Real('x')
3548 >>> x.sort()
3549 Real
3550 >>> n = ToInt(x)
3551 >>> n
3552 ToInt(x)
3553 >>> n.sort()
3554 Int
3555 """
3556 if z3_debug():
3557 _z3_assert(a.is_real(), "Z3 real expression expected.")
3558 ctx = a.ctx
3560
3561
◆ 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 3524 of file z3py.py.
3524def ToReal(a):
3525 """ Return the Z3 expression ToReal(a).
3526
3527 >>> x = Int('x')
3528 >>> x.sort()
3529 Int
3530 >>> n = ToReal(x)
3531 >>> n
3532 ToReal(x)
3533 >>> n.sort()
3534 Real
3535 """
3536 ctx = a.ctx
3537 if isinstance(a, BoolRef):
3538 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3539 if z3_debug():
3540 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3542
3543
◆ 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 12226 of file z3py.py.
12226def TransitiveClosure(f):
12227 """Given a binary relation R, such that the two arguments have the same sort
12228 create the transitive closure relation R+.
12229 The transitive closure R+ is a new relation.
12230 """
12232
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 9257 of file z3py.py.
9257def TryFor(t, ms, ctx=None):
9258 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
9259
9260 If `t` does not terminate in `ms` milliseconds, then it fails.
9261 """
9262 t = _to_tactic(t, ctx)
9264
9265
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 5975 of file z3py.py.
5975def TupleSort(name, sorts, ctx=None):
5976 """Create a named tuple sort base on a set of underlying sorts
5977 Example:
5978 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5979 """
5980 tuple = Datatype(name, ctx)
5981 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5982 tuple.declare(name, *projects)
5983 tuple = tuple.create()
5984 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5985
5986
◆ 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 4432 of file z3py.py.
4432def UDiv(a, b):
4433 """Create the Z3 expression (unsigned) division `self / other`.
4434
4435 Use the operator / for signed division.
4436
4437 >>> x = BitVec('x', 32)
4438 >>> y = BitVec('y', 32)
4439 >>> UDiv(x, y)
4440 UDiv(x, y)
4441 >>> UDiv(x, y).sort()
4442 BitVec(32)
4443 >>> (x / y).sexpr()
4444 '(bvsdiv x y)'
4445 >>> UDiv(x, y).sexpr()
4446 '(bvudiv x y)'
4447 """
4448 _check_bv_args(a, b)
4449 a, b = _coerce_exprs(a, b)
4451
4452
◆ 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 4396 of file z3py.py.
4396def UGE(a, b):
4397 """Create the Z3 expression (unsigned) `other >= self`.
4398
4399 Use the operator >= for signed greater than or equal to.
4400
4401 >>> x, y = BitVecs('x y', 32)
4402 >>> UGE(x, y)
4403 UGE(x, y)
4404 >>> (x >= y).sexpr()
4405 '(bvsge x y)'
4406 >>> UGE(x, y).sexpr()
4407 '(bvuge x y)'
4408 """
4409 _check_bv_args(a, b)
4410 a, b = _coerce_exprs(a, b)
4412
4413
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 4414 of file z3py.py.
4414def UGT(a, b):
4415 """Create the Z3 expression (unsigned) `other > self`.
4416
4417 Use the operator > for signed greater than.
4418
4419 >>> x, y = BitVecs('x y', 32)
4420 >>> UGT(x, y)
4421 UGT(x, y)
4422 >>> (x > y).sexpr()
4423 '(bvsgt x y)'
4424 >>> UGT(x, y).sexpr()
4425 '(bvugt x y)'
4426 """
4427 _check_bv_args(a, b)
4428 a, b = _coerce_exprs(a, b)
4430
4431
◆ 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 4360 of file z3py.py.
4360def ULE(a, b):
4361 """Create the Z3 expression (unsigned) `other <= self`.
4362
4363 Use the operator <= for signed less than or equal to.
4364
4365 >>> x, y = BitVecs('x y', 32)
4366 >>> ULE(x, y)
4367 ULE(x, y)
4368 >>> (x <= y).sexpr()
4369 '(bvsle x y)'
4370 >>> ULE(x, y).sexpr()
4371 '(bvule x y)'
4372 """
4373 _check_bv_args(a, b)
4374 a, b = _coerce_exprs(a, b)
4376
4377
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 4378 of file z3py.py.
4378def ULT(a, b):
4379 """Create the Z3 expression (unsigned) `other < self`.
4380
4381 Use the operator < for signed less than.
4382
4383 >>> x, y = BitVecs('x y', 32)
4384 >>> ULT(x, y)
4385 ULT(x, y)
4386 >>> (x < y).sexpr()
4387 '(bvslt x y)'
4388 >>> ULT(x, y).sexpr()
4389 '(bvult x y)'
4390 """
4391 _check_bv_args(a, b)
4392 a, b = _coerce_exprs(a, b)
4394
4395
◆ 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 12060 of file z3py.py.
12060def Union(*args):
12061 """Create union of regular expressions.
12062 >>> re = Union(Re("a"), Re("b"), Re("c"))
12063 >>> print (simplify(InRe("d", re)))
12064 False
12065 """
12066 args = _get_args(args)
12067 sz = len(args)
12068 if z3_debug():
12069 _z3_assert(sz > 0, "At least one argument expected.")
12070 arg0 = args[0]
12071 if is_finite_set(arg0):
12072 for a in args[1:]:
12073 if not is_finite_set(a):
12074 raise Z3Exception("All arguments must be regular expressions or finite sets.")
12075 arg0 = arg0 | a
12076 return arg0
12077 if z3_debug():
12078 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
12079 if sz == 1:
12080 return args[0]
12081 ctx = args[0].ctx
12082 v = (Ast * sz)()
12083 for i in range(sz):
12084 v[i] = args[i].as_ast()
12086
12087
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 4982 of file z3py.py.
4982def Update(a, *args):
4983 """Return a Z3 store array expression.
4984
4985 >>> a = Array('a', IntSort(), IntSort())
4986 >>> i, v = Ints('i v')
4987 >>> s = Update(a, i, v)
4988 >>> s.sort()
4989 Array(Int, Int)
4990 >>> prove(s[i] == v)
4991 proved
4992 >>> j = Int('j')
4993 >>> prove(Implies(i != j, s[j] == a[j]))
4994 proved
4995 """
4996 if z3_debug():
4997 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4998 args = _get_args(args)
4999 ctx = a.ctx
5000 if len(args) <= 1:
5001 raise Z3Exception("array update requires index and value arguments")
5002 if len(args) == 2:
5003 i = args[0]
5004 v = args[1]
5005 i = a.sort().domain().cast(i)
5006 v = a.sort().range().cast(v)
5008 v = a.sort().range().cast(args[-1])
5009 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
5010 _args, sz = _to_ast_array(idxs)
5012
5013
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 4453 of file z3py.py.
4453def URem(a, b):
4454 """Create the Z3 expression (unsigned) remainder `self % other`.
4455
4456 Use the operator % for signed modulus, and SRem() for signed remainder.
4457
4458 >>> x = BitVec('x', 32)
4459 >>> y = BitVec('y', 32)
4460 >>> URem(x, y)
4461 URem(x, y)
4462 >>> URem(x, y).sort()
4463 BitVec(32)
4464 >>> (x % y).sexpr()
4465 '(bvsmod x y)'
4466 >>> URem(x, y).sexpr()
4467 '(bvurem x y)'
4468 """
4469 _check_bv_args(a, b)
4470 a, b = _coerce_exprs(a, b)
4472
4473
◆ user_prop_binding()
| user_prop_binding | ( | ctx, | |
| cb, | |||
| q_ref, | |||
| inst_ref ) |
Definition at line 12396 of file z3py.py.
12396def user_prop_binding(ctx, cb, q_ref, inst_ref):
12397 prop = _prop_closures.get(ctx)
12398 old_cb = prop.cb
12399 prop.cb = cb
12400 q = _to_expr_ref(to_Ast(q_ref), prop.ctx())
12401 inst = _to_expr_ref(to_Ast(inst_ref), prop.ctx())
12402 r = prop.binding(q, inst)
12403 prop.cb = old_cb
12404 return r
12405
12406
◆ 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 12379 of file z3py.py.
12379def user_prop_diseq(ctx, cb, x, y):
12380 prop = _prop_closures.get(ctx)
12381 old_cb = prop.cb
12382 prop.cb = cb
12383 x = _to_expr_ref(to_Ast(x), prop.ctx())
12384 y = _to_expr_ref(to_Ast(y), prop.ctx())
12385 prop.diseq(x, y)
12386 prop.cb = old_cb
12387
◆ 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 12345 of file z3py.py.
12345def user_prop_fixed(ctx, cb, id, value):
12346 prop = _prop_closures.get(ctx)
12347 old_cb = prop.cb
12348 prop.cb = cb
12349 id = _to_expr_ref(to_Ast(id), prop.ctx())
12350 value = _to_expr_ref(to_Ast(value), prop.ctx())
12351 prop.fixed(id, value)
12352 prop.cb = old_cb
12353
◆ user_prop_fresh()
| user_prop_fresh | ( | ctx, | |
| _new_ctx ) |
Definition at line 12331 of file z3py.py.
12331def user_prop_fresh(ctx, _new_ctx):
12332 _prop_closures.set_threaded()
12333 prop = _prop_closures.get(ctx)
12334 nctx = Context()
12335 Z3_del_context(nctx.ctx)
12336 new_ctx = to_ContextObj(_new_ctx)
12337 nctx.ctx = new_ctx
12338 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
12339 nctx.owner = False
12340 new_prop = prop.fresh(nctx)
12341 _prop_closures.set(new_prop.id, new_prop)
12342 return new_prop.id
12343
12344
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 1581 of file z3py.py.
1581def Var(idx : int, s : SortRef) -> ExprRef:
1582 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1583 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1584 declarations.
1585
1586 >>> Var(0, IntSort())
1587 Var(0)
1588 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1589 False
1590 """
1591 if z3_debug():
1592 _z3_assert(is_sort(s), "Z3 sort expected")
1594
1595
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 9551 of file z3py.py.
9551def When(p, t, ctx=None):
9552 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
9553 Otherwise, it returns the input goal unmodified.
9554
9555 >>> t = When(Probe('size') > 2, Tactic('simplify'))
9556 >>> x, y = Ints('x y')
9557 >>> g = Goal()
9558 >>> g.add(x > 0)
9559 >>> g.add(y > 0)
9560 >>> t(g)
9561 [[x > 0, y > 0]]
9562 >>> g.add(x == y + 1)
9563 >>> t(g)
9564 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9565 """
9566 p = _to_probe(p, ctx)
9567 t = _to_tactic(t, ctx)
9569
9570
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 9208 of file z3py.py.
9208def With(t, *args, **keys):
9209 """Return a tactic that applies tactic `t` using the given configuration options.
9210
9211 >>> x, y = Ints('x y')
9212 >>> t = With(Tactic('simplify'), som=True)
9213 >>> t((x + 1)*(y + 2) == 0)
9214 [[2*x + y + x*y == -2]]
9215 """
9216 ctx = keys.pop("ctx", None)
9217 t = _to_tactic(t, ctx)
9218 p = args2params(args, keys, t.ctx)
9220
9221
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 9222 of file z3py.py.
9222def WithParams(t, p):
9223 """Return a tactic that applies tactic `t` using the given configuration options.
9224
9225 >>> x, y = Ints('x y')
9226 >>> p = ParamsRef()
9227 >>> p.set("som", True)
9228 >>> t = WithParams(Tactic('simplify'), p)
9229 >>> t((x + 1)*(y + 2) == 0)
9230 [[2*x + y + x*y == -2]]
9231 """
9232 t = _to_tactic(t, None)
9234
9235
◆ 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 1938 of file z3py.py.
1938def Xor(a, b, ctx=None):
1939 """Create a Z3 Xor expression.
1940
1941 >>> p, q = Bools('p q')
1942 >>> Xor(p, q)
1943 Xor(p, q)
1944 >>> simplify(Xor(p, q))
1945 Not(p == q)
1946 """
1947 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1948 s = BoolSort(ctx)
1949 a = s.cast(a)
1950 b = s.cast(b)
1952
1953
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(), AsArray(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), ArithSortRef.cast(), BitVecSortRef.cast(), SortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), CreatePolymorphicDatatype(), 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(), ExprRef.update(), DatatypeRef.update_field(), 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 4589 of file z3py.py.
4589def ZeroExt(n, a):
4590 """Return a bit-vector expression with `n` extra zero-bits.
4591
4592 >>> x = BitVec('x', 16)
4593 >>> n = ZeroExt(8, x)
4594 >>> n.size()
4595 24
4596 >>> n
4597 ZeroExt(8, x)
4598 >>> n.sort()
4599 BitVec(24)
4600 >>> v0 = BitVecVal(2, 2)
4601 >>> v0
4602 2
4603 >>> v0.size()
4604 2
4605 >>> v = simplify(ZeroExt(6, v0))
4606 >>> v
4607 2
4608 >>> v.size()
4609 8
4610 """
4611 if z3_debug():
4612 _z3_assert(_is_int(n), "First argument must be an integer")
4613 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4615
4616
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.17.0