Z3
Loading...
Searching...
No Matches
z3py Namespace Reference

Data Structures

class  AlgebraicNumRef
class  ApplyResult
class  ArithRef
class  ArithSortRef
 Arithmetic. More...
class  ArrayRef
class  ArraySortRef
 Arrays. More...
class  AstMap
class  AstRef
class  AstVector
class  BitVecNumRef
class  BitVecRef
class  BitVecSortRef
 Bit-Vectors. More...
class  BoolRef
class  BoolSortRef
 Booleans. More...
class  CharRef
class  CharSortRef
class  CheckSatResult
class  Context
class  Datatype
class  DatatypeRef
class  DatatypeSortRef
class  ExprRef
 Expressions. More...
class  FiniteDomainNumRef
class  FiniteDomainRef
class  FiniteDomainSortRef
class  Fixedpoint
 Fixedpoint. More...
class  FPNumRef
class  FPRef
class  FPRMRef
class  FPRMSortRef
class  FPSortRef
class  FuncDeclRef
 Function Declarations. More...
class  FuncEntry
class  FuncInterp
class  Goal
class  IntNumRef
class  ModelRef
class  OnClause
class  Optimize
class  OptimizeObjective
 Optimize. More...
class  ParamDescrsRef
class  ParamsRef
 Parameter Sets. More...
class  ParserContext
class  PatternRef
 Patterns. More...
class  Probe
class  PropClosures
class  QuantifierRef
 Quantifiers. More...
class  RatNumRef
class  ReRef
class  ReSortRef
class  ScopedConstructor
class  ScopedConstructorList
class  SeqRef
class  SeqSortRef
 Strings, Sequences and Regular expressions. More...
class  Simplifier
class  Solver
class  SortRef
class  Statistics
 Statistics. More...
class  Tactic
class  TypeVarRef
class  UserPropagateBase
class  Z3PPObject
 ASTs base class. More...

Functions

 z3_debug ()
 _is_int (v)
 enable_trace (msg)
 disable_trace (msg)
 get_version_string ()
 get_version ()
 get_full_version ()
 _z3_assert (cond, msg)
 _z3_check_cint_overflow (n, name)
 open_log (fname)
 append_log (s)
 to_symbol (s, ctx=None)
 _symbol2py (ctx, s)
 _get_args (args)
 _get_args_ast_list (args)
 _to_param_value (val)
 z3_error_handler (c, e)
Context main_ctx ()
Context _get_ctx (ctx)
Context get_ctx (ctx)
 set_param (*args, **kws)
None reset_params ()
 set_option (*args, **kws)
 get_param (name)
bool is_ast (Any a)
bool eq (AstRef a, AstRef b)
int _ast_kind (Context ctx, Any a)
 _ctx_from_ast_arg_list (args, default_ctx=None)
 _ctx_from_ast_args (*args)
 _to_func_decl_array (args)
 _to_ast_array (args)
 _to_ref_array (ref, args)
 _to_ast_ref (a, ctx)
 _sort_kind (ctx, s)
 Sorts.
bool is_sort (Any s)
 _to_sort_ref (s, ctx)
SortRef _sort (Context ctx, Any a)
SortRef DeclareSort (name, ctx=None)
 DeclareTypeVar (name, ctx=None)
 is_func_decl (a)
 Function (name, *sig)
 FreshFunction (*sig)
 _to_func_decl_ref (a, ctx)
 RecFunction (name, *sig)
 RecAddDefinition (f, args, body)
 deserialize (st)
 _to_expr_ref (a, ctx)
 _coerce_expr_merge (s, a)
 _coerce_exprs (a, b, ctx=None)
 _reduce (func, sequence, initial)
 _coerce_expr_list (alist, ctx=None)
 is_expr (a)
 is_app (a)
 is_const (a)
 is_var (a)
 get_var_index (a)
 is_app_of (a, k)
 If (a, b, c, ctx=None)
 Distinct (*args)
 _mk_bin (f, a, b)
 Const (name, sort)
 Consts (names, sort)
 FreshConst (sort, prefix="c")
ExprRef Var (int idx, SortRef s)
ExprRef RealVar (int idx, ctx=None)
 RealVarVector (int n, ctx=None)
bool is_bool (Any a)
bool is_true (Any a)
bool is_false (Any a)
bool is_and (Any a)
bool is_or (Any a)
bool is_implies (Any a)
bool is_not (Any a)
bool is_eq (Any a)
bool is_distinct (Any a)
 BoolSort (ctx=None)
 BoolVal (val, ctx=None)
 Bool (name, ctx=None)
 Bools (names, ctx=None)
 BoolVector (prefix, sz, ctx=None)
 FreshBool (prefix="b", ctx=None)
 Implies (a, b, ctx=None)
 Xor (a, b, ctx=None)
 Not (a, ctx=None)
 mk_not (a)
 _has_probe (args)
 And (*args)
 Or (*args)
 is_pattern (a)
 MultiPattern (*args)
 _to_pattern (arg)
 is_quantifier (a)
 _mk_quantifier (is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
 ForAll (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
 Exists (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
 Lambda (vs, body)
bool is_arith_sort (Any s)
 is_arith (a)
bool is_int (a)
 is_real (a)
 _is_numeral (ctx, a)
 _is_algebraic (ctx, a)
 is_int_value (a)
 is_rational_value (a)
 is_algebraic_value (a)
bool is_add (Any a)
bool is_mul (Any a)
bool is_sub (Any a)
bool is_div (Any a)
bool is_idiv (Any a)
bool is_mod (Any a)
bool is_le (Any a)
bool is_lt (Any a)
bool is_ge (Any a)
bool is_gt (Any a)
bool is_is_int (Any a)
bool is_to_real (Any a)
bool is_to_int (Any a)
 _py2expr (a, ctx=None)
 IntSort (ctx=None)
 RealSort (ctx=None)
 _to_int_str (val)
 IntVal (val, ctx=None)
 RealVal (val, ctx=None)
 RatVal (a, b, ctx=None)
 Q (a, b, ctx=None)
 Int (name, ctx=None)
 Ints (names, ctx=None)
 IntVector (prefix, sz, ctx=None)
 FreshInt (prefix="x", ctx=None)
 Real (name, ctx=None)
 Reals (names, ctx=None)
 RealVector (prefix, sz, ctx=None)
 FreshReal (prefix="b", ctx=None)
 ToReal (a)
 ToInt (a)
 IsInt (a)
 Sqrt (a, ctx=None)
 Cbrt (a, ctx=None)
 is_bv_sort (s)
 is_bv (a)
 is_bv_value (a)
 BV2Int (a, is_signed=False)
 Int2BV (a, num_bits)
 BitVecSort (sz, ctx=None)
 BitVecVal (val, bv, ctx=None)
 BitVec (name, bv, ctx=None)
 BitVecs (names, bv, ctx=None)
 Concat (*args)
 Extract (high, low, a)
 _check_bv_args (a, b)
 ULE (a, b)
 ULT (a, b)
 UGE (a, b)
 UGT (a, b)
 UDiv (a, b)
 URem (a, b)
 SRem (a, b)
 LShR (a, b)
 RotateLeft (a, b)
 RotateRight (a, b)
 SignExt (n, a)
 ZeroExt (n, a)
 RepeatBitVec (n, a)
 BVRedAnd (a)
 BVRedOr (a)
 BVAddNoOverflow (a, b, signed)
 BVAddNoUnderflow (a, b)
 BVSubNoOverflow (a, b)
 BVSubNoUnderflow (a, b, signed)
 BVSDivNoOverflow (a, b)
 BVSNegNoOverflow (a)
 BVMulNoOverflow (a, b, signed)
 BVMulNoUnderflow (a, b)
 _array_select (ar, arg)
 is_array_sort (a)
bool is_array (Any a)
 is_const_array (a)
 is_K (a)
 is_map (a)
 is_default (a)
 get_map_func (a)
 ArraySort (*sig)
 Array (name, *sorts)
 Update (a, *args)
 Default (a)
 Store (a, *args)
 Select (a, *args)
 Map (f, *args)
 K (dom, v)
 Ext (a, b)
 SetHasSize (a, k)
 is_select (a)
 is_store (a)
 SetSort (s)
 Sets.
 EmptySet (s)
 FullSet (s)
 SetUnion (*args)
 SetIntersect (*args)
 SetAdd (s, e)
 SetDel (s, e)
 SetComplement (s)
 SetDifference (a, b)
 IsMember (e, s)
 IsSubset (a, b)
 _valid_accessor (acc)
 Datatypes.
 CreateDatatypes (*ds)
 DatatypeSort (name, ctx=None)
 TupleSort (name, sorts, ctx=None)
 DisjointSum (name, sorts, ctx=None)
 EnumSort (name, values, ctx=None)
 args2params (arguments, keywords, ctx=None)
 Model (ctx=None, eval={})
 is_as_array (n)
 get_as_array_func (n)
 SolverFor (logic, ctx=None, logFile=None)
 SimpleSolver (ctx=None, logFile=None)
 FiniteDomainSort (name, sz, ctx=None)
 is_finite_domain_sort (s)
 is_finite_domain (a)
 FiniteDomainVal (val, sort, ctx=None)
 is_finite_domain_value (a)
 _global_on_model (ctx)
 _to_goal (a)
 _to_tactic (t, ctx=None)
 _and_then (t1, t2, ctx=None)
 _or_else (t1, t2, ctx=None)
 AndThen (*ts, **ks)
 Then (*ts, **ks)
 OrElse (*ts, **ks)
 ParOr (*ts, **ks)
 ParThen (t1, t2, ctx=None)
 ParAndThen (t1, t2, ctx=None)
 With (t, *args, **keys)
 WithParams (t, p)
 Repeat (t, max=4294967295, ctx=None)
 TryFor (t, ms, ctx=None)
 tactics (ctx=None)
 tactic_description (name, ctx=None)
 describe_tactics ()
 is_probe (p)
 _to_probe (p, ctx=None)
 probes (ctx=None)
 probe_description (name, ctx=None)
 describe_probes ()
 _probe_nary (f, args, ctx)
 _probe_and (args, ctx)
 _probe_or (args, ctx)
 FailIf (p, ctx=None)
 When (p, t, ctx=None)
 Cond (p, t1, t2, ctx=None)
 simplify (a, *arguments, **keywords)
 Utils.
 help_simplify ()
 simplify_param_descrs ()
 substitute (t, *m)
 substitute_vars (t, *m)
 substitute_funs (t, *m)
 Sum (*args)
 Product (*args)
 Abs (arg)
 AtMost (*args)
 AtLeast (*args)
 _reorder_pb_arg (arg)
 _pb_args_coeffs (args, default_ctx=None)
 PbLe (args, k)
 PbGe (args, k)
 PbEq (args, k, ctx=None)
 solve (*args, **keywords)
 solve_using (s, *args, **keywords)
 prove (claim, show=False, **keywords)
 _solve_html (*args, **keywords)
 _solve_using_html (s, *args, **keywords)
 _prove_html (claim, show=False, **keywords)
 _dict2sarray (sorts, ctx)
 _dict2darray (decls, ctx)
 parse_smt2_string (s, sorts={}, decls={}, ctx=None)
 parse_smt2_file (f, sorts={}, decls={}, ctx=None)
 get_default_rounding_mode (ctx=None)
 set_default_rounding_mode (rm, ctx=None)
 get_default_fp_sort (ctx=None)
 set_default_fp_sort (ebits, sbits, ctx=None)
 _dflt_rm (ctx=None)
 _dflt_fps (ctx=None)
 _coerce_fp_expr_list (alist, ctx)
 Float16 (ctx=None)
 FloatHalf (ctx=None)
 Float32 (ctx=None)
 FloatSingle (ctx=None)
 Float64 (ctx=None)
 FloatDouble (ctx=None)
 Float128 (ctx=None)
 FloatQuadruple (ctx=None)
 is_fp_sort (s)
 is_fprm_sort (s)
 RoundNearestTiesToEven (ctx=None)
 RNE (ctx=None)
 RoundNearestTiesToAway (ctx=None)
 RNA (ctx=None)
 RoundTowardPositive (ctx=None)
 RTP (ctx=None)
 RoundTowardNegative (ctx=None)
 RTN (ctx=None)
 RoundTowardZero (ctx=None)
 RTZ (ctx=None)
 is_fprm (a)
 is_fprm_value (a)
 is_fp (a)
 is_fp_value (a)
 FPSort (ebits, sbits, ctx=None)
 _to_float_str (val, exp=0)
 fpNaN (s)
 fpPlusInfinity (s)
 fpMinusInfinity (s)
 fpInfinity (s, negative)
 fpPlusZero (s)
 fpMinusZero (s)
 fpZero (s, negative)
 FPVal (sig, exp=None, fps=None, ctx=None)
 FP (name, fpsort, ctx=None)
 FPs (names, fpsort, ctx=None)
 fpAbs (a, ctx=None)
 fpNeg (a, ctx=None)
 _mk_fp_unary (f, rm, a, ctx)
 _mk_fp_unary_pred (f, a, ctx)
 _mk_fp_bin (f, rm, a, b, ctx)
 _mk_fp_bin_norm (f, a, b, ctx)
 _mk_fp_bin_pred (f, a, b, ctx)
 _mk_fp_tern (f, rm, a, b, c, ctx)
 fpAdd (rm, a, b, ctx=None)
 fpSub (rm, a, b, ctx=None)
 fpMul (rm, a, b, ctx=None)
 fpDiv (rm, a, b, ctx=None)
 fpRem (a, b, ctx=None)
 fpMin (a, b, ctx=None)
 fpMax (a, b, ctx=None)
 fpFMA (rm, a, b, c, ctx=None)
 fpSqrt (rm, a, ctx=None)
 fpRoundToIntegral (rm, a, ctx=None)
 fpIsNaN (a, ctx=None)
 fpIsInf (a, ctx=None)
 fpIsZero (a, ctx=None)
 fpIsNormal (a, ctx=None)
 fpIsSubnormal (a, ctx=None)
 fpIsNegative (a, ctx=None)
 fpIsPositive (a, ctx=None)
 _check_fp_args (a, b)
 fpLT (a, b, ctx=None)
 fpLEQ (a, b, ctx=None)
 fpGT (a, b, ctx=None)
 fpGEQ (a, b, ctx=None)
 fpEQ (a, b, ctx=None)
 fpNEQ (a, b, ctx=None)
 fpFP (sgn, exp, sig, ctx=None)
 fpToFP (a1, a2=None, a3=None, ctx=None)
 fpBVToFP (v, sort, ctx=None)
 fpFPToFP (rm, v, sort, ctx=None)
 fpRealToFP (rm, v, sort, ctx=None)
 fpSignedToFP (rm, v, sort, ctx=None)
 fpUnsignedToFP (rm, v, sort, ctx=None)
 fpToFPUnsigned (rm, x, s, ctx=None)
 fpToSBV (rm, x, s, ctx=None)
 fpToUBV (rm, x, s, ctx=None)
 fpToReal (x, ctx=None)
 fpToIEEEBV (x, ctx=None)
 StringSort (ctx=None)
 CharSort (ctx=None)
 SeqSort (s)
 _coerce_char (ch, ctx=None)
 CharVal (ch, ctx=None)
 CharFromBv (bv)
 CharToBv (ch, ctx=None)
 CharToInt (ch, ctx=None)
 CharIsDigit (ch, ctx=None)
 _coerce_seq (s, ctx=None)
 _get_ctx2 (a, b, ctx=None)
 is_seq (a)
bool is_string (Any a)
bool is_string_value (Any a)
 StringVal (s, ctx=None)
 String (name, ctx=None)
 Strings (names, ctx=None)
 SubString (s, offset, length)
 SubSeq (s, offset, length)
 Empty (s)
 Full (s)
 Unit (a)
 PrefixOf (a, b)
 SuffixOf (a, b)
 Contains (a, b)
 Replace (s, src, dst)
 IndexOf (s, substr, offset=None)
 LastIndexOf (s, substr)
 Length (s)
 SeqMap (f, s)
 SeqMapI (f, i, s)
 SeqFoldLeft (f, a, s)
 SeqFoldLeftI (f, i, a, s)
 StrToInt (s)
 IntToStr (s)
 StrToCode (s)
 StrFromCode (c)
 Re (s, ctx=None)
 ReSort (s)
 is_re (s)
 InRe (s, re)
 Union (*args)
 Intersect (*args)
 Plus (re)
 Option (re)
 Complement (re)
 Star (re)
 Loop (re, lo, hi=0)
 Range (lo, hi, ctx=None)
 Diff (a, b, ctx=None)
 AllChar (regex_sort, ctx=None)
 PartialOrder (a, index)
 LinearOrder (a, index)
 TreeOrder (a, index)
 PiecewiseLinearOrder (a, index)
 TransitiveClosure (f)
 to_Ast (ptr)
 to_ContextObj (ptr)
 to_AstVectorObj (ptr)
 on_clause_eh (ctx, p, n, dep, clause)
 ensure_prop_closures ()
 user_prop_push (ctx, cb)
 user_prop_pop (ctx, cb, num_scopes)
 user_prop_fresh (ctx, _new_ctx)
 user_prop_fixed (ctx, cb, id, value)
 user_prop_created (ctx, cb, id)
 user_prop_final (ctx, cb)
 user_prop_eq (ctx, cb, x, y)
 user_prop_diseq (ctx, cb, x, y)
 user_prop_decide (ctx, cb, t_ref, idx, phase)
 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)

Function Documentation

◆ _and_then()

_and_then ( t1,
t2,
ctx = None )
protected

Definition at line 8516 of file z3py.py.

8516def _and_then(t1, t2, ctx=None):
8517 t1 = _to_tactic(t1, ctx)
8518 t2 = _to_tactic(t2, ctx)
8519 if z3_debug():
8520 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8521 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8522
8523
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()

_array_select ( ar,
arg )
protected

Definition at line 4688 of file z3py.py.

4688def _array_select(ar, arg):
4689 if isinstance(arg, tuple):
4690 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4691 _args, sz = _to_ast_array(args)
4692 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4693 arg = ar.sort().domain().cast(arg)
4694 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4695
4696
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()

int _ast_kind ( Context ctx,
Any a )
protected

Definition at line 505 of file z3py.py.

505def _ast_kind(ctx : Context, a : Any) -> int:
506 if is_ast(a):
507 a = a.as_ast()
508 return Z3_get_ast_kind(ctx.ref(), a)
509
510
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.

Referenced by _to_ast_ref(), is_app(), and is_var().

◆ _check_bv_args()

_check_bv_args ( a,
b )
protected

Definition at line 4249 of file z3py.py.

4249def _check_bv_args(a, b):
4250 if z3_debug():
4251 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4252
4253

Referenced by BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().

◆ _check_fp_args()

_check_fp_args ( a,
b )
protected

Definition at line 10628 of file z3py.py.

10628def _check_fp_args(a, b):
10629 if z3_debug():
10630 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10631
10632

◆ _coerce_char()

_coerce_char ( ch,
ctx = None )
protected

Definition at line 11071 of file z3py.py.

11071def _coerce_char(ch, ctx=None):
11072 if isinstance(ch, str):
11073 ctx = _get_ctx(ctx)
11074 ch = CharVal(ch, ctx)
11075 if not is_expr(ch):
11076 raise Z3Exception("Character expression expected")
11077 return ch
11078

◆ _coerce_expr_list()

_coerce_expr_list ( alist,
ctx = None )
protected

Definition at line 1273 of file z3py.py.

1273def _coerce_expr_list(alist, ctx=None):
1274 has_expr = False
1275 for a in alist:
1276 if is_expr(a):
1277 has_expr = True
1278 break
1279 if not has_expr:
1280 alist = [_py2expr(a, ctx) for a in alist]
1281 s = _reduce(_coerce_expr_merge, alist, None)
1282 return [s.cast(a) for a in alist]
1283
1284

Referenced by And(), Distinct(), and Or().

◆ _coerce_expr_merge()

_coerce_expr_merge ( s,
a )
protected

Definition at line 1226 of file z3py.py.

1226def _coerce_expr_merge(s, a):
1227 if is_expr(a):
1228 s1 = a.sort()
1229 if s is None:
1230 return s1
1231 if s1.eq(s):
1232 return s
1233 elif s.subsort(s1):
1234 return s1
1235 elif s1.subsort(s):
1236 return s
1237 else:
1238 if z3_debug():
1239 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1240 _z3_assert(False, "sort mismatch")
1241 else:
1242 return s
1243
1244

Referenced by _coerce_exprs().

◆ _coerce_exprs()

_coerce_exprs ( a,
b,
ctx = None )
protected

Definition at line 1245 of file z3py.py.

1245def _coerce_exprs(a, b, ctx=None):
1246 if not is_expr(a) and not is_expr(b):
1247 a = _py2expr(a, ctx)
1248 b = _py2expr(b, ctx)
1249 if isinstance(a, str) and isinstance(b, SeqRef):
1250 a = StringVal(a, b.ctx)
1251 if isinstance(b, str) and isinstance(a, SeqRef):
1252 b = StringVal(b, a.ctx)
1253 if isinstance(a, float) and isinstance(b, ArithRef):
1254 a = RealVal(a, b.ctx)
1255 if isinstance(b, float) and isinstance(a, ArithRef):
1256 b = RealVal(b, a.ctx)
1257
1258 s = None
1259 s = _coerce_expr_merge(s, a)
1260 s = _coerce_expr_merge(s, b)
1261 a = s.cast(a)
1262 b = s.cast(b)
1263 return (a, b)
1264
1265

Referenced by ArithRef.__add__(), BitVecRef.__add__(), BitVecRef.__and__(), ArithRef.__div__(), BitVecRef.__div__(), ExprRef.__eq__(), ArithRef.__ge__(), BitVecRef.__ge__(), ArithRef.__gt__(), BitVecRef.__gt__(), ArithRef.__le__(), BitVecRef.__le__(), BitVecRef.__lshift__(), ArithRef.__lt__(), BitVecRef.__lt__(), ArithRef.__mod__(), BitVecRef.__mod__(), ArithRef.__mul__(), BitVecRef.__mul__(), ExprRef.__ne__(), BitVecRef.__or__(), ArithRef.__pow__(), ArithRef.__radd__(), BitVecRef.__radd__(), BitVecRef.__rand__(), ArithRef.__rdiv__(), BitVecRef.__rdiv__(), BitVecRef.__rlshift__(), ArithRef.__rmod__(), BitVecRef.__rmod__(), ArithRef.__rmul__(), BitVecRef.__rmul__(), BitVecRef.__ror__(), ArithRef.__rpow__(), BitVecRef.__rrshift__(), BitVecRef.__rshift__(), ArithRef.__rsub__(), BitVecRef.__rsub__(), BitVecRef.__rxor__(), ArithRef.__sub__(), BitVecRef.__sub__(), BitVecRef.__xor__(), BVAddNoOverflow(), BVAddNoUnderflow(), BVMulNoOverflow(), BVMulNoUnderflow(), BVSDivNoOverflow(), BVSubNoOverflow(), BVSubNoUnderflow(), Extract(), If(), LShR(), RotateLeft(), RotateRight(), SRem(), UDiv(), UGE(), UGT(), ULE(), ULT(), and URem().

◆ _coerce_fp_expr_list()

_coerce_fp_expr_list ( alist,
ctx )
protected

Definition at line 9577 of file z3py.py.

9577def _coerce_fp_expr_list(alist, ctx):
9578 first_fp_sort = None
9579 for a in alist:
9580 if is_fp(a):
9581 if first_fp_sort is None:
9582 first_fp_sort = a.sort()
9583 elif first_fp_sort == a.sort():
9584 pass # OK, same as before
9585 else:
9586 # we saw at least 2 different float sorts; something will
9587 # throw a sort mismatch later, for now assume None.
9588 first_fp_sort = None
9589 break
9590
9591 r = []
9592 for i in range(len(alist)):
9593 a = alist[i]
9594 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9595 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9596 r.append(FPVal(a, None, first_fp_sort, ctx))
9597 else:
9598 r.append(a)
9599 return _coerce_expr_list(r, ctx)
9600
9601
9602# FP Sorts
9603

◆ _coerce_seq()

_coerce_seq ( s,
ctx = None )
protected

Definition at line 11121 of file z3py.py.

11121def _coerce_seq(s, ctx=None):
11122 if isinstance(s, str):
11123 ctx = _get_ctx(ctx)
11124 s = StringVal(s, ctx)
11125 if not is_expr(s):
11126 raise Z3Exception("Non-expression passed as a sequence")
11127 if not is_seq(s):
11128 raise Z3Exception("Non-sequence passed as a sequence")
11129 return s
11130
11131

Referenced by Concat().

◆ _ctx_from_ast_arg_list()

_ctx_from_ast_arg_list ( args,
default_ctx = None )
protected

Definition at line 511 of file z3py.py.

511def _ctx_from_ast_arg_list(args, default_ctx=None):
512 ctx = None
513 for a in args:
514 if is_ast(a) or is_probe(a):
515 if ctx is None:
516 ctx = a.ctx
517 else:
518 if z3_debug():
519 _z3_assert(ctx == a.ctx, "Context mismatch")
520 if ctx is None:
521 ctx = default_ctx
522 return ctx
523
524

Referenced by _ctx_from_ast_args(), And(), Distinct(), If(), Implies(), IsMember(), IsSubset(), Not(), Or(), SetAdd(), SetDel(), SetDifference(), SetIntersect(), SetUnion(), and Xor().

◆ _ctx_from_ast_args()

_ctx_from_ast_args ( * args)
protected

Definition at line 525 of file z3py.py.

525def _ctx_from_ast_args(*args):
526 return _ctx_from_ast_arg_list(args)
527
528

◆ _dflt_fps()

_dflt_fps ( ctx = None)
protected

Definition at line 9573 of file z3py.py.

9573def _dflt_fps(ctx=None):
9574 return get_default_fp_sort(ctx)
9575
9576

◆ _dflt_rm()

_dflt_rm ( ctx = None)
protected

Definition at line 9569 of file z3py.py.

9569def _dflt_rm(ctx=None):
9570 return get_default_rounding_mode(ctx)
9571
9572

◆ _dict2darray()

_dict2darray ( decls,
ctx )
protected

Definition at line 9442 of file z3py.py.

9442def _dict2darray(decls, ctx):
9443 sz = len(decls)
9444 _names = (Symbol * sz)()
9445 _decls = (FuncDecl * sz)()
9446 i = 0
9447 for k in decls:
9448 v = decls[k]
9449 if z3_debug():
9450 _z3_assert(isinstance(k, str), "String expected")
9451 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9452 _names[i] = to_symbol(k, ctx)
9453 if is_const(v):
9454 _decls[i] = v.decl().ast
9455 else:
9456 _decls[i] = v.ast
9457 i = i + 1
9458 return sz, _names, _decls
9459

◆ _dict2sarray()

_dict2sarray ( sorts,
ctx )
protected

Definition at line 9426 of file z3py.py.

9426def _dict2sarray(sorts, ctx):
9427 sz = len(sorts)
9428 _names = (Symbol * sz)()
9429 _sorts = (Sort * sz)()
9430 i = 0
9431 for k in sorts:
9432 v = sorts[k]
9433 if z3_debug():
9434 _z3_assert(isinstance(k, str), "String expected")
9435 _z3_assert(is_sort(v), "Z3 sort expected")
9436 _names[i] = to_symbol(k, ctx)
9437 _sorts[i] = v.ast
9438 i = i + 1
9439 return sz, _names, _sorts
9440
9441

◆ _get_args()

_get_args ( 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()

_get_args_ast_list ( args)
protected

Definition at line 168 of file z3py.py.

168def _get_args_ast_list(args):
169 try:
170 if isinstance(args, (set, AstVector, tuple)):
171 return [arg for arg in args]
172 else:
173 return args
174 except Exception:
175 return args
176
177

◆ _get_ctx()

Context _get_ctx ( ctx)
protected

Definition at line 270 of file z3py.py.

270def _get_ctx(ctx) -> Context:
271 if ctx is None:
272 return main_ctx()
273 else:
274 return ctx
275
276

Referenced by And(), BitVec(), BitVecs(), BitVecSort(), BitVecVal(), Bool(), Bools(), BoolSort(), BoolVal(), Cbrt(), DatatypeSort(), DeclareSort(), DeclareTypeVar(), EnumSort(), FreshBool(), FreshConst(), FreshInt(), FreshReal(), get_ctx(), If(), Implies(), Int(), Ints(), IntSort(), IntVal(), IntVector(), Model(), Not(), Or(), Real(), Reals(), RealSort(), RealVal(), RealVector(), Sqrt(), to_symbol(), and Xor().

◆ _get_ctx2()

_get_ctx2 ( a,
b,
ctx = None )
protected

Definition at line 11132 of file z3py.py.

11132def _get_ctx2(a, b, ctx=None):
11133 if is_expr(a):
11134 return a.ctx
11135 if is_expr(b):
11136 return b.ctx
11137 if ctx is None:
11138 ctx = main_ctx()
11139 return ctx
11140
11141

◆ _global_on_model()

_global_on_model ( ctx)
protected

Definition at line 8020 of file z3py.py.

8020def _global_on_model(ctx):
8021 (fn, mdl) = _on_models[ctx]
8022 fn(mdl)
8023
8024

◆ _has_probe()

_has_probe ( args)
protected
Return `True` if one of the elements of the given collection is a Z3 probe.

Definition at line 1912 of file z3py.py.

1912def _has_probe(args):
1913 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1914 for arg in args:
1915 if is_probe(arg):
1916 return True
1917 return False
1918
1919

Referenced by And(), and Or().

◆ _is_algebraic()

_is_algebraic ( ctx,
a )
protected

Definition at line 2809 of file z3py.py.

2809def _is_algebraic(ctx, a):
2810 return Z3_is_algebraic_number(ctx.ref(), a)
2811
2812
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()

_is_int ( v)
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()

_is_numeral ( ctx,
a )
protected

Definition at line 2805 of file z3py.py.

2805def _is_numeral(ctx, a):
2806 return Z3_is_numeral_ast(ctx.ref(), a)
2807
2808
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()

_mk_bin ( f,
a,
b )
protected

Definition at line 1471 of file z3py.py.

1471def _mk_bin(f, a, b):
1472 args = (Ast * 2)()
1473 if z3_debug():
1474 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1475 args[0] = a.as_ast()
1476 args[1] = b.as_ast()
1477 return f(a.ctx.ref(), 2, args)
1478
1479

Referenced by ArithRef.__add__(), ArithRef.__mul__(), ArithRef.__radd__(), ArithRef.__rmul__(), ArithRef.__rsub__(), and ArithRef.__sub__().

◆ _mk_fp_bin()

_mk_fp_bin ( f,
rm,
a,
b,
ctx )
protected

Definition at line 10416 of file z3py.py.

10416def _mk_fp_bin(f, rm, a, b, ctx):
10417 ctx = _get_ctx(ctx)
10418 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10419 if z3_debug():
10420 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10421 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10422 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10423
10424

◆ _mk_fp_bin_norm()

_mk_fp_bin_norm ( f,
a,
b,
ctx )
protected

Definition at line 10425 of file z3py.py.

10425def _mk_fp_bin_norm(f, a, b, ctx):
10426 ctx = _get_ctx(ctx)
10427 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10428 if z3_debug():
10429 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10430 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10431
10432

◆ _mk_fp_bin_pred()

_mk_fp_bin_pred ( f,
a,
b,
ctx )
protected

Definition at line 10433 of file z3py.py.

10433def _mk_fp_bin_pred(f, a, b, ctx):
10434 ctx = _get_ctx(ctx)
10435 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10436 if z3_debug():
10437 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10438 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10439
10440

◆ _mk_fp_tern()

_mk_fp_tern ( f,
rm,
a,
b,
c,
ctx )
protected

Definition at line 10441 of file z3py.py.

10441def _mk_fp_tern(f, rm, a, b, c, ctx):
10442 ctx = _get_ctx(ctx)
10443 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10444 if z3_debug():
10445 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10446 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10447 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10448 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10449
10450

◆ _mk_fp_unary()

_mk_fp_unary ( f,
rm,
a,
ctx )
protected

Definition at line 10399 of file z3py.py.

10399def _mk_fp_unary(f, rm, a, ctx):
10400 ctx = _get_ctx(ctx)
10401 [a] = _coerce_fp_expr_list([a], ctx)
10402 if z3_debug():
10403 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10404 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10405 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10406
10407

◆ _mk_fp_unary_pred()

_mk_fp_unary_pred ( f,
a,
ctx )
protected

Definition at line 10408 of file z3py.py.

10408def _mk_fp_unary_pred(f, a, ctx):
10409 ctx = _get_ctx(ctx)
10410 [a] = _coerce_fp_expr_list([a], ctx)
10411 if z3_debug():
10412 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10413 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10414
10415

◆ _mk_quantifier()

_mk_quantifier ( is_forall,
vs,
body,
weight = 1,
qid = "",
skid = "",
patterns = [],
no_patterns = [] )
protected

Definition at line 2268 of file z3py.py.

2268def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2269 if z3_debug():
2270 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2271 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2272 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2273 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2274 if is_app(vs):
2275 ctx = vs.ctx
2276 vs = [vs]
2277 else:
2278 ctx = vs[0].ctx
2279 if not is_expr(body):
2280 body = BoolVal(body, ctx)
2281 num_vars = len(vs)
2282 if num_vars == 0:
2283 return body
2284 _vs = (Ast * num_vars)()
2285 for i in range(num_vars):
2286 # TODO: Check if is constant
2287 _vs[i] = vs[i].as_ast()
2288 patterns = [_to_pattern(p) for p in patterns]
2289 num_pats = len(patterns)
2290 _pats = (Pattern * num_pats)()
2291 for i in range(num_pats):
2292 _pats[i] = patterns[i].ast
2293 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2294 qid = to_symbol(qid, ctx)
2295 skid = to_symbol(skid, ctx)
2296 return QuantifierRef(Z3_mk_quantifier_const_ex(ctx.ref(), is_forall, weight, qid, skid,
2297 num_vars, _vs,
2298 num_pats, _pats,
2299 num_no_pats, _no_pats,
2300 body.as_ast()), ctx)
2301
2302
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...

Referenced by Exists(), and ForAll().

◆ _or_else()

_or_else ( t1,
t2,
ctx = None )
protected

Definition at line 8524 of file z3py.py.

8524def _or_else(t1, t2, ctx=None):
8525 t1 = _to_tactic(t1, ctx)
8526 t2 = _to_tactic(t2, ctx)
8527 if z3_debug():
8528 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8529 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8530
8531
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()

_pb_args_coeffs ( args,
default_ctx = None )
protected

Definition at line 9215 of file z3py.py.

9215def _pb_args_coeffs(args, default_ctx=None):
9216 args = _get_args_ast_list(args)
9217 if len(args) == 0:
9218 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9219 args = [_reorder_pb_arg(arg) for arg in args]
9220 args, coeffs = zip(*args)
9221 if z3_debug():
9222 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9223 ctx = _ctx_from_ast_arg_list(args)
9224 if z3_debug():
9225 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9226 args = _coerce_expr_list(args, ctx)
9227 _args, sz = _to_ast_array(args)
9228 _coeffs = (ctypes.c_int * len(coeffs))()
9229 for i in range(len(coeffs)):
9230 _z3_check_cint_overflow(coeffs[i], "coefficient")
9231 _coeffs[i] = coeffs[i]
9232 return ctx, sz, _args, _coeffs, args
9233
9234

◆ _probe_and()

_probe_and ( args,
ctx )
protected

Definition at line 8939 of file z3py.py.

8939def _probe_and(args, ctx):
8940 return _probe_nary(Z3_probe_and, args, ctx)
8941
8942

Referenced by And().

◆ _probe_nary()

_probe_nary ( f,
args,
ctx )
protected

Definition at line 8929 of file z3py.py.

8929def _probe_nary(f, args, ctx):
8930 if z3_debug():
8931 _z3_assert(len(args) > 0, "At least one argument expected")
8932 num = len(args)
8933 r = _to_probe(args[0], ctx)
8934 for i in range(num - 1):
8935 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8936 return r
8937
8938

◆ _probe_or()

_probe_or ( args,
ctx )
protected

Definition at line 8943 of file z3py.py.

8943def _probe_or(args, ctx):
8944 return _probe_nary(Z3_probe_or, args, ctx)
8945
8946

Referenced by Or().

◆ _prove_html()

_prove_html ( claim,
show = False,
** keywords )
protected
Version of function `prove` that renders HTML.

Definition at line 9406 of file z3py.py.

9406def _prove_html(claim, show=False, **keywords):
9407 """Version of function `prove` that renders HTML."""
9408 if z3_debug():
9409 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9410 s = Solver()
9411 s.set(**keywords)
9412 s.add(Not(claim))
9413 if show:
9414 print(s)
9415 r = s.check()
9416 if r == unsat:
9417 print("<b>proved</b>")
9418 elif r == unknown:
9419 print("<b>failed to prove</b>")
9420 print(s.model())
9421 else:
9422 print("<b>counterexample</b>")
9423 print(s.model())
9424
9425

◆ _py2expr()

_py2expr ( a,
ctx = None )
protected

Definition at line 3210 of file z3py.py.

3210def _py2expr(a, ctx=None):
3211 if isinstance(a, bool):
3212 return BoolVal(a, ctx)
3213 if _is_int(a):
3214 return IntVal(a, ctx)
3215 if isinstance(a, float):
3216 return RealVal(a, ctx)
3217 if isinstance(a, str):
3218 return StringVal(a, ctx)
3219 if is_expr(a):
3220 return a
3221 if z3_debug():
3222 _z3_assert(False, "Python bool, int, long or float expected")
3223
3224

Referenced by _coerce_expr_list(), _coerce_exprs(), IsMember(), K(), SetAdd(), SetDel(), SetHasSize(), and ModelRef.update_value().

◆ _reduce()

_reduce ( func,
sequence,
initial )
protected

Definition at line 1266 of file z3py.py.

1266def _reduce(func, sequence, initial):
1267 result = initial
1268 for element in sequence:
1269 result = func(result, element)
1270 return result
1271
1272

Referenced by _coerce_expr_list().

◆ _reorder_pb_arg()

_reorder_pb_arg ( arg)
protected

Definition at line 9208 of file z3py.py.

9208def _reorder_pb_arg(arg):
9209 a, b = arg
9210 if not _is_int(b) and _is_int(a):
9211 return b, a
9212 return arg
9213
9214

◆ _solve_html()

_solve_html ( * args,
** keywords )
protected
Version of function `solve` that renders HTML output.

Definition at line 9357 of file z3py.py.

9357def _solve_html(*args, **keywords):
9358 """Version of function `solve` that renders HTML output."""
9359 show = keywords.pop("show", False)
9360 s = Solver()
9361 s.set(**keywords)
9362 s.add(*args)
9363 if show:
9364 print("<b>Problem:</b>")
9365 print(s)
9366 r = s.check()
9367 if r == unsat:
9368 print("<b>no solution</b>")
9369 elif r == unknown:
9370 print("<b>failed to solve</b>")
9371 try:
9372 print(s.model())
9373 except Z3Exception:
9374 return
9375 else:
9376 if show:
9377 print("<b>Solution:</b>")
9378 print(s.model())
9379
9380

◆ _solve_using_html()

_solve_using_html ( s,
* args,
** keywords )
protected
Version of function `solve_using` that renders HTML.

Definition at line 9381 of file z3py.py.

9381def _solve_using_html(s, *args, **keywords):
9382 """Version of function `solve_using` that renders HTML."""
9383 show = keywords.pop("show", False)
9384 if z3_debug():
9385 _z3_assert(isinstance(s, Solver), "Solver object expected")
9386 s.set(**keywords)
9387 s.add(*args)
9388 if show:
9389 print("<b>Problem:</b>")
9390 print(s)
9391 r = s.check()
9392 if r == unsat:
9393 print("<b>no solution</b>")
9394 elif r == unknown:
9395 print("<b>failed to solve</b>")
9396 try:
9397 print(s.model())
9398 except Z3Exception:
9399 return
9400 else:
9401 if show:
9402 print("<b>Solution:</b>")
9403 print(s.model())
9404
9405

◆ _sort()

SortRef _sort ( Context ctx,
Any a )
protected

Definition at line 705 of file z3py.py.

705def _sort(ctx : Context, a : Any) -> SortRef:
706 return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
707
708
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.

◆ _sort_kind()

_sort_kind ( ctx,
s )
protected

Sorts.

Definition at line 569 of file z3py.py.

569def _sort_kind(ctx, s):
570 return Z3_get_sort_kind(ctx.ref(), s)
571
572
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).

Referenced by _to_sort_ref().

◆ _symbol2py()

_symbol2py ( ctx,
s )
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. """
142 if Z3_get_symbol_kind(ctx.ref(), s) == Z3_INT_SYMBOL:
143 return "k!%s" % Z3_get_symbol_int(ctx.ref(), s)
144 else:
145 return Z3_get_symbol_string(ctx.ref(), s)
146
147# Hack for having nary functions that can receive one argument that is the
148# list of arguments.
149# Use this when function takes a single list of arguments
150
151
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s)
Return Z3_INT_SYMBOL if the symbol was constructed using Z3_mk_int_symbol, and Z3_STRING_SYMBOL if th...
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.

Referenced by ParamDescrsRef.get_name(), SortRef.name(), QuantifierRef.qid(), QuantifierRef.skolem_id(), and QuantifierRef.var_name().

◆ _to_ast_array()

_to_ast_array ( args)
protected

Definition at line 537 of file z3py.py.

537def _to_ast_array(args):
538 sz = len(args)
539 _args = (Ast * sz)()
540 for i in range(sz):
541 _args[i] = args[i].as_ast()
542 return _args, sz
543
544

Referenced by ExprRef.__ne__(), _array_select(), _mk_quantifier(), And(), Distinct(), Map(), MultiPattern(), Or(), SetIntersect(), SetUnion(), and Update().

◆ _to_ast_ref()

_to_ast_ref ( a,
ctx )
protected

Definition at line 553 of file z3py.py.

553def _to_ast_ref(a, ctx):
554 k = _ast_kind(ctx, a)
555 if k == Z3_SORT_AST:
556 return _to_sort_ref(a, ctx)
557 elif k == Z3_FUNC_DECL_AST:
558 return _to_func_decl_ref(a, ctx)
559 else:
560 return _to_expr_ref(a, ctx)
561
562

Referenced by AstRef.__deepcopy__(), AstMap.__getitem__(), AstVector.__getitem__(), and AstRef.translate().

◆ _to_expr_ref()

_to_expr_ref ( a,
ctx )
protected

Definition at line 1176 of file z3py.py.

1176def _to_expr_ref(a, ctx):
1177 if isinstance(a, Pattern):
1178 return PatternRef(a, ctx)
1179 ctx_ref = ctx.ref()
1180 k = Z3_get_ast_kind(ctx_ref, a)
1181 if k == Z3_QUANTIFIER_AST:
1182 return QuantifierRef(a, ctx)
1183 sk = Z3_get_sort_kind(ctx_ref, Z3_get_sort(ctx_ref, a))
1184 if sk == Z3_BOOL_SORT:
1185 return BoolRef(a, ctx)
1186 if sk == Z3_INT_SORT:
1187 if k == Z3_NUMERAL_AST:
1188 return IntNumRef(a, ctx)
1189 return ArithRef(a, ctx)
1190 if sk == Z3_REAL_SORT:
1191 if k == Z3_NUMERAL_AST:
1192 return RatNumRef(a, ctx)
1193 if _is_algebraic(ctx, a):
1194 return AlgebraicNumRef(a, ctx)
1195 return ArithRef(a, ctx)
1196 if sk == Z3_BV_SORT:
1197 if k == Z3_NUMERAL_AST:
1198 return BitVecNumRef(a, ctx)
1199 else:
1200 return BitVecRef(a, ctx)
1201 if sk == Z3_ARRAY_SORT:
1202 return ArrayRef(a, ctx)
1203 if sk == Z3_DATATYPE_SORT:
1204 return DatatypeRef(a, ctx)
1205 if sk == Z3_FLOATING_POINT_SORT:
1206 if k == Z3_APP_AST and _is_numeral(ctx, a):
1207 return FPNumRef(a, ctx)
1208 else:
1209 return FPRef(a, ctx)
1210 if sk == Z3_FINITE_DOMAIN_SORT:
1211 if k == Z3_NUMERAL_AST:
1212 return FiniteDomainNumRef(a, ctx)
1213 else:
1214 return FiniteDomainRef(a, ctx)
1215 if sk == Z3_ROUNDING_MODE_SORT:
1216 return FPRMRef(a, ctx)
1217 if sk == Z3_SEQ_SORT:
1218 return SeqRef(a, ctx)
1219 if sk == Z3_CHAR_SORT:
1220 return CharRef(a, ctx)
1221 if sk == Z3_RE_SORT:
1222 return ReRef(a, ctx)
1223 return ExprRef(a, ctx)
1224
1225

Referenced by FuncDeclRef.__call__(), _array_select(), _to_ast_ref(), ExprRef.arg(), FuncEntry.arg_value(), QuantifierRef.body(), Const(), ArrayRef.default(), FuncInterp.else_value(), ModelRef.eval(), Ext(), FreshConst(), Goal.get(), ModelRef.get_interp(), If(), QuantifierRef.no_pattern(), ModelRef.project(), ModelRef.project_with_witness(), SetHasSize(), Update(), FuncEntry.value(), and Var().

◆ _to_float_str()

_to_float_str ( val,
exp = 0 )
protected

Definition at line 10161 of file z3py.py.

10161def _to_float_str(val, exp=0):
10162 if isinstance(val, float):
10163 if math.isnan(val):
10164 res = "NaN"
10165 elif val == 0.0:
10166 sone = math.copysign(1.0, val)
10167 if sone < 0.0:
10168 return "-0.0"
10169 else:
10170 return "+0.0"
10171 elif val == float("+inf"):
10172 res = "+oo"
10173 elif val == float("-inf"):
10174 res = "-oo"
10175 else:
10176 v = val.as_integer_ratio()
10177 num = v[0]
10178 den = v[1]
10179 rvs = str(num) + "/" + str(den)
10180 res = rvs + "p" + _to_int_str(exp)
10181 elif isinstance(val, bool):
10182 if val:
10183 res = "1.0"
10184 else:
10185 res = "0.0"
10186 elif _is_int(val):
10187 res = str(val)
10188 elif isinstance(val, str):
10189 inx = val.find("*(2**")
10190 if inx == -1:
10191 res = val
10192 elif val[-1] == ")":
10193 res = val[0:inx]
10194 exp = str(int(val[inx + 5:-1]) + int(exp))
10195 else:
10196 _z3_assert(False, "String does not have floating-point numeral form.")
10197 elif z3_debug():
10198 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10199 if exp == 0:
10200 return res
10201 else:
10202 return res + "p" + exp
10203
10204

◆ _to_func_decl_array()

_to_func_decl_array ( args)
protected

Definition at line 529 of file z3py.py.

529def _to_func_decl_array(args):
530 sz = len(args)
531 _args = (FuncDecl * sz)()
532 for i in range(sz):
533 _args[i] = args[i].as_func_decl()
534 return _args, sz
535
536

◆ _to_func_decl_ref()

_to_func_decl_ref ( a,
ctx )
protected

Definition at line 941 of file z3py.py.

941def _to_func_decl_ref(a, ctx):
942 return FuncDeclRef(a, ctx)
943
944

Referenced by _to_ast_ref().

◆ _to_goal()

_to_goal ( a)
protected

Definition at line 8500 of file z3py.py.

8500def _to_goal(a):
8501 if isinstance(a, BoolRef):
8502 goal = Goal(ctx=a.ctx)
8503 goal.add(a)
8504 return goal
8505 else:
8506 return a
8507
8508

◆ _to_int_str()

_to_int_str ( val)
protected

Definition at line 3259 of file z3py.py.

3259def _to_int_str(val):
3260 if isinstance(val, float):
3261 return str(int(val))
3262 elif isinstance(val, bool):
3263 if val:
3264 return "1"
3265 else:
3266 return "0"
3267 else:
3268 return str(val)
3269
3270

Referenced by BitVecVal(), and IntVal().

◆ _to_param_value()

_to_param_value ( val)
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()

_to_pattern ( arg)
protected

Definition at line 2046 of file z3py.py.

2046def _to_pattern(arg):
2047 if is_pattern(arg):
2048 return arg
2049 else:
2050 return MultiPattern(arg)
2051

Referenced by _mk_quantifier().

◆ _to_probe()

_to_probe ( p,
ctx = None )
protected

Definition at line 8883 of file z3py.py.

8883def _to_probe(p, ctx=None):
8884 if is_probe(p):
8885 return p
8886 else:
8887 return Probe(p, ctx)
8888
8889

◆ _to_ref_array()

_to_ref_array ( ref,
args )
protected

Definition at line 545 of file z3py.py.

545def _to_ref_array(ref, args):
546 sz = len(args)
547 _args = (ref * sz)()
548 for i in range(sz):
549 _args[i] = args[i].as_ast()
550 return _args, sz
551
552

◆ _to_sort_ref()

_to_sort_ref ( s,
ctx )
protected

Definition at line 674 of file z3py.py.

674def _to_sort_ref(s, ctx):
675 if z3_debug():
676 _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
677 k = _sort_kind(ctx, s)
678 if k == Z3_BOOL_SORT:
679 return BoolSortRef(s, ctx)
680 elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
681 return ArithSortRef(s, ctx)
682 elif k == Z3_BV_SORT:
683 return BitVecSortRef(s, ctx)
684 elif k == Z3_ARRAY_SORT:
685 return ArraySortRef(s, ctx)
686 elif k == Z3_DATATYPE_SORT:
687 return DatatypeSortRef(s, ctx)
688 elif k == Z3_FINITE_DOMAIN_SORT:
689 return FiniteDomainSortRef(s, ctx)
690 elif k == Z3_FLOATING_POINT_SORT:
691 return FPSortRef(s, ctx)
692 elif k == Z3_ROUNDING_MODE_SORT:
693 return FPRMSortRef(s, ctx)
694 elif k == Z3_RE_SORT:
695 return ReSortRef(s, ctx)
696 elif k == Z3_SEQ_SORT:
697 return SeqSortRef(s, ctx)
698 elif k == Z3_CHAR_SORT:
699 return CharSortRef(s, ctx)
700 elif k == Z3_TYPE_VAR:
701 return TypeVarRef(s, ctx)
702 return SortRef(s, ctx)
703
704

Referenced by _sort(), _to_ast_ref(), FuncDeclRef.domain(), ArraySortRef.domain_n(), ModelRef.get_sort(), ArraySortRef.range(), FuncDeclRef.range(), and QuantifierRef.var_sort().

◆ _to_tactic()

_to_tactic ( t,
ctx = None )
protected

Definition at line 8509 of file z3py.py.

8509def _to_tactic(t, ctx=None):
8510 if isinstance(t, Tactic):
8511 return t
8512 else:
8513 return Tactic(t, ctx)
8514
8515

◆ _valid_accessor()

_valid_accessor ( acc)
protected

Datatypes.

Return `True` if acc is pair of the form (String, Datatype or Sort). 

Definition at line 5127 of file z3py.py.

5127def _valid_accessor(acc):
5128 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5129 if not isinstance(acc, tuple):
5130 return False
5131 if len(acc) != 2:
5132 return False
5133 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5134
5135

Referenced by Datatype.declare_core().

◆ _z3_assert()

◆ _z3_check_cint_overflow()

_z3_check_cint_overflow ( n,
name )
protected

Definition at line 118 of file z3py.py.

118def _z3_check_cint_overflow(n, name):
119 _z3_assert(ctypes.c_int(n).value == n, name + " is too large")
120
121

◆ Abs()

Abs ( arg)
Create the absolute value of an arithmetic expression

Definition at line 9167 of file z3py.py.

9167def Abs(arg):
9168 """Create the absolute value of an arithmetic expression"""
9169 return If(arg > 0, arg, -arg)
9170
9171

◆ AllChar()

AllChar ( regex_sort,
ctx = None )
Create a regular expression that accepts all single character strings

Definition at line 11586 of file z3py.py.

11586def AllChar(regex_sort, ctx=None):
11587 """Create a regular expression that accepts all single character strings
11588 """
11589 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11590
11591# Special Relations
11592
11593
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 1920 of file z3py.py.

1920def And(*args):
1921 """Create a Z3 and-expression or and-probe.
1922
1923 >>> p, q, r = Bools('p q r')
1924 >>> And(p, q, r)
1925 And(p, q, r)
1926 >>> P = BoolVector('p', 5)
1927 >>> And(P)
1928 And(p__0, p__1, p__2, p__3, p__4)
1929 """
1930 last_arg = None
1931 if len(args) > 0:
1932 last_arg = args[len(args) - 1]
1933 if isinstance(last_arg, Context):
1934 ctx = args[len(args) - 1]
1935 args = args[:len(args) - 1]
1936 elif len(args) == 1 and isinstance(args[0], AstVector):
1937 ctx = args[0].ctx
1938 args = [a for a in args[0]]
1939 else:
1940 ctx = None
1941 args = _get_args(args)
1942 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1943 if z3_debug():
1944 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1945 if _has_probe(args):
1946 return _probe_and(args, ctx)
1947 else:
1948 args = _coerce_expr_list(args, ctx)
1949 _args, sz = _to_ast_array(args)
1950 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1951
1952
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 8532 of file z3py.py.

8532def AndThen(*ts, **ks):
8533 """Return a tactic that applies the tactics in `*ts` in sequence.
8534
8535 >>> x, y = Ints('x y')
8536 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8537 >>> t(And(x == 0, y > x + 1))
8538 [[Not(y <= 1)]]
8539 >>> t(And(x == 0, y > x + 1)).as_expr()
8540 Not(y <= 1)
8541 """
8542 if z3_debug():
8543 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8544 ctx = ks.get("ctx", None)
8545 num = len(ts)
8546 r = ts[0]
8547 for i in range(num - 1):
8548 r = _and_then(r, ts[i + 1], ctx)
8549 return r
8550
8551

◆ 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. """
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 5556 of file z3py.py.

5556def args2params(arguments, keywords, ctx=None):
5557 """Convert python arguments into a Z3_params object.
5558 A ':' is added to the keywords, and '_' is replaced with '-'
5559
5560 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5561 (params model true relevancy 2 elim_and true)
5562 """
5563 if z3_debug():
5564 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5565 prev = None
5566 r = ParamsRef(ctx)
5567 for a in arguments:
5568 if prev is None:
5569 prev = a
5570 else:
5571 r.set(prev, a)
5572 prev = None
5573 for k in keywords:
5574 v = keywords[k]
5575 r.set(k, v)
5576 return r
5577
5578

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 4823 of file z3py.py.

4823def Array(name, *sorts):
4824 """Return an array constant named `name` with the given domain and range sorts.
4825
4826 >>> a = Array('a', IntSort(), IntSort())
4827 >>> a.sort()
4828 Array(Int, Int)
4829 >>> a[0]
4830 a[0]
4831 """
4832 s = ArraySort(sorts)
4833 ctx = s.ctx
4834 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4835
4836
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 4790 of file z3py.py.

4790def ArraySort(*sig):
4791 """Return the Z3 array sort with the given domain and range sorts.
4792
4793 >>> A = ArraySort(IntSort(), BoolSort())
4794 >>> A
4795 Array(Int, Bool)
4796 >>> A.domain()
4797 Int
4798 >>> A.range()
4799 Bool
4800 >>> AA = ArraySort(IntSort(), A)
4801 >>> AA
4802 Array(Int, Array(Int, Bool))
4803 """
4804 sig = _get_args(sig)
4805 if z3_debug():
4806 _z3_assert(len(sig) > 1, "At least two arguments expected")
4807 arity = len(sig) - 1
4808 r = sig[arity]
4809 d = sig[0]
4810 if z3_debug():
4811 for s in sig:
4812 _z3_assert(is_sort(s), "Z3 sort expected")
4813 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4814 ctx = d.ctx
4815 if len(sig) == 2:
4816 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4817 dom = (Sort * arity)()
4818 for i in range(arity):
4819 dom[i] = sig[i].ast
4820 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4821
4822
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 Array(), and SetSort().

◆ AtLeast()

AtLeast ( * args)
Create an at-least Pseudo-Boolean k constraint.

>>> a, b, c = Bools('a b c')
>>> f = AtLeast(a, b, c, 2)

Definition at line 9190 of file z3py.py.

9190def AtLeast(*args):
9191 """Create an at-least Pseudo-Boolean k constraint.
9192
9193 >>> a, b, c = Bools('a b c')
9194 >>> f = AtLeast(a, b, c, 2)
9195 """
9196 args = _get_args(args)
9197 if z3_debug():
9198 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9199 ctx = _ctx_from_ast_arg_list(args)
9200 if z3_debug():
9201 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9202 args1 = _coerce_expr_list(args[:-1], ctx)
9203 k = args[-1]
9204 _args, sz = _to_ast_array(args1)
9205 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9206
9207
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 9172 of file z3py.py.

9172def AtMost(*args):
9173 """Create an at-most Pseudo-Boolean k constraint.
9174
9175 >>> a, b, c = Bools('a b c')
9176 >>> f = AtMost(a, b, c, 2)
9177 """
9178 args = _get_args(args)
9179 if z3_debug():
9180 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9181 ctx = _ctx_from_ast_arg_list(args)
9182 if z3_debug():
9183 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9184 args1 = _coerce_expr_list(args[:-1], ctx)
9185 k = args[-1]
9186 _args, sz = _to_ast_array(args1)
9187 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9188
9189
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 4127 of file z3py.py.

4127def BitVec(name, bv, ctx=None):
4128 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4129 If `ctx=None`, then the global context is used.
4130
4131 >>> x = BitVec('x', 16)
4132 >>> is_bv(x)
4133 True
4134 >>> x.size()
4135 16
4136 >>> x.sort()
4137 BitVec(16)
4138 >>> word = BitVecSort(16)
4139 >>> x2 = BitVec('x', word)
4140 >>> eq(x, x2)
4141 True
4142 """
4143 if isinstance(bv, BitVecSortRef):
4144 ctx = bv.ctx
4145 else:
4146 ctx = _get_ctx(ctx)
4147 bv = BitVecSort(bv, ctx)
4148 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4149
4150

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 4151 of file z3py.py.

4151def BitVecs(names, bv, ctx=None):
4152 """Return a tuple of bit-vector constants of size bv.
4153
4154 >>> x, y, z = BitVecs('x y z', 16)
4155 >>> x.size()
4156 16
4157 >>> x.sort()
4158 BitVec(16)
4159 >>> Sum(x, y, z)
4160 0 + x + y + z
4161 >>> Product(x, y, z)
4162 1*x*y*z
4163 >>> simplify(Product(x, y, z))
4164 x*y*z
4165 """
4166 ctx = _get_ctx(ctx)
4167 if isinstance(names, str):
4168 names = names.split(" ")
4169 return [BitVec(name, bv, ctx) for name in names]
4170
4171

◆ 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 4095 of file z3py.py.

4095def BitVecSort(sz, ctx=None):
4096 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4097
4098 >>> Byte = BitVecSort(8)
4099 >>> Word = BitVecSort(16)
4100 >>> Byte
4101 BitVec(8)
4102 >>> x = Const('x', Byte)
4103 >>> eq(x, BitVec('x', 8))
4104 True
4105 """
4106 ctx = _get_ctx(ctx)
4107 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4108
4109
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 4110 of file z3py.py.

4110def BitVecVal(val, bv, ctx=None):
4111 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4112
4113 >>> v = BitVecVal(10, 32)
4114 >>> v
4115 10
4116 >>> print("0x%.8x" % v.as_long())
4117 0x0000000a
4118 """
4119 if is_bv_sort(bv):
4120 ctx = bv.ctx
4121 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4122 else:
4123 ctx = _get_ctx(ctx)
4124 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4125
4126
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 1799 of file z3py.py.

1799def Bool(name, ctx=None):
1800 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1801
1802 >>> p = Bool('p')
1803 >>> q = Bool('q')
1804 >>> And(p, q)
1805 And(p, q)
1806 """
1807 ctx = _get_ctx(ctx)
1808 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1809
1810

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 1811 of file z3py.py.

1811def Bools(names, ctx=None):
1812 """Return a tuple of Boolean constants.
1813
1814 `names` is a single string containing all names separated by blank spaces.
1815 If `ctx=None`, then the global context is used.
1816
1817 >>> p, q, r = Bools('p q r')
1818 >>> And(p, Or(q, r))
1819 And(p, Or(q, r))
1820 """
1821 ctx = _get_ctx(ctx)
1822 if isinstance(names, str):
1823 names = names.split(" ")
1824 return [Bool(name, ctx) for name in names]
1825
1826

◆ 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 1762 of file z3py.py.

1762def BoolSort(ctx=None):
1763 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1764
1765 >>> BoolSort()
1766 Bool
1767 >>> p = Const('p', BoolSort())
1768 >>> is_bool(p)
1769 True
1770 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1771 >>> r(0, 1)
1772 r(0, 1)
1773 >>> is_bool(r(0, 1))
1774 True
1775 """
1776 ctx = _get_ctx(ctx)
1777 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1778
1779
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.

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 1780 of file z3py.py.

1780def BoolVal(val, ctx=None):
1781 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1782
1783 >>> BoolVal(True)
1784 True
1785 >>> is_true(BoolVal(True))
1786 True
1787 >>> is_true(True)
1788 False
1789 >>> is_false(BoolVal(False))
1790 True
1791 """
1792 ctx = _get_ctx(ctx)
1793 if val:
1794 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1795 else:
1796 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1797
1798
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.

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 1827 of file z3py.py.

1827def BoolVector(prefix, sz, ctx=None):
1828 """Return a list of Boolean constants of size `sz`.
1829
1830 The constants are named using the given prefix.
1831 If `ctx=None`, then the global context is used.
1832
1833 >>> P = BoolVector('p', 3)
1834 >>> P
1835 [p__0, p__1, p__2]
1836 >>> And(P)
1837 And(p__0, p__1, p__2)
1838 """
1839 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1840
1841

◆ 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 4063 of file z3py.py.

4063def BV2Int(a, is_signed=False):
4064 """Return the Z3 expression BV2Int(a).
4065
4066 >>> b = BitVec('b', 3)
4067 >>> BV2Int(b).sort()
4068 Int
4069 >>> x = Int('x')
4070 >>> x > BV2Int(b)
4071 x > BV2Int(b)
4072 >>> x > BV2Int(b, is_signed=False)
4073 x > BV2Int(b)
4074 >>> x > BV2Int(b, is_signed=True)
4075 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4076 >>> solve(x > BV2Int(b), b == 1, x < 3)
4077 [x = 2, b = 1]
4078 """
4079 if z3_debug():
4080 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4081 ctx = a.ctx
4082 # investigate problem with bv2int
4083 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
4084
4085
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 4549 of file z3py.py.

4549def BVAddNoOverflow(a, b, signed):
4550 """A predicate the determines that bit-vector addition does not overflow"""
4551 _check_bv_args(a, b)
4552 a, b = _coerce_exprs(a, b)
4553 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4554
4555
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 4556 of file z3py.py.

4556def BVAddNoUnderflow(a, b):
4557 """A predicate the determines that signed bit-vector addition does not underflow"""
4558 _check_bv_args(a, b)
4559 a, b = _coerce_exprs(a, b)
4560 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4561
4562
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 4591 of file z3py.py.

4591def BVMulNoOverflow(a, b, signed):
4592 """A predicate the determines that bit-vector multiplication does not overflow"""
4593 _check_bv_args(a, b)
4594 a, b = _coerce_exprs(a, b)
4595 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4596
4597
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 4598 of file z3py.py.

4598def BVMulNoUnderflow(a, b):
4599 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4600 _check_bv_args(a, b)
4601 a, b = _coerce_exprs(a, b)
4602 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4603
4604
Z3_ast Z3_API Z3_mk_bvmul_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed multiplication of t1 and t2 does not underflo...

◆ BVRedAnd()

BVRedAnd ( a)
Return the reduction-and expression of `a`.

Definition at line 4535 of file z3py.py.

4535def BVRedAnd(a):
4536 """Return the reduction-and expression of `a`."""
4537 if z3_debug():
4538 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4539 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4540
4541
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 4542 of file z3py.py.

4542def BVRedOr(a):
4543 """Return the reduction-or expression of `a`."""
4544 if z3_debug():
4545 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4546 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4547
4548
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 4577 of file z3py.py.

4577def BVSDivNoOverflow(a, b):
4578 """A predicate the determines that bit-vector signed division does not overflow"""
4579 _check_bv_args(a, b)
4580 a, b = _coerce_exprs(a, b)
4581 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4582
4583
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 4584 of file z3py.py.

4584def BVSNegNoOverflow(a):
4585 """A predicate the determines that bit-vector unary negation does not overflow"""
4586 if z3_debug():
4587 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4588 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4589
4590
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 4563 of file z3py.py.

4563def BVSubNoOverflow(a, b):
4564 """A predicate the determines that bit-vector subtraction does not overflow"""
4565 _check_bv_args(a, b)
4566 a, b = _coerce_exprs(a, b)
4567 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4568
4569
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 4570 of file z3py.py.

4570def BVSubNoUnderflow(a, b, signed):
4571 """A predicate the determines that bit-vector subtraction does not underflow"""
4572 _check_bv_args(a, b)
4573 a, b = _coerce_exprs(a, b)
4574 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4575
4576
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.

◆ Cbrt()

Cbrt ( a,
ctx = None )
 Return a Z3 expression which represents the cubic root of a.

>>> x = Real('x')
>>> Cbrt(x)
x**(1/3)

Definition at line 3509 of file z3py.py.

3509def Cbrt(a, ctx=None):
3510 """ Return a Z3 expression which represents the cubic root of a.
3511
3512 >>> x = Real('x')
3513 >>> Cbrt(x)
3514 x**(1/3)
3515 """
3516 if not is_expr(a):
3517 ctx = _get_ctx(ctx)
3518 a = RealVal(a, ctx)
3519 return a ** "1/3"
3520

◆ CharFromBv()

CharFromBv ( bv)

Definition at line 11104 of file z3py.py.

11104def CharFromBv(bv):
11105 if not is_expr(bv):
11106 raise Z3Exception("Bit-vector expression needed")
11107 return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
11108
Z3_ast Z3_API Z3_mk_char_from_bv(Z3_context c, Z3_ast bv)
Create a character from a bit-vector (code point).

◆ CharIsDigit()

CharIsDigit ( ch,
ctx = None )

Definition at line 11117 of file z3py.py.

11117def CharIsDigit(ch, ctx=None):
11118 ch = _coerce_char(ch, ctx)
11119 return ch.is_digit()
11120

◆ CharSort()

CharSort ( ctx = None)
Create a character sort
>>> ch = CharSort()
>>> print(ch)
Char

Definition at line 11000 of file z3py.py.

11000def CharSort(ctx=None):
11001 """Create a character sort
11002 >>> ch = CharSort()
11003 >>> print(ch)
11004 Char
11005 """
11006 ctx = _get_ctx(ctx)
11007 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
11008
11009
Z3_sort Z3_API Z3_mk_char_sort(Z3_context c)
Create a sort for unicode characters.

◆ CharToBv()

CharToBv ( ch,
ctx = None )

Definition at line 11109 of file z3py.py.

11109def CharToBv(ch, ctx=None):
11110 ch = _coerce_char(ch, ctx)
11111 return ch.to_bv()
11112

◆ CharToInt()

CharToInt ( ch,
ctx = None )

Definition at line 11113 of file z3py.py.

11113def CharToInt(ch, ctx=None):
11114 ch = _coerce_char(ch, ctx)
11115 return ch.to_int()
11116

◆ CharVal()

CharVal ( ch,
ctx = None )

Definition at line 11096 of file z3py.py.

11096def CharVal(ch, ctx=None):
11097 ctx = _get_ctx(ctx)
11098 if isinstance(ch, str):
11099 ch = ord(ch)
11100 if not isinstance(ch, int):
11101 raise Z3Exception("character value should be an ordinal")
11102 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
11103
Z3_ast Z3_API Z3_mk_char(Z3_context c, unsigned ch)
Create a character literal.

◆ Complement()

Complement ( re)
Create the complement regular expression.

Definition at line 11528 of file z3py.py.

11528def Complement(re):
11529 """Create the complement regular expression."""
11530 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11531
11532
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language 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 4172 of file z3py.py.

4172def Concat(*args):
4173 """Create a Z3 bit-vector concatenation expression.
4174
4175 >>> v = BitVecVal(1, 4)
4176 >>> Concat(v, v+1, v)
4177 Concat(Concat(1, 1 + 1), 1)
4178 >>> simplify(Concat(v, v+1, v))
4179 289
4180 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4181 121
4182 """
4183 args = _get_args(args)
4184 sz = len(args)
4185 if z3_debug():
4186 _z3_assert(sz >= 2, "At least two arguments expected.")
4187
4188 ctx = None
4189 for a in args:
4190 if is_expr(a):
4191 ctx = a.ctx
4192 break
4193 if is_seq(args[0]) or isinstance(args[0], str):
4194 args = [_coerce_seq(s, ctx) for s in args]
4195 if z3_debug():
4196 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4197 v = (Ast * sz)()
4198 for i in range(sz):
4199 v[i] = args[i].as_ast()
4200 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4201
4202 if is_re(args[0]):
4203 if z3_debug():
4204 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4205 v = (Ast * sz)()
4206 for i in range(sz):
4207 v[i] = args[i].as_ast()
4208 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4209
4210 if z3_debug():
4211 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4212 r = args[0]
4213 for i in range(sz - 1):
4214 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4215 return r
4216
4217
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 8989 of file z3py.py.

8989def Cond(p, t1, t2, ctx=None):
8990 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8991
8992 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8993 """
8994 p = _to_probe(p, ctx)
8995 t1 = _to_tactic(t1, ctx)
8996 t2 = _to_tactic(t2, ctx)
8997 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8998
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 1480 of file z3py.py.

1480def Const(name, sort):
1481 """Create a constant of the given sort.
1482
1483 >>> Const('x', IntSort())
1484 x
1485 """
1486 if z3_debug():
1487 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1488 ctx = sort.ctx
1489 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1490
1491

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 1492 of file z3py.py.

1492def Consts(names, sort):
1493 """Create several constants of the given sort.
1494
1495 `names` is a string containing the names of all constants to be created.
1496 Blank spaces separate the names of different constants.
1497
1498 >>> x, y, z = Consts('x y z', IntSort())
1499 >>> x + y + z
1500 x + y + z
1501 """
1502 if isinstance(names, str):
1503 names = names.split(" ")
1504 return [Const(name, sort) for name in names]
1505
1506

◆ 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 11273 of file z3py.py.

11273def Contains(a, b):
11274 """Check if 'a' contains 'b'
11275 >>> s1 = Contains("abc", "ab")
11276 >>> simplify(s1)
11277 True
11278 >>> s2 = Contains("abc", "bc")
11279 >>> simplify(s2)
11280 True
11281 >>> x, y, z = Strings('x y z')
11282 >>> s3 = Contains(Concat(x,y,z), y)
11283 >>> simplify(s3)
11284 True
11285 """
11286 ctx = _get_ctx2(a, b)
11287 a = _coerce_seq(a, ctx)
11288 b = _coerce_seq(b, ctx)
11289 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11290
11291
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 5248 of file z3py.py.

5248def CreateDatatypes(*ds):
5249 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5250
5251 In the following example we define a Tree-List using two mutually recursive datatypes.
5252
5253 >>> TreeList = Datatype('TreeList')
5254 >>> Tree = Datatype('Tree')
5255 >>> # Tree has two constructors: leaf and node
5256 >>> Tree.declare('leaf', ('val', IntSort()))
5257 >>> # a node contains a list of trees
5258 >>> Tree.declare('node', ('children', TreeList))
5259 >>> TreeList.declare('nil')
5260 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5261 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5262 >>> Tree.val(Tree.leaf(10))
5263 val(leaf(10))
5264 >>> simplify(Tree.val(Tree.leaf(10)))
5265 10
5266 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5267 >>> n1
5268 node(cons(leaf(10), cons(leaf(20), nil)))
5269 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5270 >>> simplify(n2 == n1)
5271 False
5272 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5273 True
5274 """
5275 ds = _get_args(ds)
5276 if z3_debug():
5277 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5278 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5279 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5280 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5281 ctx = ds[0].ctx
5282 num = len(ds)
5283 names = (Symbol * num)()
5284 out = (Sort * num)()
5285 clists = (ConstructorList * num)()
5286 to_delete = []
5287 for i in range(num):
5288 d = ds[i]
5289 names[i] = to_symbol(d.name, ctx)
5290 num_cs = len(d.constructors)
5291 cs = (Constructor * num_cs)()
5292 for j in range(num_cs):
5293 c = d.constructors[j]
5294 cname = to_symbol(c[0], ctx)
5295 rname = to_symbol(c[1], ctx)
5296 fs = c[2]
5297 num_fs = len(fs)
5298 fnames = (Symbol * num_fs)()
5299 sorts = (Sort * num_fs)()
5300 refs = (ctypes.c_uint * num_fs)()
5301 for k in range(num_fs):
5302 fname = fs[k][0]
5303 ftype = fs[k][1]
5304 fnames[k] = to_symbol(fname, ctx)
5305 if isinstance(ftype, Datatype):
5306 if z3_debug():
5307 _z3_assert(
5308 ds.count(ftype) == 1,
5309 "One and only one occurrence of each datatype is expected",
5310 )
5311 sorts[k] = None
5312 refs[k] = ds.index(ftype)
5313 else:
5314 if z3_debug():
5315 _z3_assert(is_sort(ftype), "Z3 sort expected")
5316 sorts[k] = ftype.ast
5317 refs[k] = 0
5318 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5319 to_delete.append(ScopedConstructor(cs[j], ctx))
5320 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5321 to_delete.append(ScopedConstructorList(clists[i], ctx))
5322 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5323 result = []
5324 # Create a field for every constructor, recognizer and accessor
5325 for i in range(num):
5326 dref = DatatypeSortRef(out[i], ctx)
5327 num_cs = dref.num_constructors()
5328 for j in range(num_cs):
5329 cref = dref.constructor(j)
5330 cref_name = cref.name()
5331 cref_arity = cref.arity()
5332 if cref.arity() == 0:
5333 cref = cref()
5334 setattr(dref, cref_name, cref)
5335 rref = dref.recognizer(j)
5336 setattr(dref, "is_" + cref_name, rref)
5337 for k in range(cref_arity):
5338 aref = dref.accessor(j, k)
5339 setattr(dref, aref.name(), aref)
5340 result.append(dref)
5341 return tuple(result)
5342
5343
void Z3_API Z3_mk_datatypes(Z3_context c, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort sorts[], Z3_constructor_list constructor_lists[])
Create mutually recursive datatypes.
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort const sorts[], unsigned sort_refs[])
Create a constructor.

Referenced by Datatype.create().

◆ DatatypeSort()

DatatypeSort ( name,
ctx = None )
Create a reference to a sort that was declared, or will be declared, as a recursive datatype

Definition at line 5448 of file z3py.py.

5448def DatatypeSort(name, ctx = None):
5449 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5450 ctx = _get_ctx(ctx)
5451 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5452
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name)
create a forward reference to a recursive datatype being declared. The forward reference can be used ...

◆ DeclareSort()

SortRef DeclareSort ( name,
ctx = None )
Create a new uninterpreted sort named `name`.

If `ctx=None`, then the new sort is declared in the global Z3Py context.

>>> A = DeclareSort('A')
>>> a = Const('a', A)
>>> b = Const('b', A)
>>> a.sort() == A
True
>>> b.sort() == A
True
>>> a == b
a == b

Definition at line 709 of file z3py.py.

709def DeclareSort(name, ctx= None) -> SortRef:
710 """Create a new uninterpreted sort named `name`.
711
712 If `ctx=None`, then the new sort is declared in the global Z3Py context.
713
714 >>> A = DeclareSort('A')
715 >>> a = Const('a', A)
716 >>> b = Const('b', A)
717 >>> a.sort() == A
718 True
719 >>> b.sort() == A
720 True
721 >>> a == b
722 a == b
723 """
724 ctx = _get_ctx(ctx)
725 return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
726
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 737 of file z3py.py.

737def DeclareTypeVar(name, ctx=None):
738 """Create a new type variable named `name`.
739
740 If `ctx=None`, then the new sort is declared in the global Z3Py context.
741
742 """
743 ctx = _get_ctx(ctx)
744 return TypeVarRef(Z3_mk_type_variable(ctx.ref(), to_symbol(name, ctx)), ctx)
745
746
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 4869 of file z3py.py.

4869def Default(a):
4870 """ Return a default value for array expression.
4871 >>> b = K(IntSort(), 1)
4872 >>> prove(Default(b) == 1)
4873 proved
4874 """
4875 if z3_debug():
4876 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4877 return a.default()
4878
4879

◆ describe_probes()

describe_probes ( )
Display a (tabular) description of all available probes in Z3.

Definition at line 8910 of file z3py.py.

8910def describe_probes():
8911 """Display a (tabular) description of all available probes in Z3."""
8912 if in_html_mode():
8913 even = True
8914 print('<table border="1" cellpadding="2" cellspacing="0">')
8915 for p in probes():
8916 if even:
8917 print('<tr style="background-color:#CFCFCF">')
8918 even = False
8919 else:
8920 print("<tr>")
8921 even = True
8922 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8923 print("</table>")
8924 else:
8925 for p in probes():
8926 print("%s : %s" % (p, probe_description(p)))
8927
8928

◆ describe_tactics()

describe_tactics ( )
Display a (tabular) description of all available tactics in Z3.

Definition at line 8704 of file z3py.py.

8704def describe_tactics():
8705 """Display a (tabular) description of all available tactics in Z3."""
8706 if in_html_mode():
8707 even = True
8708 print('<table border="1" cellpadding="2" cellspacing="0">')
8709 for t in tactics():
8710 if even:
8711 print('<tr style="background-color:#CFCFCF">')
8712 even = False
8713 else:
8714 print("<tr>")
8715 even = True
8716 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8717 print("</table>")
8718 else:
8719 for t in tactics():
8720 print("%s : %s" % (t, tactic_description(t)))
8721
8722

◆ 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 1162 of file z3py.py.

1162def deserialize(st):
1163 """inverse function to the serialize method on ExprRef.
1164 It is made available to make it easier for users to serialize expressions back and forth between
1165 strings. Solvers can be serialized using the 'sexpr()' method.
1166 """
1167 s = Solver()
1168 s.from_string(st)
1169 if len(s.assertions()) != 1:
1170 raise Z3Exception("single assertion expected")
1171 fml = s.assertions()[0]
1172 if fml.num_args() != 1:
1173 raise Z3Exception("dummy function 'F' expected")
1174 return fml.arg(0)
1175

◆ Diff()

Diff ( a,
b,
ctx = None )
Create the difference regular expression

Definition at line 11578 of file z3py.py.

11578def Diff(a, b, ctx=None):
11579 """Create the difference regular expression
11580 """
11581 if z3_debug():
11582 _z3_assert(is_expr(a), "expression expected")
11583 _z3_assert(is_expr(b), "expression expected")
11584 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11585
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):
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 5465 of file z3py.py.

5465def DisjointSum(name, sorts, ctx=None):
5466 """Create a named tagged union sort base on a set of underlying sorts
5467 Example:
5468 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5469 """
5470 sum = Datatype(name, ctx)
5471 for i in range(len(sorts)):
5472 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5473 sum = sum.create()
5474 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5475
5476

◆ 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 1447 of file z3py.py.

1447def Distinct(*args):
1448 """Create a Z3 distinct expression.
1449
1450 >>> x = Int('x')
1451 >>> y = Int('y')
1452 >>> Distinct(x, y)
1453 x != y
1454 >>> z = Int('z')
1455 >>> Distinct(x, y, z)
1456 Distinct(x, y, z)
1457 >>> simplify(Distinct(x, y, z))
1458 Distinct(x, y, z)
1459 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1460 And(Not(x == y), Not(x == z), Not(y == z))
1461 """
1462 args = _get_args(args)
1463 ctx = _ctx_from_ast_arg_list(args)
1464 if z3_debug():
1465 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1466 args = _coerce_expr_list(args, ctx)
1467 _args, sz = _to_ast_array(args)
1468 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1469
1470
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 11203 of file z3py.py.

11203def Empty(s):
11204 """Create the empty sequence of the given sort
11205 >>> e = Empty(StringSort())
11206 >>> e2 = StringVal("")
11207 >>> print(e.eq(e2))
11208 True
11209 >>> e3 = Empty(SeqSort(IntSort()))
11210 >>> print(e3)
11211 Empty(Seq(Int))
11212 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11213 >>> print(e4)
11214 Empty(ReSort(Seq(Int)))
11215 """
11216 if isinstance(s, SeqSortRef):
11217 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11218 if isinstance(s, ReSortRef):
11219 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11220 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11221
11222
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)
Create the empty set
>>> EmptySet(IntSort())
K(Int, False)

Definition at line 5012 of file z3py.py.

5012def EmptySet(s):
5013 """Create the empty set
5014 >>> EmptySet(IntSort())
5015 K(Int, False)
5016 """
5017 ctx = s.ctx
5018 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
5019
5020
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.

◆ enable_trace()

enable_trace ( msg)

Definition at line 83 of file z3py.py.

83def 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 ( )

Definition at line 11697 of file z3py.py.

11697def ensure_prop_closures():
11698 global _prop_closures
11699 if _prop_closures is None:
11700 _prop_closures = PropClosures()
11701
11702

◆ 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 5477 of file z3py.py.

5477def EnumSort(name, values, ctx=None):
5478 """Return a new enumeration sort named `name` containing the given values.
5479
5480 The result is a pair (sort, list of constants).
5481 Example:
5482 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5483 """
5484 if z3_debug():
5485 _z3_assert(isinstance(name, str), "Name must be a string")
5486 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
5487 _z3_assert(len(values) > 0, "At least one value expected")
5488 ctx = _get_ctx(ctx)
5489 num = len(values)
5490 _val_names = (Symbol * num)()
5491 for i in range(num):
5492 _val_names[i] = to_symbol(values[i], ctx)
5493 _values = (FuncDecl * num)()
5494 _testers = (FuncDecl * num)()
5495 name = to_symbol(name, ctx)
5496 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5497 V = []
5498 for i in range(num):
5499 V.append(FuncDeclRef(_values[i], ctx))
5500 V = [a() for a in V]
5501 return S, V
5502
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()

bool eq ( AstRef a,
AstRef b )
Return `True` if `a` and `b` are structurally identical AST nodes.

>>> x = Int('x')
>>> y = Int('y')
>>> eq(x, y)
False
>>> eq(x + 1, x + 1)
True
>>> eq(x + 1, 1 + x)
False
>>> eq(simplify(x + 1), simplify(1 + x))
True

Definition at line 486 of file z3py.py.

486def eq(a : AstRef, b : AstRef) -> bool:
487 """Return `True` if `a` and `b` are structurally identical AST nodes.
488
489 >>> x = Int('x')
490 >>> y = Int('y')
491 >>> eq(x, y)
492 False
493 >>> eq(x + 1, x + 1)
494 True
495 >>> eq(x + 1, 1 + x)
496 False
497 >>> eq(simplify(x + 1), simplify(1 + x))
498 True
499 """
500 if z3_debug():
501 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
502 return a.eq(b)
503
504

◆ Exists()

Exists ( vs,
body,
weight = 1,
qid = "",
skid = "",
patterns = [],
no_patterns = [] )
Create a Z3 exists formula.

The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.


>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> x = Int('x')
>>> y = Int('y')
>>> q = Exists([x, y], f(x, y) >= x, skid="foo")
>>> q
Exists([x, y], f(x, y) >= x)
>>> is_quantifier(q)
True
>>> r = Tactic('nnf')(q).as_expr()
>>> is_quantifier(r)
False

Definition at line 2321 of file z3py.py.

2321def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2322 """Create a Z3 exists formula.
2323
2324 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2325
2326
2327 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2328 >>> x = Int('x')
2329 >>> y = Int('y')
2330 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2331 >>> q
2332 Exists([x, y], f(x, y) >= x)
2333 >>> is_quantifier(q)
2334 True
2335 >>> r = Tactic('nnf')(q).as_expr()
2336 >>> is_quantifier(r)
2337 False
2338 """
2339 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2340
2341

◆ 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 4958 of file z3py.py.

4958def Ext(a, b):
4959 """Return extensionality index for one-dimensional arrays.
4960 >> a, b = Consts('a b', SetSort(IntSort()))
4961 >> Ext(a, b)
4962 Ext(a, b)
4963 """
4964 ctx = a.ctx
4965 if z3_debug():
4966 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4967 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4968
4969
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.
Extract is overloaded to also work on sequence extraction.
The functions SubString and SubSeq are redirected to Extract.
For this case, the arguments are reinterpreted as:
    high - is a sequence (string)
    low  - is an offset
    a    - is the length to be extracted

>>> x = BitVec('x', 8)
>>> Extract(6, 2, x)
Extract(6, 2, x)
>>> Extract(6, 2, x).sort()
BitVec(5)
>>> simplify(Extract(StringVal("abcd"),2,1))
"c"

Definition at line 4218 of file z3py.py.

4218def Extract(high, low, a):
4219 """Create a Z3 bit-vector extraction expression.
4220 Extract is overloaded to also work on sequence extraction.
4221 The functions SubString and SubSeq are redirected to Extract.
4222 For this case, the arguments are reinterpreted as:
4223 high - is a sequence (string)
4224 low - is an offset
4225 a - is the length to be extracted
4226
4227 >>> x = BitVec('x', 8)
4228 >>> Extract(6, 2, x)
4229 Extract(6, 2, x)
4230 >>> Extract(6, 2, x).sort()
4231 BitVec(5)
4232 >>> simplify(Extract(StringVal("abcd"),2,1))
4233 "c"
4234 """
4235 if isinstance(high, str):
4236 high = StringVal(high)
4237 if is_seq(high):
4238 s = high
4239 offset, length = _coerce_exprs(low, a, s.ctx)
4240 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4241 if z3_debug():
4242 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4243 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4244 "First and second arguments must be non negative integers")
4245 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4246 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4247
4248
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 8947 of file z3py.py.

8947def FailIf(p, ctx=None):
8948 """Return a tactic that fails if the probe `p` evaluates to true.
8949 Otherwise, it returns the input goal unmodified.
8950
8951 In the following example, the tactic applies 'simplify' if and only if there are
8952 more than 2 constraints in the goal.
8953
8954 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8955 >>> x, y = Ints('x y')
8956 >>> g = Goal()
8957 >>> g.add(x > 0)
8958 >>> g.add(y > 0)
8959 >>> t(g)
8960 [[x > 0, y > 0]]
8961 >>> g.add(x == y + 1)
8962 >>> t(g)
8963 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8964 """
8965 p = _to_probe(p, ctx)
8966 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8967
8968
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 7878 of file z3py.py.

7878def FiniteDomainSort(name, sz, ctx=None):
7879 """Create a named finite domain sort of a given size sz"""
7880 if not isinstance(name, Symbol):
7881 name = to_symbol(name)
7882 ctx = _get_ctx(ctx)
7883 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7884
7885
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 7948 of file z3py.py.

7948def FiniteDomainVal(val, sort, ctx=None):
7949 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7950
7951 >>> s = FiniteDomainSort('S', 256)
7952 >>> FiniteDomainVal(255, s)
7953 255
7954 >>> FiniteDomainVal('100', s)
7955 100
7956 """
7957 if z3_debug():
7958 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7959 ctx = sort.ctx
7960 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7961
7962

◆ Float128()

Float128 ( ctx = None)
Floating-point 128-bit (quadruple) sort.

Definition at line 9675 of file z3py.py.

9675def Float128(ctx=None):
9676 """Floating-point 128-bit (quadruple) sort."""
9677 ctx = _get_ctx(ctx)
9678 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9679
9680
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.

◆ Float16()

Float16 ( ctx = None)
Floating-point 16-bit (half) sort.

Definition at line 9639 of file z3py.py.

9639def Float16(ctx=None):
9640 """Floating-point 16-bit (half) sort."""
9641 ctx = _get_ctx(ctx)
9642 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9643
9644
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ Float32()

Float32 ( ctx = None)
Floating-point 32-bit (single) sort.

Definition at line 9651 of file z3py.py.

9651def Float32(ctx=None):
9652 """Floating-point 32-bit (single) sort."""
9653 ctx = _get_ctx(ctx)
9654 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9655
9656
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

◆ Float64()

Float64 ( ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 9663 of file z3py.py.

9663def Float64(ctx=None):
9664 """Floating-point 64-bit (double) sort."""
9665 ctx = _get_ctx(ctx)
9666 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9667
9668
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

◆ FloatDouble()

FloatDouble ( ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 9669 of file z3py.py.

9669def FloatDouble(ctx=None):
9670 """Floating-point 64-bit (double) sort."""
9671 ctx = _get_ctx(ctx)
9672 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9673
9674
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

◆ FloatHalf()

FloatHalf ( ctx = None)
Floating-point 16-bit (half) sort.

Definition at line 9645 of file z3py.py.

9645def FloatHalf(ctx=None):
9646 """Floating-point 16-bit (half) sort."""
9647 ctx = _get_ctx(ctx)
9648 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9649
9650
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ FloatQuadruple()

FloatQuadruple ( ctx = None)
Floating-point 128-bit (quadruple) sort.

Definition at line 9681 of file z3py.py.

9681def FloatQuadruple(ctx=None):
9682 """Floating-point 128-bit (quadruple) sort."""
9683 ctx = _get_ctx(ctx)
9684 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9685
9686
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 9657 of file z3py.py.

9657def FloatSingle(ctx=None):
9658 """Floating-point 32-bit (single) sort."""
9659 ctx = _get_ctx(ctx)
9660 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9661
9662
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 2303 of file z3py.py.

2303def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2304 """Create a Z3 forall formula.
2305
2306 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2307
2308 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2309 >>> x = Int('x')
2310 >>> y = Int('y')
2311 >>> ForAll([x, y], f(x, y) >= x)
2312 ForAll([x, y], f(x, y) >= x)
2313 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2314 ForAll([x, y], f(x, y) >= x)
2315 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2316 ForAll([x, y], f(x, y) >= x)
2317 """
2318 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2319
2320

◆ 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 10317 of file z3py.py.

10317def FP(name, fpsort, ctx=None):
10318 """Return a floating-point constant named `name`.
10319 `fpsort` is the floating-point sort.
10320 If `ctx=None`, then the global context is used.
10321
10322 >>> x = FP('x', FPSort(8, 24))
10323 >>> is_fp(x)
10324 True
10325 >>> x.ebits()
10326 8
10327 >>> x.sort()
10328 FPSort(8, 24)
10329 >>> word = FPSort(8, 24)
10330 >>> x2 = FP('x', word)
10331 >>> eq(x, x2)
10332 True
10333 """
10334 if isinstance(fpsort, FPSortRef) and ctx is None:
10335 ctx = fpsort.ctx
10336 else:
10337 ctx = _get_ctx(ctx)
10338 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10339
10340

◆ 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 10360 of file z3py.py.

10360def fpAbs(a, ctx=None):
10361 """Create a Z3 floating-point absolute value expression.
10362
10363 >>> s = FPSort(8, 24)
10364 >>> rm = RNE()
10365 >>> x = FPVal(1.0, s)
10366 >>> fpAbs(x)
10367 fpAbs(1)
10368 >>> y = FPVal(-20.0, s)
10369 >>> y
10370 -1.25*(2**4)
10371 >>> fpAbs(y)
10372 fpAbs(-1.25*(2**4))
10373 >>> fpAbs(-1.25*(2**4))
10374 fpAbs(-1.25*(2**4))
10375 >>> fpAbs(x).sort()
10376 FPSort(8, 24)
10377 """
10378 ctx = _get_ctx(ctx)
10379 [a] = _coerce_fp_expr_list([a], ctx)
10380 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10381
10382
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.

◆ 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 10451 of file z3py.py.

10451def fpAdd(rm, a, b, ctx=None):
10452 """Create a Z3 floating-point addition expression.
10453
10454 >>> s = FPSort(8, 24)
10455 >>> rm = RNE()
10456 >>> x = FP('x', s)
10457 >>> y = FP('y', s)
10458 >>> fpAdd(rm, x, y)
10459 x + y
10460 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10461 fpAdd(RTZ(), x, y)
10462 >>> fpAdd(rm, x, y).sort()
10463 FPSort(8, 24)
10464 """
10465 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10466
10467

◆ 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 10773 of file z3py.py.

10773def fpBVToFP(v, sort, ctx=None):
10774 """Create a Z3 floating-point conversion expression that represents the
10775 conversion from a bit-vector term to a floating-point term.
10776
10777 >>> x_bv = BitVecVal(0x3F800000, 32)
10778 >>> x_fp = fpBVToFP(x_bv, Float32())
10779 >>> x_fp
10780 fpToFP(1065353216)
10781 >>> simplify(x_fp)
10782 1
10783 """
10784 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10785 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10786 ctx = _get_ctx(ctx)
10787 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10788
10789
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 10498 of file z3py.py.

10498def fpDiv(rm, a, b, ctx=None):
10499 """Create a Z3 floating-point division expression.
10500
10501 >>> s = FPSort(8, 24)
10502 >>> rm = RNE()
10503 >>> x = FP('x', s)
10504 >>> y = FP('y', s)
10505 >>> fpDiv(rm, x, y)
10506 x / y
10507 >>> fpDiv(rm, x, y).sort()
10508 FPSort(8, 24)
10509 """
10510 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10511
10512

◆ 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 10681 of file z3py.py.

10681def fpEQ(a, b, ctx=None):
10682 """Create the Z3 floating-point expression `fpEQ(other, self)`.
10683
10684 >>> x, y = FPs('x y', FPSort(8, 24))
10685 >>> fpEQ(x, y)
10686 fpEQ(x, y)
10687 >>> fpEQ(x, y).sexpr()
10688 '(fp.eq x y)'
10689 """
10690 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10691
10692

◆ fpFMA()

fpFMA ( rm,
a,
b,
c,
ctx = None )
Create a Z3 floating-point fused multiply-add expression.

Definition at line 10557 of file z3py.py.

10557def fpFMA(rm, a, b, c, ctx=None):
10558 """Create a Z3 floating-point fused multiply-add expression.
10559 """
10560 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10561
10562

◆ 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 10705 of file z3py.py.

10705def fpFP(sgn, exp, sig, ctx=None):
10706 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10707
10708 >>> s = FPSort(8, 24)
10709 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10710 >>> print(x)
10711 fpFP(1, 127, 4194304)
10712 >>> xv = FPVal(-1.5, s)
10713 >>> print(xv)
10714 -1.5
10715 >>> slvr = Solver()
10716 >>> slvr.add(fpEQ(x, xv))
10717 >>> slvr.check()
10718 sat
10719 >>> xv = FPVal(+1.5, s)
10720 >>> print(xv)
10721 1.5
10722 >>> slvr = Solver()
10723 >>> slvr.add(fpEQ(x, xv))
10724 >>> slvr.check()
10725 unsat
10726 """
10727 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10728 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10729 ctx = _get_ctx(ctx)
10730 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10731 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10732
10733
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.

◆ fpFPToFP()

fpFPToFP ( rm,
v,
sort,
ctx = None )
Create a Z3 floating-point conversion expression that represents the
conversion from a floating-point term to a floating-point term of different precision.

>>> x_sgl = FPVal(1.0, Float32())
>>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
>>> x_dbl
fpToFP(RNE(), 1)
>>> simplify(x_dbl)
1
>>> x_dbl.sort()
FPSort(11, 53)

Definition at line 10790 of file z3py.py.

10790def fpFPToFP(rm, v, sort, ctx=None):
10791 """Create a Z3 floating-point conversion expression that represents the
10792 conversion from a floating-point term to a floating-point term of different precision.
10793
10794 >>> x_sgl = FPVal(1.0, Float32())
10795 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10796 >>> x_dbl
10797 fpToFP(RNE(), 1)
10798 >>> simplify(x_dbl)
10799 1
10800 >>> x_dbl.sort()
10801 FPSort(11, 53)
10802 """
10803 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10804 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10805 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10806 ctx = _get_ctx(ctx)
10807 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10808
10809
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 10669 of file z3py.py.

10669def fpGEQ(a, b, ctx=None):
10670 """Create the Z3 floating-point expression `other >= self`.
10671
10672 >>> x, y = FPs('x y', FPSort(8, 24))
10673 >>> fpGEQ(x, y)
10674 x >= y
10675 >>> (x >= y).sexpr()
10676 '(fp.geq x y)'
10677 """
10678 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10679
10680

◆ 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 10657 of file z3py.py.

10657def fpGT(a, b, ctx=None):
10658 """Create the Z3 floating-point expression `other > self`.
10659
10660 >>> x, y = FPs('x y', FPSort(8, 24))
10661 >>> fpGT(x, y)
10662 x > y
10663 >>> (x > y).sexpr()
10664 '(fp.gt x y)'
10665 """
10666 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10667
10668

◆ fpInfinity()

fpInfinity ( s,
negative )
Create a Z3 floating-point +oo or -oo term.

Definition at line 10245 of file z3py.py.

10245def fpInfinity(s, negative):
10246 """Create a Z3 floating-point +oo or -oo term."""
10247 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10248 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10249 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10250
10251
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 10587 of file z3py.py.

10587def fpIsInf(a, ctx=None):
10588 """Create a Z3 floating-point isInfinite expression.
10589
10590 >>> s = FPSort(8, 24)
10591 >>> x = FP('x', s)
10592 >>> fpIsInf(x)
10593 fpIsInf(x)
10594 """
10595 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10596
10597

◆ 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 10575 of file z3py.py.

10575def fpIsNaN(a, ctx=None):
10576 """Create a Z3 floating-point isNaN expression.
10577
10578 >>> s = FPSort(8, 24)
10579 >>> x = FP('x', s)
10580 >>> y = FP('y', s)
10581 >>> fpIsNaN(x)
10582 fpIsNaN(x)
10583 """
10584 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10585
10586

◆ fpIsNegative()

fpIsNegative ( a,
ctx = None )
Create a Z3 floating-point isNegative expression.

Definition at line 10616 of file z3py.py.

10616def fpIsNegative(a, ctx=None):
10617 """Create a Z3 floating-point isNegative expression.
10618 """
10619 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10620
10621

◆ fpIsNormal()

fpIsNormal ( a,
ctx = None )
Create a Z3 floating-point isNormal expression.

Definition at line 10604 of file z3py.py.

10604def fpIsNormal(a, ctx=None):
10605 """Create a Z3 floating-point isNormal expression.
10606 """
10607 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10608
10609

◆ fpIsPositive()

fpIsPositive ( a,
ctx = None )
Create a Z3 floating-point isPositive expression.

Definition at line 10622 of file z3py.py.

10622def fpIsPositive(a, ctx=None):
10623 """Create a Z3 floating-point isPositive expression.
10624 """
10625 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10626
10627

◆ fpIsSubnormal()

fpIsSubnormal ( a,
ctx = None )
Create a Z3 floating-point isSubnormal expression.

Definition at line 10610 of file z3py.py.

10610def fpIsSubnormal(a, ctx=None):
10611 """Create a Z3 floating-point isSubnormal expression.
10612 """
10613 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10614
10615

◆ fpIsZero()

fpIsZero ( a,
ctx = None )
Create a Z3 floating-point isZero expression.

Definition at line 10598 of file z3py.py.

10598def fpIsZero(a, ctx=None):
10599 """Create a Z3 floating-point isZero expression.
10600 """
10601 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10602
10603

◆ 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 10645 of file z3py.py.

10645def fpLEQ(a, b, ctx=None):
10646 """Create the Z3 floating-point expression `other <= self`.
10647
10648 >>> x, y = FPs('x y', FPSort(8, 24))
10649 >>> fpLEQ(x, y)
10650 x <= y
10651 >>> (x <= y).sexpr()
10652 '(fp.leq x y)'
10653 """
10654 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10655
10656

◆ 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 10633 of file z3py.py.

10633def fpLT(a, b, ctx=None):
10634 """Create the Z3 floating-point expression `other < self`.
10635
10636 >>> x, y = FPs('x y', FPSort(8, 24))
10637 >>> fpLT(x, y)
10638 x < y
10639 >>> (x < y).sexpr()
10640 '(fp.lt x y)'
10641 """
10642 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10643
10644

◆ 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 10542 of file z3py.py.

10542def fpMax(a, b, ctx=None):
10543 """Create a Z3 floating-point maximum expression.
10544
10545 >>> s = FPSort(8, 24)
10546 >>> rm = RNE()
10547 >>> x = FP('x', s)
10548 >>> y = FP('y', s)
10549 >>> fpMax(x, y)
10550 fpMax(x, y)
10551 >>> fpMax(x, y).sort()
10552 FPSort(8, 24)
10553 """
10554 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10555
10556

◆ 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 10527 of file z3py.py.

10527def fpMin(a, b, ctx=None):
10528 """Create a Z3 floating-point minimum expression.
10529
10530 >>> s = FPSort(8, 24)
10531 >>> rm = RNE()
10532 >>> x = FP('x', s)
10533 >>> y = FP('y', s)
10534 >>> fpMin(x, y)
10535 fpMin(x, y)
10536 >>> fpMin(x, y).sort()
10537 FPSort(8, 24)
10538 """
10539 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10540
10541

◆ fpMinusInfinity()

fpMinusInfinity ( s)
Create a Z3 floating-point -oo term.

Definition at line 10239 of file z3py.py.

10239def fpMinusInfinity(s):
10240 """Create a Z3 floating-point -oo term."""
10241 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10242 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10243
10244

◆ fpMinusZero()

fpMinusZero ( s)
Create a Z3 floating-point -0.0 term.

Definition at line 10258 of file z3py.py.

10258def fpMinusZero(s):
10259 """Create a Z3 floating-point -0.0 term."""
10260 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10261 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10262
10263
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 10483 of file z3py.py.

10483def fpMul(rm, a, b, ctx=None):
10484 """Create a Z3 floating-point multiplication expression.
10485
10486 >>> s = FPSort(8, 24)
10487 >>> rm = RNE()
10488 >>> x = FP('x', s)
10489 >>> y = FP('y', s)
10490 >>> fpMul(rm, x, y)
10491 x * y
10492 >>> fpMul(rm, x, y).sort()
10493 FPSort(8, 24)
10494 """
10495 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10496
10497

◆ 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 10205 of file z3py.py.

10205def fpNaN(s):
10206 """Create a Z3 floating-point NaN term.
10207
10208 >>> s = FPSort(8, 24)
10209 >>> set_fpa_pretty(True)
10210 >>> fpNaN(s)
10211 NaN
10212 >>> pb = get_fpa_pretty()
10213 >>> set_fpa_pretty(False)
10214 >>> fpNaN(s)
10215 fpNaN(FPSort(8, 24))
10216 >>> set_fpa_pretty(pb)
10217 """
10218 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10219 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10220
10221
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 10383 of file z3py.py.

10383def fpNeg(a, ctx=None):
10384 """Create a Z3 floating-point addition expression.
10385
10386 >>> s = FPSort(8, 24)
10387 >>> rm = RNE()
10388 >>> x = FP('x', s)
10389 >>> fpNeg(x)
10390 -x
10391 >>> fpNeg(x).sort()
10392 FPSort(8, 24)
10393 """
10394 ctx = _get_ctx(ctx)
10395 [a] = _coerce_fp_expr_list([a], ctx)
10396 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10397
10398
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.

◆ 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 10693 of file z3py.py.

10693def fpNEQ(a, b, ctx=None):
10694 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10695
10696 >>> x, y = FPs('x y', FPSort(8, 24))
10697 >>> fpNEQ(x, y)
10698 Not(fpEQ(x, y))
10699 >>> (x != y).sexpr()
10700 '(distinct x y)'
10701 """
10702 return Not(fpEQ(a, b, ctx))
10703
10704

◆ 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 10222 of file z3py.py.

10222def fpPlusInfinity(s):
10223 """Create a Z3 floating-point +oo term.
10224
10225 >>> s = FPSort(8, 24)
10226 >>> pb = get_fpa_pretty()
10227 >>> set_fpa_pretty(True)
10228 >>> fpPlusInfinity(s)
10229 +oo
10230 >>> set_fpa_pretty(False)
10231 >>> fpPlusInfinity(s)
10232 fpPlusInfinity(FPSort(8, 24))
10233 >>> set_fpa_pretty(pb)
10234 """
10235 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10236 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10237
10238

◆ fpPlusZero()

fpPlusZero ( s)
Create a Z3 floating-point +0.0 term.

Definition at line 10252 of file z3py.py.

10252def fpPlusZero(s):
10253 """Create a Z3 floating-point +0.0 term."""
10254 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10255 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10256
10257

◆ 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 10810 of file z3py.py.

10810def fpRealToFP(rm, v, sort, ctx=None):
10811 """Create a Z3 floating-point conversion expression that represents the
10812 conversion from a real term to a floating-point term.
10813
10814 >>> x_r = RealVal(1.5)
10815 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10816 >>> x_fp
10817 fpToFP(RNE(), 3/2)
10818 >>> simplify(x_fp)
10819 1.5
10820 """
10821 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10822 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10823 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10824 ctx = _get_ctx(ctx)
10825 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10826
10827
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 10513 of file z3py.py.

10513def fpRem(a, b, ctx=None):
10514 """Create a Z3 floating-point remainder expression.
10515
10516 >>> s = FPSort(8, 24)
10517 >>> x = FP('x', s)
10518 >>> y = FP('y', s)
10519 >>> fpRem(x, y)
10520 fpRem(x, y)
10521 >>> fpRem(x, y).sort()
10522 FPSort(8, 24)
10523 """
10524 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10525
10526

◆ fpRoundToIntegral()

fpRoundToIntegral ( rm,
a,
ctx = None )
Create a Z3 floating-point roundToIntegral expression.

Definition at line 10569 of file z3py.py.

10569def fpRoundToIntegral(rm, a, ctx=None):
10570 """Create a Z3 floating-point roundToIntegral expression.
10571 """
10572 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10573
10574

◆ 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 10341 of file z3py.py.

10341def FPs(names, fpsort, ctx=None):
10342 """Return an array of floating-point constants.
10343
10344 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10345 >>> x.sort()
10346 FPSort(8, 24)
10347 >>> x.sbits()
10348 24
10349 >>> x.ebits()
10350 8
10351 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10352 (x + y) * z
10353 """
10354 ctx = _get_ctx(ctx)
10355 if isinstance(names, str):
10356 names = names.split(" ")
10357 return [FP(name, fpsort, ctx) for name in names]
10358
10359

◆ 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 10828 of file z3py.py.

10828def fpSignedToFP(rm, v, sort, ctx=None):
10829 """Create a Z3 floating-point conversion expression that represents the
10830 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10831
10832 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10833 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10834 >>> x_fp
10835 fpToFP(RNE(), 4294967291)
10836 >>> simplify(x_fp)
10837 -1.25*(2**2)
10838 """
10839 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10840 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10841 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10842 ctx = _get_ctx(ctx)
10843 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10844
10845
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 10146 of file z3py.py.

10146def FPSort(ebits, sbits, ctx=None):
10147 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10148
10149 >>> Single = FPSort(8, 24)
10150 >>> Double = FPSort(11, 53)
10151 >>> Single
10152 FPSort(8, 24)
10153 >>> x = Const('x', Single)
10154 >>> eq(x, FP('x', FPSort(8, 24)))
10155 True
10156 """
10157 ctx = _get_ctx(ctx)
10158 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
10159
10160
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 )
Create a Z3 floating-point square root expression.

Definition at line 10563 of file z3py.py.

10563def fpSqrt(rm, a, ctx=None):
10564 """Create a Z3 floating-point square root expression.
10565 """
10566 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10567
10568

◆ 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 10468 of file z3py.py.

10468def fpSub(rm, a, b, ctx=None):
10469 """Create a Z3 floating-point subtraction expression.
10470
10471 >>> s = FPSort(8, 24)
10472 >>> rm = RNE()
10473 >>> x = FP('x', s)
10474 >>> y = FP('y', s)
10475 >>> fpSub(rm, x, y)
10476 x - y
10477 >>> fpSub(rm, x, y).sort()
10478 FPSort(8, 24)
10479 """
10480 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10481
10482

◆ 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 10734 of file z3py.py.

10734def fpToFP(a1, a2=None, a3=None, ctx=None):
10735 """Create a Z3 floating-point conversion expression from other term sorts
10736 to floating-point.
10737
10738 From a bit-vector term in IEEE 754-2008 format:
10739 >>> x = FPVal(1.0, Float32())
10740 >>> x_bv = fpToIEEEBV(x)
10741 >>> simplify(fpToFP(x_bv, Float32()))
10742 1
10743
10744 From a floating-point term with different precision:
10745 >>> x = FPVal(1.0, Float32())
10746 >>> x_db = fpToFP(RNE(), x, Float64())
10747 >>> x_db.sort()
10748 FPSort(11, 53)
10749
10750 From a real term:
10751 >>> x_r = RealVal(1.5)
10752 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10753 1.5
10754
10755 From a signed bit-vector term:
10756 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10757 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10758 -1.25*(2**2)
10759 """
10760 ctx = _get_ctx(ctx)
10761 if is_bv(a1) and is_fp_sort(a2):
10762 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10763 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10764 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10765 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10766 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10767 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10768 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10769 else:
10770 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10771
10772

◆ 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 10864 of file z3py.py.

10864def fpToFPUnsigned(rm, x, s, ctx=None):
10865 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10866 if z3_debug():
10867 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10868 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10869 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10870 ctx = _get_ctx(ctx)
10871 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10872
10873
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 10938 of file z3py.py.

10938def fpToIEEEBV(x, ctx=None):
10939 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10940
10941 The size of the resulting bit-vector is automatically determined.
10942
10943 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10944 knows only one NaN and it will always produce the same bit-vector representation of
10945 that NaN.
10946
10947 >>> x = FP('x', FPSort(8, 24))
10948 >>> y = fpToIEEEBV(x)
10949 >>> print(is_fp(x))
10950 True
10951 >>> print(is_bv(y))
10952 True
10953 >>> print(is_fp(y))
10954 False
10955 >>> print(is_bv(x))
10956 False
10957 """
10958 if z3_debug():
10959 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10960 ctx = _get_ctx(ctx)
10961 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10962
10963
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 10918 of file z3py.py.

10918def fpToReal(x, ctx=None):
10919 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10920
10921 >>> x = FP('x', FPSort(8, 24))
10922 >>> y = fpToReal(x)
10923 >>> print(is_fp(x))
10924 True
10925 >>> print(is_real(y))
10926 True
10927 >>> print(is_fp(y))
10928 False
10929 >>> print(is_real(x))
10930 False
10931 """
10932 if z3_debug():
10933 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10934 ctx = _get_ctx(ctx)
10935 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10936
10937
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 10874 of file z3py.py.

10874def fpToSBV(rm, x, s, ctx=None):
10875 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10876
10877 >>> x = FP('x', FPSort(8, 24))
10878 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10879 >>> print(is_fp(x))
10880 True
10881 >>> print(is_bv(y))
10882 True
10883 >>> print(is_fp(y))
10884 False
10885 >>> print(is_bv(x))
10886 False
10887 """
10888 if z3_debug():
10889 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10890 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10891 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10892 ctx = _get_ctx(ctx)
10893 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10894
10895
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 10896 of file z3py.py.

10896def fpToUBV(rm, x, s, ctx=None):
10897 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10898
10899 >>> x = FP('x', FPSort(8, 24))
10900 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10901 >>> print(is_fp(x))
10902 True
10903 >>> print(is_bv(y))
10904 True
10905 >>> print(is_fp(y))
10906 False
10907 >>> print(is_bv(x))
10908 False
10909 """
10910 if z3_debug():
10911 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10912 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10913 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10914 ctx = _get_ctx(ctx)
10915 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10916
10917
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 10846 of file z3py.py.

10846def fpUnsignedToFP(rm, v, sort, ctx=None):
10847 """Create a Z3 floating-point conversion expression that represents the
10848 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10849
10850 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10851 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10852 >>> x_fp
10853 fpToFPUnsigned(RNE(), 4294967291)
10854 >>> simplify(x_fp)
10855 1*(2**32)
10856 """
10857 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10858 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10859 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10860 ctx = _get_ctx(ctx)
10861 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10862
10863

◆ 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 10271 of file z3py.py.

10271def FPVal(sig, exp=None, fps=None, ctx=None):
10272 """Return a floating-point value of value `val` and sort `fps`.
10273 If `ctx=None`, then the global context is used.
10274
10275 >>> v = FPVal(20.0, FPSort(8, 24))
10276 >>> v
10277 1.25*(2**4)
10278 >>> print("0x%.8x" % v.exponent_as_long(False))
10279 0x00000004
10280 >>> v = FPVal(2.25, FPSort(8, 24))
10281 >>> v
10282 1.125*(2**1)
10283 >>> v = FPVal(-2.25, FPSort(8, 24))
10284 >>> v
10285 -1.125*(2**1)
10286 >>> FPVal(-0.0, FPSort(8, 24))
10287 -0.0
10288 >>> FPVal(0.0, FPSort(8, 24))
10289 +0.0
10290 >>> FPVal(+0.0, FPSort(8, 24))
10291 +0.0
10292 """
10293 ctx = _get_ctx(ctx)
10294 if is_fp_sort(exp):
10295 fps = exp
10296 exp = None
10297 elif fps is None:
10298 fps = _dflt_fps(ctx)
10299 _z3_assert(is_fp_sort(fps), "sort mismatch")
10300 if exp is None:
10301 exp = 0
10302 val = _to_float_str(sig)
10303 if val == "NaN" or val == "nan":
10304 return fpNaN(fps)
10305 elif val == "-0.0":
10306 return fpMinusZero(fps)
10307 elif val == "0.0" or val == "+0.0":
10308 return fpPlusZero(fps)
10309 elif val == "+oo" or val == "+inf" or val == "+Inf":
10310 return fpPlusInfinity(fps)
10311 elif val == "-oo" or val == "-inf" or val == "-Inf":
10312 return fpMinusInfinity(fps)
10313 else:
10314 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10315
10316

◆ fpZero()

fpZero ( s,
negative )
Create a Z3 floating-point +0.0 or -0.0 term.

Definition at line 10264 of file z3py.py.

10264def fpZero(s, negative):
10265 """Create a Z3 floating-point +0.0 or -0.0 term."""
10266 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10267 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10268 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10269
10270

◆ 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 1842 of file z3py.py.

1842def FreshBool(prefix="b", ctx=None):
1843 """Return a fresh Boolean constant in the given context using the given prefix.
1844
1845 If `ctx=None`, then the global context is used.
1846
1847 >>> b1 = FreshBool()
1848 >>> b2 = FreshBool()
1849 >>> eq(b1, b2)
1850 False
1851 """
1852 ctx = _get_ctx(ctx)
1853 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1854
1855
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 1507 of file z3py.py.

1507def FreshConst(sort, prefix="c"):
1508 """Create a fresh constant of a specified sort"""
1509 ctx = _get_ctx(sort.ctx)
1510 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1511
1512

◆ FreshFunction()

FreshFunction ( * sig)
Create a new fresh Z3 uninterpreted function with the given sorts.

Definition at line 922 of file z3py.py.

922def FreshFunction(*sig):
923 """Create a new fresh Z3 uninterpreted function with the given sorts.
924 """
925 sig = _get_args(sig)
926 if z3_debug():
927 _z3_assert(len(sig) > 0, "At least two arguments expected")
928 arity = len(sig) - 1
929 rng = sig[arity]
930 if z3_debug():
931 _z3_assert(is_sort(rng), "Z3 sort expected")
932 dom = (z3.Sort * arity)()
933 for i in range(arity):
934 if z3_debug():
935 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
936 dom[i] = sig[i].ast
937 ctx = rng.ctx
938 return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), "f", arity, dom, rng.ast), ctx)
939
940
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 3370 of file z3py.py.

3370def FreshInt(prefix="x", ctx=None):
3371 """Return a fresh integer constant in the given context using the given prefix.
3372
3373 >>> x = FreshInt()
3374 >>> y = FreshInt()
3375 >>> eq(x, y)
3376 False
3377 >>> x.sort()
3378 Int
3379 """
3380 ctx = _get_ctx(ctx)
3381 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3382
3383

◆ 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 3427 of file z3py.py.

3427def FreshReal(prefix="b", ctx=None):
3428 """Return a fresh real constant in the given context using the given prefix.
3429
3430 >>> x = FreshReal()
3431 >>> y = FreshReal()
3432 >>> eq(x, y)
3433 False
3434 >>> x.sort()
3435 Real
3436 """
3437 ctx = _get_ctx(ctx)
3438 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3439
3440

◆ 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 11223 of file z3py.py.

11223def Full(s):
11224 """Create the regular expression that accepts the universal language
11225 >>> e = Full(ReSort(SeqSort(IntSort())))
11226 >>> print(e)
11227 Full(ReSort(Seq(Int)))
11228 >>> e1 = Full(ReSort(StringSort()))
11229 >>> print(e1)
11230 Full(ReSort(String))
11231 """
11232 if isinstance(s, ReSortRef):
11233 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11234 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11235
11236
11237
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)
Create the full set
>>> FullSet(IntSort())
K(Int, True)

Definition at line 5021 of file z3py.py.

5021def FullSet(s):
5022 """Create the full set
5023 >>> FullSet(IntSort())
5024 K(Int, True)
5025 """
5026 ctx = s.ctx
5027 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
5028
5029
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.

◆ 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 899 of file z3py.py.

899def Function(name, *sig):
900 """Create a new Z3 uninterpreted function with the given sorts.
901
902 >>> f = Function('f', IntSort(), IntSort())
903 >>> f(f(0))
904 f(f(0))
905 """
906 sig = _get_args(sig)
907 if z3_debug():
908 _z3_assert(len(sig) > 0, "At least two arguments expected")
909 arity = len(sig) - 1
910 rng = sig[arity]
911 if z3_debug():
912 _z3_assert(is_sort(rng), "Z3 sort expected")
913 dom = (Sort * arity)()
914 for i in range(arity):
915 if z3_debug():
916 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
917 dom[i] = sig[i].ast
918 ctx = rng.ctx
919 return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
920
921
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 6816 of file z3py.py.

6816def get_as_array_func(n):
6817 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6818 if z3_debug():
6819 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6820 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6821
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)

Definition at line 277 of file z3py.py.

277def get_ctx(ctx) -> Context:
278 return _get_ctx(ctx)
279
280

◆ get_default_fp_sort()

get_default_fp_sort ( ctx = None)

Definition at line 9558 of file z3py.py.

9558def get_default_fp_sort(ctx=None):
9559 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9560
9561

◆ get_default_rounding_mode()

get_default_rounding_mode ( ctx = None)
Retrieves the global default rounding mode.

Definition at line 9525 of file z3py.py.

9525def get_default_rounding_mode(ctx=None):
9526 """Retrieves the global default rounding mode."""
9527 global _dflt_rounding_mode
9528 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9529 return RTZ(ctx)
9530 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9531 return RTN(ctx)
9532 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9533 return RTP(ctx)
9534 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9535 return RNE(ctx)
9536 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9537 return RNA(ctx)
9538
9539

◆ get_full_version()

get_full_version ( )

Definition at line 109 of file z3py.py.

109def get_full_version():
110 return Z3_get_full_version()
111
112
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.

◆ 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 4766 of file z3py.py.

4766def get_map_func(a):
4767 """Return the function declaration associated with a Z3 map array expression.
4768
4769 >>> f = Function('f', IntSort(), IntSort())
4770 >>> b = Array('b', IntSort(), IntSort())
4771 >>> a = Map(f, b)
4772 >>> eq(f, get_map_func(a))
4773 True
4774 >>> get_map_func(a)
4775 f
4776 >>> get_map_func(a)(0)
4777 f(0)
4778 """
4779 if z3_debug():
4780 _z3_assert(is_map(a), "Z3 array map expression expected.")
4781 return FuncDeclRef(
4783 a.ctx_ref(),
4784 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4785 ),
4786 ctx=a.ctx,
4787 )
4788
4789
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.

◆ get_param()

get_param ( name)
Return the value of a Z3 global (or module) parameter

>>> get_param('nlsat.reorder')
'true'

Definition at line 317 of file z3py.py.

317def get_param(name):
318 """Return the value of a Z3 global (or module) parameter
319
320 >>> get_param('nlsat.reorder')
321 'true'
322 """
323 ptr = (ctypes.c_char_p * 1)()
324 if Z3_global_param_get(str(name), ptr):
325 r = z3core._to_pystr(ptr[0])
326 return r
327 raise Z3Exception("failed to retrieve value for '%s'" % name)
328
bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.

◆ get_var_index()

get_var_index ( a)
Return the de-Bruijn index of the Z3 bounded variable `a`.

>>> x = Int('x')
>>> y = Int('y')
>>> is_var(x)
False
>>> is_const(x)
True
>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> # Z3 replaces x and y with bound variables when ForAll is executed.
>>> q = ForAll([x, y], f(x, y) == x + y)
>>> q.body()
f(Var(1), Var(0)) == Var(1) + Var(0)
>>> b = q.body()
>>> b.arg(0)
f(Var(1), Var(0))
>>> v1 = b.arg(0).arg(0)
>>> v2 = b.arg(0).arg(1)
>>> v1
Var(1)
>>> v2
Var(0)
>>> get_var_index(v1)
1
>>> get_var_index(v2)
0

Definition at line 1378 of file z3py.py.

1378def get_var_index(a):
1379 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1380
1381 >>> x = Int('x')
1382 >>> y = Int('y')
1383 >>> is_var(x)
1384 False
1385 >>> is_const(x)
1386 True
1387 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1388 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1389 >>> q = ForAll([x, y], f(x, y) == x + y)
1390 >>> q.body()
1391 f(Var(1), Var(0)) == Var(1) + Var(0)
1392 >>> b = q.body()
1393 >>> b.arg(0)
1394 f(Var(1), Var(0))
1395 >>> v1 = b.arg(0).arg(0)
1396 >>> v2 = b.arg(0).arg(1)
1397 >>> v1
1398 Var(1)
1399 >>> v2
1400 Var(0)
1401 >>> get_var_index(v1)
1402 1
1403 >>> get_var_index(v2)
1404 0
1405 """
1406 if z3_debug():
1407 _z3_assert(is_var(a), "Z3 bound variable expected")
1408 return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1409
1410
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 9031 of file z3py.py.

9031def help_simplify():
9032 """Return a string describing all options available for Z3 `simplify` procedure."""
9033 print(Z3_simplify_get_help(main_ctx().ref()))
9034
9035
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 1424 of file z3py.py.

1424def If(a, b, c, ctx=None):
1425 """Create a Z3 if-then-else expression.
1426
1427 >>> x = Int('x')
1428 >>> y = Int('y')
1429 >>> max = If(x > y, x, y)
1430 >>> max
1431 If(x > y, x, y)
1432 >>> simplify(max)
1433 If(x <= y, y, x)
1434 """
1435 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1436 return Cond(a, b, c, ctx)
1437 else:
1438 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1439 s = BoolSort(ctx)
1440 a = s.cast(a)
1441 b, c = _coerce_exprs(b, c, ctx)
1442 if z3_debug():
1443 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1444 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1445
1446
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 1856 of file z3py.py.

1856def Implies(a, b, ctx=None):
1857 """Create a Z3 implies expression.
1858
1859 >>> p, q = Bools('p q')
1860 >>> Implies(p, q)
1861 Implies(p, q)
1862 """
1863 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1864 s = BoolSort(ctx)
1865 a = s.cast(a)
1866 b = s.cast(b)
1867 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1868
1869
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.

◆ IndexOf()

IndexOf ( s,
substr,
offset = None )
Retrieve the index of substring within a string starting at a specified offset.
>>> simplify(IndexOf("abcabc", "bc", 0))
1
>>> simplify(IndexOf("abcabc", "bc", 2))
4

Definition at line 11307 of file z3py.py.

11307def IndexOf(s, substr, offset=None):
11308 """Retrieve the index of substring within a string starting at a specified offset.
11309 >>> simplify(IndexOf("abcabc", "bc", 0))
11310 1
11311 >>> simplify(IndexOf("abcabc", "bc", 2))
11312 4
11313 """
11314 if offset is None:
11315 offset = IntVal(0)
11316 ctx = None
11317 if is_expr(offset):
11318 ctx = offset.ctx
11319 ctx = _get_ctx2(s, substr, ctx)
11320 s = _coerce_seq(s, ctx)
11321 substr = _coerce_seq(substr, ctx)
11322 if _is_int(offset):
11323 offset = IntVal(offset, ctx)
11324 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11325
11326
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 11446 of file z3py.py.

11446def InRe(s, re):
11447 """Create regular expression membership test
11448 >>> re = Union(Re("a"),Re("b"))
11449 >>> print (simplify(InRe("a", re)))
11450 True
11451 >>> print (simplify(InRe("b", re)))
11452 True
11453 >>> print (simplify(InRe("c", re)))
11454 False
11455 """
11456 s = _coerce_seq(s, re.ctx)
11457 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11458
11459
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 3331 of file z3py.py.

3331def Int(name, ctx=None):
3332 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3333
3334 >>> x = Int('x')
3335 >>> is_int(x)
3336 True
3337 >>> is_int(x + 1)
3338 True
3339 """
3340 ctx = _get_ctx(ctx)
3341 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3342
3343

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 4086 of file z3py.py.

4086def Int2BV(a, num_bits):
4087 """Return the z3 expression Int2BV(a, num_bits).
4088 It is a bit-vector of width num_bits and represents the
4089 modulo of a by 2^num_bits
4090 """
4091 ctx = a.ctx
4092 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4093
4094
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 11480 of file z3py.py.

11480def Intersect(*args):
11481 """Create intersection of regular expressions.
11482 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11483 """
11484 args = _get_args(args)
11485 sz = len(args)
11486 if z3_debug():
11487 _z3_assert(sz > 0, "At least one argument expected.")
11488 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11489 if sz == 1:
11490 return args[0]
11491 ctx = args[0].ctx
11492 v = (Ast * sz)()
11493 for i in range(sz):
11494 v[i] = args[i].as_ast()
11495 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11496
11497
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 3344 of file z3py.py.

3344def Ints(names, ctx=None):
3345 """Return a tuple of Integer constants.
3346
3347 >>> x, y, z = Ints('x y z')
3348 >>> Sum(x, y, z)
3349 x + y + z
3350 """
3351 ctx = _get_ctx(ctx)
3352 if isinstance(names, str):
3353 names = names.split(" ")
3354 return [Int(name, ctx) for name in names]
3355
3356

◆ 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 3225 of file z3py.py.

3225def IntSort(ctx=None):
3226 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3227
3228 >>> IntSort()
3229 Int
3230 >>> x = Const('x', IntSort())
3231 >>> is_int(x)
3232 True
3233 >>> x.sort() == IntSort()
3234 True
3235 >>> x.sort() == BoolSort()
3236 False
3237 """
3238 ctx = _get_ctx(ctx)
3239 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3240
3241
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.

Referenced by FreshInt(), Int(), and IntVal().

◆ IntToStr()

IntToStr ( s)
Convert integer expression to string

Definition at line 11388 of file z3py.py.

11388def IntToStr(s):
11389 """Convert integer expression to string"""
11390 if not is_expr(s):
11391 s = _py2expr(s)
11392 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11393
11394
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.

◆ 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 3271 of file z3py.py.

3271def IntVal(val, ctx=None):
3272 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3273
3274 >>> IntVal(1)
3275 1
3276 >>> IntVal("100")
3277 100
3278 """
3279 ctx = _get_ctx(ctx)
3280 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3281
3282

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 3357 of file z3py.py.

3357def IntVector(prefix, sz, ctx=None):
3358 """Return a list of integer constants of size `sz`.
3359
3360 >>> X = IntVector('x', 3)
3361 >>> X
3362 [x__0, x__1, x__2]
3363 >>> Sum(X)
3364 x__0 + x__1 + x__2
3365 """
3366 ctx = _get_ctx(ctx)
3367 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3368
3369

◆ 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 2873 of file z3py.py.

2873def is_add(a : Any) -> bool:
2874 """Return `True` if `a` is an expression of the form b + c.
2875
2876 >>> x, y = Ints('x y')
2877 >>> is_add(x + y)
2878 True
2879 >>> is_add(x - y)
2880 False
2881 """
2882 return is_app_of(a, Z3_OP_ADD)
2883
2884

◆ 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 2859 of file z3py.py.

2859def is_algebraic_value(a):
2860 """Return `True` if `a` is an algebraic value of sort Real.
2861
2862 >>> is_algebraic_value(RealVal("3/5"))
2863 False
2864 >>> n = simplify(Sqrt(2))
2865 >>> n
2866 1.4142135623?
2867 >>> is_algebraic_value(n)
2868 True
2869 """
2870 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2871
2872

◆ 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 1692 of file z3py.py.

1692def is_and(a : Any) -> bool:
1693 """Return `True` if `a` is a Z3 and expression.
1694
1695 >>> p, q = Bools('p q')
1696 >>> is_and(And(p, q))
1697 True
1698 >>> is_and(Or(p, q))
1699 False
1700 """
1701 return is_app_of(a, Z3_OP_AND)
1702
1703

◆ 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 1308 of file z3py.py.

1308def is_app(a):
1309 """Return `True` if `a` is a Z3 function application.
1310
1311 Note that, constants are function applications with 0 arguments.
1312
1313 >>> a = Int('a')
1314 >>> is_app(a)
1315 True
1316 >>> is_app(a + 1)
1317 True
1318 >>> is_app(IntSort())
1319 False
1320 >>> is_app(1)
1321 False
1322 >>> is_app(IntVal(1))
1323 True
1324 >>> x = Int('x')
1325 >>> is_app(ForAll(x, x >= 0))
1326 False
1327 """
1328 if not isinstance(a, ExprRef):
1329 return False
1330 k = _ast_kind(a.ctx, a)
1331 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1332
1333

Referenced by _mk_quantifier(), ExprRef.arg(), ExprRef.children(), ExprRef.decl(), is_app_of(), is_const(), ExprRef.kind(), Lambda(), ExprRef.num_args(), and RecAddDefinition().

◆ is_app_of()

is_app_of ( a,
k )
Return `True` if `a` is an application of the given kind `k`.

>>> x = Int('x')
>>> n = x + 1
>>> is_app_of(n, Z3_OP_ADD)
True
>>> is_app_of(n, Z3_OP_MUL)
False

Definition at line 1411 of file z3py.py.

1411def is_app_of(a, k):
1412 """Return `True` if `a` is an application of the given kind `k`.
1413
1414 >>> x = Int('x')
1415 >>> n = x + 1
1416 >>> is_app_of(n, Z3_OP_ADD)
1417 True
1418 >>> is_app_of(n, Z3_OP_MUL)
1419 False
1420 """
1421 return is_app(a) and a.kind() == k
1422
1423

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 2746 of file z3py.py.

2746def is_arith(a):
2747 """Return `True` if `a` is an arithmetical expression.
2748
2749 >>> x = Int('x')
2750 >>> is_arith(x)
2751 True
2752 >>> is_arith(x + 1)
2753 True
2754 >>> is_arith(1)
2755 False
2756 >>> is_arith(IntVal(1))
2757 True
2758 >>> y = Real('y')
2759 >>> is_arith(y)
2760 True
2761 >>> is_arith(y + 1)
2762 True
2763 """
2764 return isinstance(a, ArithRef)
2765
2766

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 2445 of file z3py.py.

2445def is_arith_sort(s : Any) -> bool:
2446 """Return `True` if s is an arithmetical sort (type).
2447
2448 >>> is_arith_sort(IntSort())
2449 True
2450 >>> is_arith_sort(RealSort())
2451 True
2452 >>> is_arith_sort(BoolSort())
2453 False
2454 >>> n = Int('x') + 1
2455 >>> is_arith_sort(n.sort())
2456 True
2457 """
2458 return isinstance(s, ArithSortRef)
2459
2460

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 4701 of file z3py.py.

4701def is_array(a : Any) -> bool:
4702 """Return `True` if `a` is a Z3 array expression.
4703
4704 >>> a = Array('a', IntSort(), IntSort())
4705 >>> is_array(a)
4706 True
4707 >>> is_array(Store(a, 0, 1))
4708 True
4709 >>> is_array(a[0])
4710 False
4711 """
4712 return isinstance(a, ArrayRef)
4713
4714

Referenced by Ext(), and Map().

◆ is_array_sort()

is_array_sort ( a)

Definition at line 4697 of file z3py.py.

4697def is_array_sort(a):
4698 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4699
4700

Referenced by Default(), Ext(), Select(), and Update().

◆ is_as_array()

is_as_array ( n)
Return true if n is a Z3 expression of the form (_ as-array f).

Definition at line 6811 of file z3py.py.

6811def is_as_array(n):
6812 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6813 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6814
6815
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a)
The (_ as-array f) AST node is a construct for assigning interpretations for arrays in Z3....

Referenced by get_as_array_func(), and ModelRef.get_interp().

◆ is_ast()

bool is_ast ( Any a)
Return `True` if `a` is an AST node.

>>> is_ast(10)
False
>>> is_ast(IntVal(10))
True
>>> is_ast(Int('x'))
True
>>> is_ast(BoolSort())
True
>>> is_ast(Function('f', IntSort(), IntSort()))
True
>>> is_ast("x")
False
>>> is_ast(Solver())
False

Definition at line 465 of file z3py.py.

465def is_ast(a : Any) -> bool:
466 """Return `True` if `a` is an AST node.
467
468 >>> is_ast(10)
469 False
470 >>> is_ast(IntVal(10))
471 True
472 >>> is_ast(Int('x'))
473 True
474 >>> is_ast(BoolSort())
475 True
476 >>> is_ast(Function('f', IntSort(), IntSort()))
477 True
478 >>> is_ast("x")
479 False
480 >>> is_ast(Solver())
481 False
482 """
483 return isinstance(a, AstRef)
484
485

Referenced by _ast_kind(), _ctx_from_ast_arg_list(), AstRef.eq(), and eq().

◆ is_bool()

bool is_bool ( Any a)
Return `True` if `a` is a Z3 Boolean expression.

>>> p = Bool('p')
>>> is_bool(p)
True
>>> q = Bool('q')
>>> is_bool(And(p, q))
True
>>> x = Real('x')
>>> is_bool(x)
False
>>> is_bool(x == 0)
True

Definition at line 1642 of file z3py.py.

1642def is_bool(a : Any) -> bool:
1643 """Return `True` if `a` is a Z3 Boolean expression.
1644
1645 >>> p = Bool('p')
1646 >>> is_bool(p)
1647 True
1648 >>> q = Bool('q')
1649 >>> is_bool(And(p, q))
1650 True
1651 >>> x = Real('x')
1652 >>> is_bool(x)
1653 False
1654 >>> is_bool(x == 0)
1655 True
1656 """
1657 return isinstance(a, BoolRef)
1658
1659

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 4034 of file z3py.py.

4034def is_bv(a):
4035 """Return `True` if `a` is a Z3 bit-vector expression.
4036
4037 >>> b = BitVec('b', 32)
4038 >>> is_bv(b)
4039 True
4040 >>> is_bv(b + 10)
4041 True
4042 >>> is_bv(Int('x'))
4043 False
4044 """
4045 return isinstance(a, BitVecRef)
4046
4047

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 3561 of file z3py.py.

3561def is_bv_sort(s):
3562 """Return True if `s` is a Z3 bit-vector sort.
3563
3564 >>> is_bv_sort(BitVecSort(32))
3565 True
3566 >>> is_bv_sort(IntSort())
3567 False
3568 """
3569 return isinstance(s, BitVecSortRef)
3570
3571

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 4048 of file z3py.py.

4048def is_bv_value(a):
4049 """Return `True` if `a` is a Z3 bit-vector numeral value.
4050
4051 >>> b = BitVec('b', 32)
4052 >>> is_bv_value(b)
4053 False
4054 >>> b = BitVecVal(10, 32)
4055 >>> b
4056 10
4057 >>> is_bv_value(b)
4058 True
4059 """
4060 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4061
4062

◆ 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 1334 of file z3py.py.

1334def is_const(a):
1335 """Return `True` if `a` is Z3 constant/variable expression.
1336
1337 >>> a = Int('a')
1338 >>> is_const(a)
1339 True
1340 >>> is_const(a + 1)
1341 False
1342 >>> is_const(1)
1343 False
1344 >>> is_const(IntVal(1))
1345 True
1346 >>> x = Int('x')
1347 >>> is_const(ForAll(x, x >= 0))
1348 False
1349 """
1350 return is_app(a) and a.num_args() == 0
1351
1352

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 4715 of file z3py.py.

4715def is_const_array(a):
4716 """Return `True` if `a` is a Z3 constant array.
4717
4718 >>> a = K(IntSort(), 10)
4719 >>> is_const_array(a)
4720 True
4721 >>> a = Array('a', IntSort(), IntSort())
4722 >>> is_const_array(a)
4723 False
4724 """
4725 return is_app_of(a, Z3_OP_CONST_ARRAY)
4726
4727

◆ 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 4757 of file z3py.py.

4757def is_default(a):
4758 """Return `True` if `a` is a Z3 default array expression.
4759 >>> d = Default(K(IntSort(), 10))
4760 >>> is_default(d)
4761 True
4762 """
4763 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4764
4765

◆ 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 1750 of file z3py.py.

1750def is_distinct(a : Any) -> bool:
1751 """Return `True` if `a` is a Z3 distinct expression.
1752
1753 >>> x, y, z = Ints('x y z')
1754 >>> is_distinct(x == y)
1755 False
1756 >>> is_distinct(Distinct(x, y, z))
1757 True
1758 """
1759 return is_app_of(a, Z3_OP_DISTINCT)
1760
1761

◆ 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 2909 of file z3py.py.

2909def is_div(a : Any) -> bool:
2910 """Return `True` if `a` is an expression of the form b / c.
2911
2912 >>> x, y = Reals('x y')
2913 >>> is_div(x / y)
2914 True
2915 >>> is_div(x + y)
2916 False
2917 >>> x, y = Ints('x y')
2918 >>> is_div(x / y)
2919 False
2920 >>> is_idiv(x / y)
2921 True
2922 """
2923 return is_app_of(a, Z3_OP_DIV)
2924
2925

◆ 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 1740 of file z3py.py.

1740def is_eq(a : Any) -> bool:
1741 """Return `True` if `a` is a Z3 equality expression.
1742
1743 >>> x, y = Ints('x y')
1744 >>> is_eq(x == y)
1745 True
1746 """
1747 return is_app_of(a, Z3_OP_EQ)
1748
1749

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 1285 of file z3py.py.

1285def is_expr(a):
1286 """Return `True` if `a` is a Z3 expression.
1287
1288 >>> a = Int('a')
1289 >>> is_expr(a)
1290 True
1291 >>> is_expr(a + 1)
1292 True
1293 >>> is_expr(IntSort())
1294 False
1295 >>> is_expr(1)
1296 False
1297 >>> is_expr(IntVal(1))
1298 True
1299 >>> x = Int('x')
1300 >>> is_expr(ForAll(x, x >= 0))
1301 True
1302 >>> is_expr(FPVal(1.0))
1303 True
1304 """
1305 return isinstance(a, ExprRef)
1306
1307

Referenced by _coerce_expr_list(), _coerce_expr_merge(), _coerce_exprs(), _mk_quantifier(), _py2expr(), ArithSortRef.cast(), BitVecSortRef.cast(), SortRef.cast(), Cbrt(), Concat(), is_var(), K(), MultiPattern(), Sqrt(), and ModelRef.update_value().

◆ is_false()

bool is_false ( Any a)
Return `True` if `a` is the Z3 false expression.

>>> p = Bool('p')
>>> is_false(p)
False
>>> is_false(False)
False
>>> is_false(BoolVal(False))
True

Definition at line 1678 of file z3py.py.

1678def is_false(a : Any) -> bool:
1679 """Return `True` if `a` is the Z3 false expression.
1680
1681 >>> p = Bool('p')
1682 >>> is_false(p)
1683 False
1684 >>> is_false(False)
1685 False
1686 >>> is_false(BoolVal(False))
1687 True
1688 """
1689 return is_app_of(a, Z3_OP_FALSE)
1690
1691

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 7909 of file z3py.py.

7909def is_finite_domain(a):
7910 """Return `True` if `a` is a Z3 finite-domain expression.
7911
7912 >>> s = FiniteDomainSort('S', 100)
7913 >>> b = Const('b', s)
7914 >>> is_finite_domain(b)
7915 True
7916 >>> is_finite_domain(Int('x'))
7917 False
7918 """
7919 return isinstance(a, FiniteDomainRef)
7920
7921

◆ 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 7886 of file z3py.py.

7886def is_finite_domain_sort(s):
7887 """Return True if `s` is a Z3 finite-domain sort.
7888
7889 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7890 True
7891 >>> is_finite_domain_sort(IntSort())
7892 False
7893 """
7894 return isinstance(s, FiniteDomainSortRef)
7895
7896

◆ 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 7963 of file z3py.py.

7963def is_finite_domain_value(a):
7964 """Return `True` if `a` is a Z3 finite-domain value.
7965
7966 >>> s = FiniteDomainSort('S', 100)
7967 >>> b = Const('b', s)
7968 >>> is_finite_domain_value(b)
7969 False
7970 >>> b = FiniteDomainVal(10, s)
7971 >>> b
7972 10
7973 >>> is_finite_domain_value(b)
7974 True
7975 """
7976 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7977
7978

◆ 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 10117 of file z3py.py.

10117def is_fp(a):
10118 """Return `True` if `a` is a Z3 floating-point expression.
10119
10120 >>> b = FP('b', FPSort(8, 24))
10121 >>> is_fp(b)
10122 True
10123 >>> is_fp(b + 1.0)
10124 True
10125 >>> is_fp(Int('x'))
10126 False
10127 """
10128 return isinstance(a, FPRef)
10129
10130

◆ 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 9691 of file z3py.py.

9691def is_fp_sort(s):
9692 """Return True if `s` is a Z3 floating-point sort.
9693
9694 >>> is_fp_sort(FPSort(8, 24))
9695 True
9696 >>> is_fp_sort(IntSort())
9697 False
9698 """
9699 return isinstance(s, FPSortRef)
9700
9701

◆ 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 10131 of file z3py.py.

10131def is_fp_value(a):
10132 """Return `True` if `a` is a Z3 floating-point numeral value.
10133
10134 >>> b = FP('b', FPSort(8, 24))
10135 >>> is_fp_value(b)
10136 False
10137 >>> b = FPVal(1.0, FPSort(8, 24))
10138 >>> b
10139 1
10140 >>> is_fp_value(b)
10141 True
10142 """
10143 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10144
10145

◆ 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 9951 of file z3py.py.

9951def is_fprm(a):
9952 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9953
9954 >>> rm = RNE()
9955 >>> is_fprm(rm)
9956 True
9957 >>> rm = 1.0
9958 >>> is_fprm(rm)
9959 False
9960 """
9961 return isinstance(a, FPRMRef)
9962
9963

◆ 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 9702 of file z3py.py.

9702def is_fprm_sort(s):
9703 """Return True if `s` is a Z3 floating-point rounding mode sort.
9704
9705 >>> is_fprm_sort(FPSort(8, 24))
9706 False
9707 >>> is_fprm_sort(RNE().sort())
9708 True
9709 """
9710 return isinstance(s, FPRMSortRef)
9711
9712# FP Expressions
9713
9714

◆ is_fprm_value()

is_fprm_value ( a)
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.

Definition at line 9964 of file z3py.py.

9964def is_fprm_value(a):
9965 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9966 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9967
9968# FP Numerals
9969
9970

◆ 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 886 of file z3py.py.

886def is_func_decl(a):
887 """Return `True` if `a` is a Z3 function declaration.
888
889 >>> f = Function('f', IntSort(), IntSort())
890 >>> is_func_decl(f)
891 True
892 >>> x = Real('x')
893 >>> is_func_decl(x)
894 False
895 """
896 return isinstance(a, FuncDeclRef)
897
898

Referenced by Map(), and ModelRef.update_value().

◆ is_ge()

bool is_ge ( Any a)
Return `True` if `a` is an expression of the form b >= c.

>>> x, y = Ints('x y')
>>> is_ge(x >= y)
True
>>> is_ge(x == y)
False

Definition at line 2974 of file z3py.py.

2974def is_ge(a : Any) -> bool:
2975 """Return `True` if `a` is an expression of the form b >= c.
2976
2977 >>> x, y = Ints('x y')
2978 >>> is_ge(x >= y)
2979 True
2980 >>> is_ge(x == y)
2981 False
2982 """
2983 return is_app_of(a, Z3_OP_GE)
2984
2985

◆ 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 2986 of file z3py.py.

2986def is_gt(a : Any) -> bool:
2987 """Return `True` if `a` is an expression of the form b > c.
2988
2989 >>> x, y = Ints('x y')
2990 >>> is_gt(x > y)
2991 True
2992 >>> is_gt(x == y)
2993 False
2994 """
2995 return is_app_of(a, Z3_OP_GT)
2996
2997

◆ 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 2926 of file z3py.py.

2926def is_idiv(a : Any) -> bool:
2927 """Return `True` if `a` is an expression of the form b div c.
2928
2929 >>> x, y = Ints('x y')
2930 >>> is_idiv(x / y)
2931 True
2932 >>> is_idiv(x + y)
2933 False
2934 """
2935 return is_app_of(a, Z3_OP_IDIV)
2936
2937

◆ 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 1716 of file z3py.py.

1716def is_implies(a : Any) -> bool:
1717 """Return `True` if `a` is a Z3 implication expression.
1718
1719 >>> p, q = Bools('p q')
1720 >>> is_implies(Implies(p, q))
1721 True
1722 >>> is_implies(And(p, q))
1723 False
1724 """
1725 return is_app_of(a, Z3_OP_IMPLIES)
1726
1727

◆ 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 2767 of file z3py.py.

2767def is_int(a) -> bool:
2768 """Return `True` if `a` is an integer expression.
2769
2770 >>> x = Int('x')
2771 >>> is_int(x + 1)
2772 True
2773 >>> is_int(1)
2774 False
2775 >>> is_int(IntVal(1))
2776 True
2777 >>> y = Real('y')
2778 >>> is_int(y)
2779 False
2780 >>> is_int(y + 1)
2781 False
2782 """
2783 return is_arith(a) and a.is_int()
2784
2785

◆ 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 2813 of file z3py.py.

2813def is_int_value(a):
2814 """Return `True` if `a` is an integer value of sort Int.
2815
2816 >>> is_int_value(IntVal(1))
2817 True
2818 >>> is_int_value(1)
2819 False
2820 >>> is_int_value(Int('x'))
2821 False
2822 >>> n = Int('x') + 1
2823 >>> n
2824 x + 1
2825 >>> n.arg(1)
2826 1
2827 >>> is_int_value(n.arg(1))
2828 True
2829 >>> is_int_value(RealVal("1/3"))
2830 False
2831 >>> is_int_value(RealVal(1))
2832 False
2833 """
2834 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2835
2836

◆ 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 2998 of file z3py.py.

2998def is_is_int(a : Any) -> bool:
2999 """Return `True` if `a` is an expression of the form IsInt(b).
3000
3001 >>> x = Real('x')
3002 >>> is_is_int(IsInt(x))
3003 True
3004 >>> is_is_int(x)
3005 False
3006 """
3007 return is_app_of(a, Z3_OP_IS_INT)
3008
3009

◆ 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 4728 of file z3py.py.

4728def is_K(a):
4729 """Return `True` if `a` is a Z3 constant array.
4730
4731 >>> a = K(IntSort(), 10)
4732 >>> is_K(a)
4733 True
4734 >>> a = Array('a', IntSort(), IntSort())
4735 >>> is_K(a)
4736 False
4737 """
4738 return is_app_of(a, Z3_OP_CONST_ARRAY)
4739
4740

◆ 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 2950 of file z3py.py.

2950def is_le(a : Any) -> bool:
2951 """Return `True` if `a` is an expression of the form b <= c.
2952
2953 >>> x, y = Ints('x y')
2954 >>> is_le(x <= y)
2955 True
2956 >>> is_le(x < y)
2957 False
2958 """
2959 return is_app_of(a, Z3_OP_LE)
2960
2961

◆ 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 2962 of file z3py.py.

2962def is_lt(a : Any) -> bool:
2963 """Return `True` if `a` is an expression of the form b < c.
2964
2965 >>> x, y = Ints('x y')
2966 >>> is_lt(x < y)
2967 True
2968 >>> is_lt(x == y)
2969 False
2970 """
2971 return is_app_of(a, Z3_OP_LT)
2972
2973

◆ 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 4741 of file z3py.py.

4741def is_map(a):
4742 """Return `True` if `a` is a Z3 map array expression.
4743
4744 >>> f = Function('f', IntSort(), IntSort())
4745 >>> b = Array('b', IntSort(), IntSort())
4746 >>> a = Map(f, b)
4747 >>> a
4748 Map(f, b)
4749 >>> is_map(a)
4750 True
4751 >>> is_map(b)
4752 False
4753 """
4754 return is_app_of(a, Z3_OP_ARRAY_MAP)
4755
4756

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 2938 of file z3py.py.

2938def is_mod(a : Any) -> bool:
2939 """Return `True` if `a` is an expression of the form b % c.
2940
2941 >>> x, y = Ints('x y')
2942 >>> is_mod(x % y)
2943 True
2944 >>> is_mod(x + y)
2945 False
2946 """
2947 return is_app_of(a, Z3_OP_MOD)
2948
2949

◆ 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 2885 of file z3py.py.

2885def is_mul(a : Any) -> bool:
2886 """Return `True` if `a` is an expression of the form b * c.
2887
2888 >>> x, y = Ints('x y')
2889 >>> is_mul(x * y)
2890 True
2891 >>> is_mul(x - y)
2892 False
2893 """
2894 return is_app_of(a, Z3_OP_MUL)
2895
2896

◆ 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 1728 of file z3py.py.

1728def is_not(a : Any) -> bool:
1729 """Return `True` if `a` is a Z3 not expression.
1730
1731 >>> p = Bool('p')
1732 >>> is_not(p)
1733 False
1734 >>> is_not(Not(p))
1735 True
1736 """
1737 return is_app_of(a, Z3_OP_NOT)
1738
1739

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 1704 of file z3py.py.

1704def is_or(a : Any) -> bool:
1705 """Return `True` if `a` is a Z3 or expression.
1706
1707 >>> p, q = Bools('p q')
1708 >>> is_or(Or(p, q))
1709 True
1710 >>> is_or(And(p, q))
1711 False
1712 """
1713 return is_app_of(a, Z3_OP_OR)
1714
1715

◆ 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 2004 of file z3py.py.

2004def is_pattern(a):
2005 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
2006
2007 >>> f = Function('f', IntSort(), IntSort())
2008 >>> x = Int('x')
2009 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2010 >>> q
2011 ForAll(x, f(x) == 0)
2012 >>> q.num_patterns()
2013 1
2014 >>> is_pattern(q.pattern(0))
2015 True
2016 >>> q.pattern(0)
2017 f(Var(0))
2018 """
2019 return isinstance(a, PatternRef)
2020
2021

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 8872 of file z3py.py.

8872def is_probe(p):
8873 """Return `True` if `p` is a Z3 probe.
8874
8875 >>> is_probe(Int('x'))
8876 False
8877 >>> is_probe(Probe('memory'))
8878 True
8879 """
8880 return isinstance(p, Probe)
8881
8882

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 2254 of file z3py.py.

2254def is_quantifier(a):
2255 """Return `True` if `a` is a Z3 quantifier.
2256
2257 >>> f = Function('f', IntSort(), IntSort())
2258 >>> x = Int('x')
2259 >>> q = ForAll(x, f(x) == 0)
2260 >>> is_quantifier(q)
2261 True
2262 >>> is_quantifier(f(x))
2263 False
2264 """
2265 return isinstance(a, QuantifierRef)
2266
2267

◆ 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 2837 of file z3py.py.

2837def is_rational_value(a):
2838 """Return `True` if `a` is rational value of sort Real.
2839
2840 >>> is_rational_value(RealVal(1))
2841 True
2842 >>> is_rational_value(RealVal("3/5"))
2843 True
2844 >>> is_rational_value(IntVal(1))
2845 False
2846 >>> is_rational_value(1)
2847 False
2848 >>> n = Real('x') + 1
2849 >>> n.arg(1)
2850 1
2851 >>> is_rational_value(n.arg(1))
2852 True
2853 >>> is_rational_value(Real('x'))
2854 False
2855 """
2856 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2857
2858

◆ is_re()

is_re ( s)

Definition at line 11442 of file z3py.py.

11442def is_re(s):
11443 return isinstance(s, ReRef)
11444
11445

Referenced by Concat().

◆ 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 2786 of file z3py.py.

2786def is_real(a):
2787 """Return `True` if `a` is a real expression.
2788
2789 >>> x = Int('x')
2790 >>> is_real(x + 1)
2791 False
2792 >>> y = Real('y')
2793 >>> is_real(y)
2794 True
2795 >>> is_real(y + 1)
2796 True
2797 >>> is_real(1)
2798 False
2799 >>> is_real(RealVal(1))
2800 True
2801 """
2802 return is_arith(a) and a.is_real()
2803
2804

◆ 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 4976 of file z3py.py.

4976def is_select(a):
4977 """Return `True` if `a` is a Z3 array select application.
4978
4979 >>> a = Array('a', IntSort(), IntSort())
4980 >>> is_select(a)
4981 False
4982 >>> i = Int('i')
4983 >>> is_select(a[i])
4984 True
4985 """
4986 return is_app_of(a, Z3_OP_SELECT)
4987
4988

◆ 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 11142 of file z3py.py.

11142def is_seq(a):
11143 """Return `True` if `a` is a Z3 sequence expression.
11144 >>> print (is_seq(Unit(IntVal(0))))
11145 True
11146 >>> print (is_seq(StringVal("abc")))
11147 True
11148 """
11149 return isinstance(a, SeqRef)
11150
11151

Referenced by Concat(), and Extract().

◆ 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 661 of file z3py.py.

661def is_sort(s : Any) -> bool:
662 """Return `True` if `s` is a Z3 sort.
663
664 >>> is_sort(IntSort())
665 True
666 >>> is_sort(Int('x'))
667 False
668 >>> is_expr(Int('x'))
669 True
670 """
671 return isinstance(s, SortRef)
672
673

Referenced by _valid_accessor(), ArraySort(), CreateDatatypes(), 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 4989 of file z3py.py.

4989def is_store(a):
4990 """Return `True` if `a` is a Z3 array store application.
4991
4992 >>> a = Array('a', IntSort(), IntSort())
4993 >>> is_store(a)
4994 False
4995 >>> is_store(Store(a, 0, 1))
4996 True
4997 """
4998 return is_app_of(a, Z3_OP_STORE)
4999

◆ 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 11152 of file z3py.py.

11152def is_string(a: Any) -> bool:
11153 """Return `True` if `a` is a Z3 string expression.
11154 >>> print (is_string(StringVal("ab")))
11155 True
11156 """
11157 return isinstance(a, SeqRef) and a.is_string()
11158
11159

◆ 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 11160 of file z3py.py.

11160def is_string_value(a: Any) -> bool:
11161 """return 'True' if 'a' is a Z3 string constant expression.
11162 >>> print (is_string_value(StringVal("a")))
11163 True
11164 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11165 False
11166 """
11167 return isinstance(a, SeqRef) and a.is_string_value()
11168

◆ 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 2897 of file z3py.py.

2897def is_sub(a : Any) -> bool:
2898 """Return `True` if `a` is an expression of the form b - c.
2899
2900 >>> x, y = Ints('x y')
2901 >>> is_sub(x - y)
2902 True
2903 >>> is_sub(x + y)
2904 False
2905 """
2906 return is_app_of(a, Z3_OP_SUB)
2907
2908

◆ 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 3025 of file z3py.py.

3025def is_to_int(a : Any) -> bool:
3026 """Return `True` if `a` is an expression of the form ToInt(b).
3027
3028 >>> x = Real('x')
3029 >>> n = ToInt(x)
3030 >>> n
3031 ToInt(x)
3032 >>> is_to_int(n)
3033 True
3034 >>> is_to_int(x)
3035 False
3036 """
3037 return is_app_of(a, Z3_OP_TO_INT)
3038
3039

◆ 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 3010 of file z3py.py.

3010def is_to_real(a : Any) -> bool:
3011 """Return `True` if `a` is an expression of the form ToReal(b).
3012
3013 >>> x = Int('x')
3014 >>> n = ToReal(x)
3015 >>> n
3016 ToReal(x)
3017 >>> is_to_real(n)
3018 True
3019 >>> is_to_real(x)
3020 False
3021 """
3022 return is_app_of(a, Z3_OP_TO_REAL)
3023
3024

◆ 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 1660 of file z3py.py.

1660def is_true(a : Any) -> bool:
1661 """Return `True` if `a` is the Z3 true expression.
1662
1663 >>> p = Bool('p')
1664 >>> is_true(p)
1665 False
1666 >>> is_true(simplify(p == p))
1667 True
1668 >>> x = Real('x')
1669 >>> is_true(x == 0)
1670 False
1671 >>> # True is a Python Boolean expression
1672 >>> is_true(True)
1673 False
1674 """
1675 return is_app_of(a, Z3_OP_TRUE)
1676
1677

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 1353 of file z3py.py.

1353def is_var(a):
1354 """Return `True` if `a` is variable.
1355
1356 Z3 uses de-Bruijn indices for representing bound variables in
1357 quantifiers.
1358
1359 >>> x = Int('x')
1360 >>> is_var(x)
1361 False
1362 >>> is_const(x)
1363 True
1364 >>> f = Function('f', IntSort(), IntSort())
1365 >>> # Z3 replaces x with bound variables when ForAll is executed.
1366 >>> q = ForAll(x, f(x) == x)
1367 >>> b = q.body()
1368 >>> b
1369 f(Var(0)) == Var(0)
1370 >>> b.arg(1)
1371 Var(0)
1372 >>> is_var(b.arg(1))
1373 True
1374 """
1375 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1376
1377

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 3479 of file z3py.py.

3479def IsInt(a):
3480 """ Return the Z3 predicate IsInt(a).
3481
3482 >>> x = Real('x')
3483 >>> IsInt(x + "1/2")
3484 IsInt(x + 1/2)
3485 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3486 [x = 1/2]
3487 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3488 no solution
3489 """
3490 if z3_debug():
3491 _z3_assert(a.is_real(), "Z3 real expression expected.")
3492 ctx = a.ctx
3493 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3494
3495
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 5099 of file z3py.py.

5099def IsMember(e, s):
5100 """ Check if e is a member of set s
5101 >>> a = Const('a', SetSort(IntSort()))
5102 >>> IsMember(1, a)
5103 a[1]
5104 """
5105 ctx = _ctx_from_ast_arg_list([s, e])
5106 e = _py2expr(e, ctx)
5107 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5108
5109
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 5110 of file z3py.py.

5110def IsSubset(a, b):
5111 """ Check if a is a subset of b
5112 >>> a = Const('a', SetSort(IntSort()))
5113 >>> b = Const('b', SetSort(IntSort()))
5114 >>> IsSubset(a, b)
5115 subset(a, b)
5116 """
5117 ctx = _ctx_from_ast_arg_list([a, b])
5118 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5119
5120
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 4936 of file z3py.py.

4936def K(dom, v):
4937 """Return a Z3 constant array expression.
4938
4939 >>> a = K(IntSort(), 10)
4940 >>> a
4941 K(Int, 10)
4942 >>> a.sort()
4943 Array(Int, Int)
4944 >>> i = Int('i')
4945 >>> a[i]
4946 K(Int, 10)[i]
4947 >>> simplify(a[i])
4948 10
4949 """
4950 if z3_debug():
4951 _z3_assert(is_sort(dom), "Z3 sort expected")
4952 ctx = dom.ctx
4953 if not is_expr(v):
4954 v = _py2expr(v, ctx)
4955 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4956
4957
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 2342 of file z3py.py.

2342def Lambda(vs, body):
2343 """Create a Z3 lambda expression.
2344
2345 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2346 >>> mem0 = Array('mem0', IntSort(), IntSort())
2347 >>> lo, hi, e, i = Ints('lo hi e i')
2348 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2349 >>> mem1
2350 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2351 """
2352 ctx = body.ctx
2353 if is_app(vs):
2354 vs = [vs]
2355 num_vars = len(vs)
2356 _vs = (Ast * num_vars)()
2357 for i in range(num_vars):
2358 # TODO: Check if is constant
2359 _vs[i] = vs[i].as_ast()
2360 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2361
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 11327 of file z3py.py.

11327def LastIndexOf(s, substr):
11328 """Retrieve the last index of substring within a string"""
11329 ctx = None
11330 ctx = _get_ctx2(s, substr, ctx)
11331 s = _coerce_seq(s, ctx)
11332 substr = _coerce_seq(substr, ctx)
11333 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11334
11335
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 11336 of file z3py.py.

11336def Length(s):
11337 """Obtain the length of a sequence 's'
11338 >>> l = Length(StringVal("abc"))
11339 >>> simplify(l)
11340 3
11341 """
11342 s = _coerce_seq(s)
11343 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11344
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 )

Definition at line 11598 of file z3py.py.

11598def LinearOrder(a, index):
11599 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11600
11601
Z3_func_decl Z3_API Z3_mk_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a linear ordering relation over signature a. The relation is identified by the index id.

◆ 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 11548 of file z3py.py.

11548def Loop(re, lo, hi=0):
11549 """Create the regular expression accepting between a lower and upper bound repetitions
11550 >>> re = Loop(Re("a"), 1, 3)
11551 >>> print(simplify(InRe("aa", re)))
11552 True
11553 >>> print(simplify(InRe("aaaa", re)))
11554 False
11555 >>> print(simplify(InRe("", re)))
11556 False
11557 """
11558 if z3_debug():
11559 _z3_assert(is_expr(re), "expression expected")
11560 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11561
11562
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 4389 of file z3py.py.

4389def LShR(a, b):
4390 """Create the Z3 expression logical right shift.
4391
4392 Use the operator >> for the arithmetical right shift.
4393
4394 >>> x, y = BitVecs('x y', 32)
4395 >>> LShR(x, y)
4396 LShR(x, y)
4397 >>> (x >> y).sexpr()
4398 '(bvashr x y)'
4399 >>> LShR(x, y).sexpr()
4400 '(bvlshr x y)'
4401 >>> BitVecVal(4, 3)
4402 4
4403 >>> BitVecVal(4, 3).as_signed_long()
4404 -4
4405 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4406 -2
4407 >>> simplify(BitVecVal(4, 3) >> 1)
4408 6
4409 >>> simplify(LShR(BitVecVal(4, 3), 1))
4410 2
4411 >>> simplify(BitVecVal(2, 3) >> 1)
4412 1
4413 >>> simplify(LShR(BitVecVal(2, 3), 1))
4414 1
4415 """
4416 _check_bv_args(a, b)
4417 a, b = _coerce_exprs(a, b)
4418 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4419
4420
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.

◆ main_ctx()

Context main_ctx ( )
Return a reference to the global Z3 context.

>>> x = Real('x')
>>> x.ctx == main_ctx()
True
>>> c = Context()
>>> c == main_ctx()
False
>>> x2 = Real('x', c)
>>> x2.ctx == c
True
>>> eq(x, x2)
False

Definition at line 249 of file z3py.py.

249def main_ctx() -> Context:
250 """Return a reference to the global Z3 context.
251
252 >>> x = Real('x')
253 >>> x.ctx == main_ctx()
254 True
255 >>> c = Context()
256 >>> c == main_ctx()
257 False
258 >>> x2 = Real('x', c)
259 >>> x2.ctx == c
260 True
261 >>> eq(x, x2)
262 False
263 """
264 global _main_ctx
265 if _main_ctx is None:
266 _main_ctx = Context()
267 return _main_ctx
268
269

Referenced by _get_ctx().

◆ Map()

Map ( f,
* args )
Return a Z3 map array expression.

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> a1 = Array('a1', IntSort(), IntSort())
>>> a2 = Array('a2', IntSort(), IntSort())
>>> b  = Map(f, a1, a2)
>>> b
Map(f, a1, a2)
>>> prove(b[0] == f(a1[0], a2[0]))
proved

Definition at line 4913 of file z3py.py.

4913def Map(f, *args):
4914 """Return a Z3 map array expression.
4915
4916 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4917 >>> a1 = Array('a1', IntSort(), IntSort())
4918 >>> a2 = Array('a2', IntSort(), IntSort())
4919 >>> b = Map(f, a1, a2)
4920 >>> b
4921 Map(f, a1, a2)
4922 >>> prove(b[0] == f(a1[0], a2[0]))
4923 proved
4924 """
4925 args = _get_args(args)
4926 if z3_debug():
4927 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4928 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4929 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4930 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4931 _args, sz = _to_ast_array(args)
4932 ctx = f.ctx
4933 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4934
4935
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)

Definition at line 1905 of file z3py.py.

1905def mk_not(a):
1906 if is_not(a):
1907 return a.arg(0)
1908 else:
1909 return Not(a)
1910
1911

◆ Model()

Model ( ctx = None,
eval = {} )

Definition at line 6803 of file z3py.py.

6803def Model(ctx=None, eval = {}):
6804 ctx = _get_ctx(ctx)
6805 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
6806 for k, v in eval.items():
6807 mdl.update_value(k, v)
6808 return mdl
6809
6810
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 2022 of file z3py.py.

2022def MultiPattern(*args):
2023 """Create a Z3 multi-pattern using the given expressions `*args`
2024
2025 >>> f = Function('f', IntSort(), IntSort())
2026 >>> g = Function('g', IntSort(), IntSort())
2027 >>> x = Int('x')
2028 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
2029 >>> q
2030 ForAll(x, f(x) != g(x))
2031 >>> q.num_patterns()
2032 1
2033 >>> is_pattern(q.pattern(0))
2034 True
2035 >>> q.pattern(0)
2036 MultiPattern(f(Var(0)), g(Var(0)))
2037 """
2038 if z3_debug():
2039 _z3_assert(len(args) > 0, "At least one argument expected")
2040 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2041 ctx = args[0].ctx
2042 args, sz = _to_ast_array(args)
2043 return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
2044
2045
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 1886 of file z3py.py.

1886def Not(a, ctx=None):
1887 """Create a Z3 not expression or probe.
1888
1889 >>> p = Bool('p')
1890 >>> Not(Not(p))
1891 Not(Not(p))
1892 >>> simplify(Not(Not(p)))
1893 p
1894 """
1895 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1896 if is_probe(a):
1897 # Not is also used to build probes
1898 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1899 else:
1900 s = BoolSort(ctx)
1901 a = s.cast(a)
1902 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1903
1904
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).

Referenced by BoolRef.__invert__(), and mk_not().

◆ on_clause_eh()

on_clause_eh ( ctx,
p,
n,
dep,
clause )

Definition at line 11638 of file z3py.py.

11638def on_clause_eh(ctx, p, n, dep, clause):
11639 onc = _my_hacky_class
11640 p = _to_expr_ref(to_Ast(p), onc.ctx)
11641 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11642 deps = [dep[i] for i in range(n)]
11643 onc.on_clause(p, deps, clause)
11644

◆ 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
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.

◆ 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 11513 of file z3py.py.

11513def Option(re):
11514 """Create the regular expression that optionally accepts the argument.
11515 >>> re = Option(Re("a"))
11516 >>> print(simplify(InRe("a", re)))
11517 True
11518 >>> print(simplify(InRe("", re)))
11519 True
11520 >>> print(simplify(InRe("aa", re)))
11521 False
11522 """
11523 if z3_debug():
11524 _z3_assert(is_expr(re), "expression expected")
11525 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11526
11527
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 1953 of file z3py.py.

1953def Or(*args):
1954 """Create a Z3 or-expression or or-probe.
1955
1956 >>> p, q, r = Bools('p q r')
1957 >>> Or(p, q, r)
1958 Or(p, q, r)
1959 >>> P = BoolVector('p', 5)
1960 >>> Or(P)
1961 Or(p__0, p__1, p__2, p__3, p__4)
1962 """
1963 last_arg = None
1964 if len(args) > 0:
1965 last_arg = args[len(args) - 1]
1966 if isinstance(last_arg, Context):
1967 ctx = args[len(args) - 1]
1968 args = args[:len(args) - 1]
1969 elif len(args) == 1 and isinstance(args[0], AstVector):
1970 ctx = args[0].ctx
1971 args = [a for a in args[0]]
1972 else:
1973 ctx = None
1974 args = _get_args(args)
1975 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1976 if z3_debug():
1977 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1978 if _has_probe(args):
1979 return _probe_or(args, ctx)
1980 else:
1981 args = _coerce_expr_list(args, ctx)
1982 _args, sz = _to_ast_array(args)
1983 return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1984
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 8565 of file z3py.py.

8565def OrElse(*ts, **ks):
8566 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8567
8568 >>> x = Int('x')
8569 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8570 >>> # Tactic split-clause fails if there is no clause in the given goal.
8571 >>> t(x == 0)
8572 [[x == 0]]
8573 >>> t(Or(x == 0, x == 1))
8574 [[x == 0], [x == 1]]
8575 """
8576 if z3_debug():
8577 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8578 ctx = ks.get("ctx", None)
8579 num = len(ts)
8580 r = ts[0]
8581 for i in range(num - 1):
8582 r = _or_else(r, ts[i + 1], ctx)
8583 return r
8584
8585

◆ ParAndThen()

ParAndThen ( t1,
t2,
ctx = None )
Alias for ParThen(t1, t2, ctx).

Definition at line 8621 of file z3py.py.

8621def ParAndThen(t1, t2, ctx=None):
8622 """Alias for ParThen(t1, t2, ctx)."""
8623 return ParThen(t1, t2, ctx)
8624
8625

◆ 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 8586 of file z3py.py.

8586def ParOr(*ts, **ks):
8587 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8588
8589 >>> x = Int('x')
8590 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8591 >>> t(x + 1 == 2)
8592 [[x == 1]]
8593 """
8594 if z3_debug():
8595 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8596 ctx = _get_ctx(ks.get("ctx", None))
8597 ts = [_to_tactic(t, ctx) for t in ts]
8598 sz = len(ts)
8599 _args = (TacticObj * sz)()
8600 for i in range(sz):
8601 _args[i] = ts[i].tactic
8602 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8603
8604
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 9501 of file z3py.py.

9501def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9502 """Parse a file in SMT 2.0 format using the given sorts and decls.
9503
9504 This function is similar to parse_smt2_string().
9505 """
9506 ctx = _get_ctx(ctx)
9507 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9508 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9509 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9510
9511
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 9480 of file z3py.py.

9480def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9481 """Parse a string in SMT 2.0 format using the given sorts and decls.
9482
9483 The arguments sorts and decls are Python dictionaries used to initialize
9484 the symbol table used for the SMT 2.0 parser.
9485
9486 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9487 [x > 0, x < 10]
9488 >>> x, y = Ints('x y')
9489 >>> f = Function('f', IntSort(), IntSort())
9490 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9491 [x + f(y) > 0]
9492 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9493 [a > 0]
9494 """
9495 ctx = _get_ctx(ctx)
9496 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9497 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9498 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9499
9500
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 8605 of file z3py.py.

8605def ParThen(t1, t2, ctx=None):
8606 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8607 The subgoals are processed in parallel.
8608
8609 >>> x, y = Ints('x y')
8610 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8611 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8612 [[x == 1, y == 2], [x == 2, y == 3]]
8613 """
8614 t1 = _to_tactic(t1, ctx)
8615 t2 = _to_tactic(t2, ctx)
8616 if z3_debug():
8617 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8618 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8619
8620
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 )

Definition at line 11594 of file z3py.py.

11594def PartialOrder(a, index):
11595 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11596
11597
Z3_func_decl Z3_API Z3_mk_partial_order(Z3_context c, Z3_sort a, unsigned id)
create a partial ordering relation over signature a and index id.

◆ 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 9257 of file z3py.py.

9257def PbEq(args, k, ctx=None):
9258 """Create a Pseudo-Boolean equality k constraint.
9259
9260 >>> a, b, c = Bools('a b c')
9261 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9262 """
9263 _z3_check_cint_overflow(k, "k")
9264 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9265 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9266
9267
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 9246 of file z3py.py.

9246def PbGe(args, k):
9247 """Create a Pseudo-Boolean inequality k constraint.
9248
9249 >>> a, b, c = Bools('a b c')
9250 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9251 """
9252 _z3_check_cint_overflow(k, "k")
9253 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9254 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9255
9256
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 9235 of file z3py.py.

9235def PbLe(args, k):
9236 """Create a Pseudo-Boolean inequality k constraint.
9237
9238 >>> a, b, c = Bools('a b c')
9239 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9240 """
9241 _z3_check_cint_overflow(k, "k")
9242 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9243 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9244
9245
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 )

Definition at line 11606 of file z3py.py.

11606def PiecewiseLinearOrder(a, index):
11607 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11608
11609
Z3_func_decl Z3_API Z3_mk_piecewise_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a piecewise linear ordering relation over signature a and index id.

◆ 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 11498 of file z3py.py.

11498def Plus(re):
11499 """Create the regular expression accepting one or more repetitions of argument.
11500 >>> re = Plus(Re("a"))
11501 >>> print(simplify(InRe("aa", re)))
11502 True
11503 >>> print(simplify(InRe("ab", re)))
11504 False
11505 >>> print(simplify(InRe("", re)))
11506 False
11507 """
11508 if z3_debug():
11509 _z3_assert(is_expr(re), "expression expected")
11510 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11511
11512
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.

◆ 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 11243 of file z3py.py.

11243def PrefixOf(a, b):
11244 """Check if 'a' is a prefix of 'b'
11245 >>> s1 = PrefixOf("ab", "abc")
11246 >>> simplify(s1)
11247 True
11248 >>> s2 = PrefixOf("bc", "abc")
11249 >>> simplify(s2)
11250 False
11251 """
11252 ctx = _get_ctx2(a, b)
11253 a = _coerce_seq(a, ctx)
11254 b = _coerce_seq(b, ctx)
11255 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11256
11257
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 8901 of file z3py.py.

8901def probe_description(name, ctx=None):
8902 """Return a short description for the probe named `name`.
8903
8904 >>> d = probe_description('memory')
8905 """
8906 ctx = _get_ctx(ctx)
8907 return Z3_probe_get_descr(ctx.ref(), name)
8908
8909
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 8890 of file z3py.py.

8890def probes(ctx=None):
8891 """Return a list of all available probes in Z3.
8892
8893 >>> l = probes()
8894 >>> l.count('memory') == 1
8895 True
8896 """
8897 ctx = _get_ctx(ctx)
8898 return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8899
8900
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 9142 of file z3py.py.

9142def Product(*args):
9143 """Create the product of the Z3 expressions.
9144
9145 >>> a, b, c = Ints('a b c')
9146 >>> Product(a, b, c)
9147 a*b*c
9148 >>> Product([a, b, c])
9149 a*b*c
9150 >>> A = IntVector('a', 5)
9151 >>> Product(A)
9152 a__0*a__1*a__2*a__3*a__4
9153 """
9154 args = _get_args(args)
9155 if len(args) == 0:
9156 return 1
9157 ctx = _ctx_from_ast_arg_list(args)
9158 if ctx is None:
9159 return _reduce(lambda a, b: a * b, args, 1)
9160 args = _coerce_expr_list(args, ctx)
9161 if is_bv(args[0]):
9162 return _reduce(lambda a, b: a * b, args, 1)
9163 else:
9164 _args, sz = _to_ast_array(args)
9165 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
9166
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 11792 of file z3py.py.

11792def PropagateFunction(name, *sig):
11793 """Create a function that gets tracked by user propagator.
11794 Every term headed by this function symbol is tracked.
11795 If a term is fixed and the fixed callback is registered a
11796 callback is invoked that the term headed by this function is fixed.
11797 """
11798 sig = _get_args(sig)
11799 if z3_debug():
11800 _z3_assert(len(sig) > 0, "At least two arguments expected")
11801 arity = len(sig) - 1
11802 rng = sig[arity]
11803 if z3_debug():
11804 _z3_assert(is_sort(rng), "Z3 sort expected")
11805 dom = (Sort * arity)()
11806 for i in range(arity):
11807 if z3_debug():
11808 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11809 dom[i] = sig[i].ast
11810 ctx = rng.ctx
11811 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11812
11813
11814
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 9329 of file z3py.py.

9329def prove(claim, show=False, **keywords):
9330 """Try to prove the given claim.
9331
9332 This is a simple function for creating demonstrations. It tries to prove
9333 `claim` by showing the negation is unsatisfiable.
9334
9335 >>> p, q = Bools('p q')
9336 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9337 proved
9338 """
9339 if z3_debug():
9340 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9341 s = Solver()
9342 s.set(**keywords)
9343 s.add(Not(claim))
9344 if show:
9345 print(s)
9346 r = s.check()
9347 if r == unsat:
9348 print("proved")
9349 elif r == unknown:
9350 print("failed to prove")
9351 print(s.model())
9352 else:
9353 print("counterexample")
9354 print(s.model())
9355
9356

◆ 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 3318 of file z3py.py.

3318def Q(a, b, ctx=None):
3319 """Return a Z3 rational a/b.
3320
3321 If `ctx=None`, then the global context is used.
3322
3323 >>> Q(3,5)
3324 3/5
3325 >>> Q(3,5).sort()
3326 Real
3327 """
3328 return simplify(RatVal(a, b, ctx=ctx))
3329
3330

◆ 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 11563 of file z3py.py.

11563def Range(lo, hi, ctx=None):
11564 """Create the range regular expression over two sequences of length 1
11565 >>> range = Range("a","z")
11566 >>> print(simplify(InRe("b", range)))
11567 True
11568 >>> print(simplify(InRe("bb", range)))
11569 False
11570 """
11571 lo = _coerce_seq(lo, ctx)
11572 hi = _coerce_seq(hi, ctx)
11573 if z3_debug():
11574 _z3_assert(is_expr(lo), "expression expected")
11575 _z3_assert(is_expr(hi), "expression expected")
11576 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11577
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.

◆ RatVal()

RatVal ( a,
b,
ctx = None )
Return a Z3 rational a/b.

If `ctx=None`, then the global context is used.

>>> RatVal(3,5)
3/5
>>> RatVal(3,5).sort()
Real

Definition at line 3302 of file z3py.py.

3302def RatVal(a, b, ctx=None):
3303 """Return a Z3 rational a/b.
3304
3305 If `ctx=None`, then the global context is used.
3306
3307 >>> RatVal(3,5)
3308 3/5
3309 >>> RatVal(3,5).sort()
3310 Real
3311 """
3312 if z3_debug():
3313 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3314 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3315 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3316
3317

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 11407 of file z3py.py.

11407def Re(s, ctx=None):
11408 """The regular expression that accepts sequence 's'
11409 >>> s1 = Re("ab")
11410 >>> s2 = Re(StringVal("ab"))
11411 >>> s3 = Re(Unit(BoolVal(True)))
11412 """
11413 s = _coerce_seq(s, ctx)
11414 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11415
11416
11417# Regular expressions
11418
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 3384 of file z3py.py.

3384def Real(name, ctx=None):
3385 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3386
3387 >>> x = Real('x')
3388 >>> is_real(x)
3389 True
3390 >>> is_real(x + 1)
3391 True
3392 """
3393 ctx = _get_ctx(ctx)
3394 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3395
3396

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 3397 of file z3py.py.

3397def Reals(names, ctx=None):
3398 """Return a tuple of real constants.
3399
3400 >>> x, y, z = Reals('x y z')
3401 >>> Sum(x, y, z)
3402 x + y + z
3403 >>> Sum(x, y, z).sort()
3404 Real
3405 """
3406 ctx = _get_ctx(ctx)
3407 if isinstance(names, str):
3408 names = names.split(" ")
3409 return [Real(name, ctx) for name in names]
3410
3411

◆ 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 3242 of file z3py.py.

3242def RealSort(ctx=None):
3243 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3244
3245 >>> RealSort()
3246 Real
3247 >>> x = Const('x', RealSort())
3248 >>> is_real(x)
3249 True
3250 >>> is_int(x)
3251 False
3252 >>> x.sort() == RealSort()
3253 True
3254 """
3255 ctx = _get_ctx(ctx)
3256 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3257
3258
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.

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 3283 of file z3py.py.

3283def RealVal(val, ctx=None):
3284 """Return a Z3 real value.
3285
3286 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3287 If `ctx=None`, then the global context is used.
3288
3289 >>> RealVal(1)
3290 1
3291 >>> RealVal(1).sort()
3292 Real
3293 >>> RealVal("3/5")
3294 3/5
3295 >>> RealVal("1.5")
3296 3/2
3297 """
3298 ctx = _get_ctx(ctx)
3299 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3300
3301

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 1528 of file z3py.py.

1528def RealVar(idx: int, ctx=None) -> ExprRef:
1529 """
1530 Create a real free variable. Free variables are used to create quantified formulas.
1531 They are also used to create polynomials.
1532
1533 >>> RealVar(0)
1534 Var(0)
1535 """
1536 return Var(idx, RealSort(ctx))
1537

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 1538 of file z3py.py.

1538def RealVarVector(n: int, ctx= None):
1539 """
1540 Create a list of Real free variables.
1541 The variables have ids: 0, 1, ..., n-1
1542
1543 >>> x0, x1, x2, x3 = RealVarVector(4)
1544 >>> x2
1545 Var(2)
1546 """
1547 return [RealVar(i, ctx) for i in range(n)]
1548

◆ 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 3412 of file z3py.py.

3412def RealVector(prefix, sz, ctx=None):
3413 """Return a list of real constants of size `sz`.
3414
3415 >>> X = RealVector('x', 3)
3416 >>> X
3417 [x__0, x__1, x__2]
3418 >>> Sum(X)
3419 x__0 + x__1 + x__2
3420 >>> Sum(X).sort()
3421 Real
3422 """
3423 ctx = _get_ctx(ctx)
3424 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3425
3426

◆ 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 963 of file z3py.py.

963def RecAddDefinition(f, args, body):
964 """Set the body of a recursive function.
965 Recursive definitions can be simplified if they are applied to ground
966 arguments.
967 >>> ctx = Context()
968 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
969 >>> n = Int('n', ctx)
970 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
971 >>> simplify(fac(5))
972 120
973 >>> s = Solver(ctx=ctx)
974 >>> s.add(fac(n) < 3)
975 >>> s.check()
976 sat
977 >>> s.model().eval(fac(5))
978 120
979 """
980 if is_app(args):
981 args = [args]
982 ctx = body.ctx
983 args = _get_args(args)
984 n = len(args)
985 _args = (Ast * n)()
986 for i in range(n):
987 _args[i] = args[i].ast
988 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
989
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 945 of file z3py.py.

945def RecFunction(name, *sig):
946 """Create a new Z3 recursive with the given sorts."""
947 sig = _get_args(sig)
948 if z3_debug():
949 _z3_assert(len(sig) > 0, "At least two arguments expected")
950 arity = len(sig) - 1
951 rng = sig[arity]
952 if z3_debug():
953 _z3_assert(is_sort(rng), "Z3 sort expected")
954 dom = (Sort * arity)()
955 for i in range(arity):
956 if z3_debug():
957 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
958 dom[i] = sig[i].ast
959 ctx = rng.ctx
960 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
961
962
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 8654 of file z3py.py.

8654def Repeat(t, max=4294967295, ctx=None):
8655 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8656 or the maximum number of iterations `max` is reached.
8657
8658 >>> x, y = Ints('x y')
8659 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8660 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8661 >>> r = t(c)
8662 >>> for subgoal in r: print(subgoal)
8663 [x == 0, y == 0, x > y]
8664 [x == 0, y == 1, x > y]
8665 [x == 1, y == 0, x > y]
8666 [x == 1, y == 1, x > y]
8667 >>> t = Then(t, Tactic('propagate-values'))
8668 >>> t(c)
8669 [[x == 1, y == 0]]
8670 """
8671 t = _to_tactic(t, ctx)
8672 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8673
8674
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 4511 of file z3py.py.

4511def RepeatBitVec(n, a):
4512 """Return an expression representing `n` copies of `a`.
4513
4514 >>> x = BitVec('x', 8)
4515 >>> n = RepeatBitVec(4, x)
4516 >>> n
4517 RepeatBitVec(4, x)
4518 >>> n.size()
4519 32
4520 >>> v0 = BitVecVal(10, 4)
4521 >>> print("%.x" % v0.as_long())
4522 a
4523 >>> v = simplify(RepeatBitVec(4, v0))
4524 >>> v.size()
4525 16
4526 >>> print("%.x" % v.as_long())
4527 aaaa
4528 """
4529 if z3_debug():
4530 _z3_assert(_is_int(n), "First argument must be an integer")
4531 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4532 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4533
4534
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 11292 of file z3py.py.

11292def Replace(s, src, dst):
11293 """Replace the first occurrence of 'src' by 'dst' in 's'
11294 >>> r = Replace("aaa", "a", "b")
11295 >>> simplify(r)
11296 "baa"
11297 """
11298 ctx = _get_ctx2(dst, s)
11299 if ctx is None and is_expr(src):
11300 ctx = src.ctx
11301 src = _coerce_seq(src, ctx)
11302 dst = _coerce_seq(dst, ctx)
11303 s = _coerce_seq(s, ctx)
11304 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11305
11306
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.

◆ reset_params()

None reset_params ( )
Reset all global (or module) parameters.

Definition at line 305 of file z3py.py.

305def reset_params() -> None:
306 """Reset all global (or module) parameters.
307 """
309
310
void Z3_API Z3_global_param_reset_all(void)
Restore the value of all global (and module) parameters. This command will not affect already created...

◆ ReSort()

ReSort ( s)

Definition at line 11426 of file z3py.py.

11426def ReSort(s):
11427 if is_ast(s):
11428 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11429 if s is None or isinstance(s, Context):
11430 ctx = _get_ctx(s)
11431 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11432 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11433
11434
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.

◆ RNA()

RNA ( ctx = None)

Definition at line 9916 of file z3py.py.

9916def RNA(ctx=None):
9917 ctx = _get_ctx(ctx)
9918 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9919
9920
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_away(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.

◆ RNE()

RNE ( ctx = None)

Definition at line 9906 of file z3py.py.

9906def RNE(ctx=None):
9907 ctx = _get_ctx(ctx)
9908 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9909
9910
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_even(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.

◆ 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 4421 of file z3py.py.

4421def RotateLeft(a, b):
4422 """Return an expression representing `a` rotated to the left `b` times.
4423
4424 >>> a, b = BitVecs('a b', 16)
4425 >>> RotateLeft(a, b)
4426 RotateLeft(a, b)
4427 >>> simplify(RotateLeft(a, 0))
4428 a
4429 >>> simplify(RotateLeft(a, 16))
4430 a
4431 """
4432 _check_bv_args(a, b)
4433 a, b = _coerce_exprs(a, b)
4434 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4435
4436
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 4437 of file z3py.py.

4437def RotateRight(a, b):
4438 """Return an expression representing `a` rotated to the right `b` times.
4439
4440 >>> a, b = BitVecs('a b', 16)
4441 >>> RotateRight(a, b)
4442 RotateRight(a, b)
4443 >>> simplify(RotateRight(a, 0))
4444 a
4445 >>> simplify(RotateRight(a, 16))
4446 a
4447 """
4448 _check_bv_args(a, b)
4449 a, b = _coerce_exprs(a, b)
4450 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4451
4452
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)

Definition at line 9911 of file z3py.py.

9911def RoundNearestTiesToAway(ctx=None):
9912 ctx = _get_ctx(ctx)
9913 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9914
9915

◆ RoundNearestTiesToEven()

RoundNearestTiesToEven ( ctx = None)

Definition at line 9901 of file z3py.py.

9901def RoundNearestTiesToEven(ctx=None):
9902 ctx = _get_ctx(ctx)
9903 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9904
9905

◆ RoundTowardNegative()

RoundTowardNegative ( ctx = None)

Definition at line 9931 of file z3py.py.

9931def RoundTowardNegative(ctx=None):
9932 ctx = _get_ctx(ctx)
9933 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9934
9935
Z3_ast Z3_API Z3_mk_fpa_round_toward_negative(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode.

◆ RoundTowardPositive()

RoundTowardPositive ( ctx = None)

Definition at line 9921 of file z3py.py.

9921def RoundTowardPositive(ctx=None):
9922 ctx = _get_ctx(ctx)
9923 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9924
9925
Z3_ast Z3_API Z3_mk_fpa_round_toward_positive(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode.

◆ RoundTowardZero()

RoundTowardZero ( ctx = None)

Definition at line 9941 of file z3py.py.

9941def RoundTowardZero(ctx=None):
9942 ctx = _get_ctx(ctx)
9943 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9944
9945
Z3_ast Z3_API Z3_mk_fpa_round_toward_zero(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.

◆ RTN()

RTN ( ctx = None)

Definition at line 9936 of file z3py.py.

9936def RTN(ctx=None):
9937 ctx = _get_ctx(ctx)
9938 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9939
9940

◆ RTP()

RTP ( ctx = None)

Definition at line 9926 of file z3py.py.

9926def RTP(ctx=None):
9927 ctx = _get_ctx(ctx)
9928 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9929
9930

◆ RTZ()

RTZ ( ctx = None)

Definition at line 9946 of file z3py.py.

9946def RTZ(ctx=None):
9947 ctx = _get_ctx(ctx)
9948 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9949
9950

◆ 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 4897 of file z3py.py.

4897def Select(a, *args):
4898 """Return a Z3 select array expression.
4899
4900 >>> a = Array('a', IntSort(), IntSort())
4901 >>> i = Int('i')
4902 >>> Select(a, i)
4903 a[i]
4904 >>> eq(Select(a, i), a[i])
4905 True
4906 """
4907 args = _get_args(args)
4908 if z3_debug():
4909 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4910 return a[args]
4911
4912

◆ SeqFoldLeft()

SeqFoldLeft ( f,
a,
s )

Definition at line 11359 of file z3py.py.

11359def SeqFoldLeft(f, a, s):
11360 ctx = _get_ctx2(f, s)
11361 s = _coerce_seq(s, ctx)
11362 a = _py2expr(a)
11363 return _to_expr_ref(Z3_mk_seq_foldl(s.ctx_ref(), f.as_ast(), a.as_ast(), s.as_ast()), ctx)
11364
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 11365 of file z3py.py.

11365def SeqFoldLeftI(f, i, a, s):
11366 ctx = _get_ctx2(f, s)
11367 s = _coerce_seq(s, ctx)
11368 a = _py2expr(a)
11369 i = _py2epxr(i)
11370 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11371
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 11345 of file z3py.py.

11345def SeqMap(f, s):
11346 """Map function 'f' over sequence 's'"""
11347 ctx = _get_ctx2(f, s)
11348 s = _coerce_seq(s, ctx)
11349 return _to_expr_ref(Z3_mk_seq_map(s.ctx_ref(), f.as_ast(), s.as_ast()), ctx)
11350
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 11351 of file z3py.py.

11351def SeqMapI(f, i, s):
11352 """Map function 'f' over sequence 's' at index 'i'"""
11353 ctx = _get_ctx2(f, s)
11354 s = _coerce_seq(s, ctx)
11355 if not is_expr(i):
11356 i = _py2expr(i)
11357 return _to_expr_ref(Z3_mk_seq_mapi(s.ctx_ref(), f.as_ast(), i.as_ast(), s.as_ast()), ctx)
11358
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 11010 of file z3py.py.

11010def SeqSort(s):
11011 """Create a sequence sort over elements provided in the argument
11012 >>> s = SeqSort(IntSort())
11013 >>> s == Unit(IntVal(1)).sort()
11014 True
11015 """
11016 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
11017
11018
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 )

Definition at line 9562 of file z3py.py.

9562def set_default_fp_sort(ebits, sbits, ctx=None):
9563 global _dflt_fpsort_ebits
9564 global _dflt_fpsort_sbits
9565 _dflt_fpsort_ebits = ebits
9566 _dflt_fpsort_sbits = sbits
9567
9568

◆ set_default_rounding_mode()

set_default_rounding_mode ( rm,
ctx = None )

Definition at line 9549 of file z3py.py.

9549def set_default_rounding_mode(rm, ctx=None):
9550 global _dflt_rounding_mode
9551 if is_fprm_value(rm):
9552 _dflt_rounding_mode = rm.kind()
9553 else:
9554 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9555 _dflt_rounding_mode = rm
9556
9557

◆ set_option()

set_option ( * args,
** kws )
Alias for 'set_param' for backward compatibility.

Definition at line 311 of file z3py.py.

311def set_option(*args, **kws):
312 """Alias for 'set_param' for backward compatibility.
313 """
314 return set_param(*args, **kws)
315
316

◆ set_param()

set_param ( * args,
** kws )
Set Z3 global (or module) parameters.

>>> set_param(precision=10)

Definition at line 281 of file z3py.py.

281def set_param(*args, **kws):
282 """Set Z3 global (or module) parameters.
283
284 >>> set_param(precision=10)
285 """
286 if z3_debug():
287 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
288 new_kws = {}
289 for k in kws:
290 v = kws[k]
291 if not set_pp_option(k, v):
292 new_kws[k] = v
293 for key in new_kws:
294 value = new_kws[key]
295 Z3_global_param_set(str(key).upper(), _to_param_value(value))
296 prev = None
297 for a in args:
298 if prev is None:
299 prev = a
300 else:
301 Z3_global_param_set(str(prev), _to_param_value(a))
302 prev = None
303
304
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.

Referenced by set_option().

◆ SetAdd()

SetAdd ( s,
e )
 Add element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetAdd(a, 1)
Store(a, 1, True)

Definition at line 5056 of file z3py.py.

5056def SetAdd(s, e):
5057 """ Add element e to set s
5058 >>> a = Const('a', SetSort(IntSort()))
5059 >>> SetAdd(a, 1)
5060 Store(a, 1, True)
5061 """
5062 ctx = _ctx_from_ast_arg_list([s, e])
5063 e = _py2expr(e, ctx)
5064 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5065
5066
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 5078 of file z3py.py.

5078def SetComplement(s):
5079 """ The complement of set s
5080 >>> a = Const('a', SetSort(IntSort()))
5081 >>> SetComplement(a)
5082 complement(a)
5083 """
5084 ctx = s.ctx
5085 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
5086
5087
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 5067 of file z3py.py.

5067def SetDel(s, e):
5068 """ Remove element e to set s
5069 >>> a = Const('a', SetSort(IntSort()))
5070 >>> SetDel(a, 1)
5071 Store(a, 1, False)
5072 """
5073 ctx = _ctx_from_ast_arg_list([s, e])
5074 e = _py2expr(e, ctx)
5075 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5076
5077
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 5088 of file z3py.py.

5088def SetDifference(a, b):
5089 """ The set difference of a and b
5090 >>> a = Const('a', SetSort(IntSort()))
5091 >>> b = Const('b', SetSort(IntSort()))
5092 >>> SetDifference(a, b)
5093 setminus(a, b)
5094 """
5095 ctx = _ctx_from_ast_arg_list([a, b])
5096 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5097
5098
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.

◆ SetHasSize()

SetHasSize ( a,
k )

Definition at line 4970 of file z3py.py.

4970def SetHasSize(a, k):
4971 ctx = a.ctx
4972 k = _py2expr(k, ctx)
4973 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4974
4975
Z3_ast Z3_API Z3_mk_set_has_size(Z3_context c, Z3_ast set, Z3_ast k)
Create predicate that holds if Boolean array set has k elements set to true.

◆ 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 5043 of file z3py.py.

5043def SetIntersect(*args):
5044 """ Take the union of sets
5045 >>> a = Const('a', SetSort(IntSort()))
5046 >>> b = Const('b', SetSort(IntSort()))
5047 >>> SetIntersect(a, b)
5048 intersection(a, b)
5049 """
5050 args = _get_args(args)
5051 ctx = _ctx_from_ast_arg_list(args)
5052 _args, sz = _to_ast_array(args)
5053 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
5054
5055
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)

Sets.

Create a set sort over element sort s

Definition at line 5007 of file z3py.py.

5007def SetSort(s):
5008 """ Create a set sort over element sort s"""
5009 return ArraySort(s, BoolSort())
5010
5011

◆ 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 5030 of file z3py.py.

5030def SetUnion(*args):
5031 """ Take the union of sets
5032 >>> a = Const('a', SetSort(IntSort()))
5033 >>> b = Const('b', SetSort(IntSort()))
5034 >>> SetUnion(a, b)
5035 union(a, b)
5036 """
5037 args = _get_args(args)
5038 ctx = _ctx_from_ast_arg_list(args)
5039 _args, sz = _to_ast_array(args)
5040 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
5041
5042
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 4453 of file z3py.py.

4453def SignExt(n, a):
4454 """Return a bit-vector expression with `n` extra sign-bits.
4455
4456 >>> x = BitVec('x', 16)
4457 >>> n = SignExt(8, x)
4458 >>> n.size()
4459 24
4460 >>> n
4461 SignExt(8, x)
4462 >>> n.sort()
4463 BitVec(24)
4464 >>> v0 = BitVecVal(2, 2)
4465 >>> v0
4466 2
4467 >>> v0.size()
4468 2
4469 >>> v = simplify(SignExt(6, v0))
4470 >>> v
4471 254
4472 >>> v.size()
4473 8
4474 >>> print("%.x" % v.as_long())
4475 fe
4476 """
4477 if z3_debug():
4478 _z3_assert(_is_int(n), "First argument must be an integer")
4479 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4480 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4481
4482
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 7581 of file z3py.py.

7581def SimpleSolver(ctx=None, logFile=None):
7582 """Return a simple general purpose solver with limited amount of preprocessing.
7583
7584 >>> s = SimpleSolver()
7585 >>> x = Int('x')
7586 >>> s.add(x > 0)
7587 >>> s.check()
7588 sat
7589 """
7590 ctx = _get_ctx(ctx)
7591 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7592
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.

◆ simplify()

simplify ( a,
* arguments,
** keywords )

Utils.

Simplify the expression `a` using the given options.

This function has many options. Use `help_simplify` to obtain the complete list.

>>> x = Int('x')
>>> y = Int('y')
>>> simplify(x + 1 + y + x + 1)
2 + 2*x + y
>>> simplify((x + 1)*(y + 1), som=True)
1 + x + y + x*y
>>> simplify(Distinct(x, y, 1), blast_distinct=True)
And(Not(x == y), Not(x == 1), Not(y == 1))
>>> simplify(And(x == 0, y == 1), elim_and=True)
Not(Or(Not(x == 0), Not(y == 1)))

Definition at line 9006 of file z3py.py.

9006def simplify(a, *arguments, **keywords):
9007 """Simplify the expression `a` using the given options.
9008
9009 This function has many options. Use `help_simplify` to obtain the complete list.
9010
9011 >>> x = Int('x')
9012 >>> y = Int('y')
9013 >>> simplify(x + 1 + y + x + 1)
9014 2 + 2*x + y
9015 >>> simplify((x + 1)*(y + 1), som=True)
9016 1 + x + y + x*y
9017 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9018 And(Not(x == y), Not(x == 1), Not(y == 1))
9019 >>> simplify(And(x == 0, y == 1), elim_and=True)
9020 Not(Or(Not(x == 0), Not(y == 1)))
9021 """
9022 if z3_debug():
9023 _z3_assert(is_expr(a), "Z3 expression expected")
9024 if len(arguments) > 0 or len(keywords) > 0:
9025 p = args2params(arguments, keywords, a.ctx)
9026 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
9027 else:
9028 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
9029
9030
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.

Referenced by Q(), and RatVal().

◆ simplify_param_descrs()

simplify_param_descrs ( )
Return the set of parameter descriptions for Z3 `simplify` procedure.

Definition at line 9036 of file z3py.py.

9036def simplify_param_descrs():
9037 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9038 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
9039
9040
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.

◆ solve()

solve ( * args,
** keywords )
Solve the constraints `*args`.

This is a simple function for creating demonstrations. It creates a solver,
configure it using the options in `keywords`, adds the constraints
in `args`, and invokes check.

>>> a = Int('a')
>>> solve(a > 0, a < 2)
[a = 1]

Definition at line 9268 of file z3py.py.

9268def solve(*args, **keywords):
9269 """Solve the constraints `*args`.
9270
9271 This is a simple function for creating demonstrations. It creates a solver,
9272 configure it using the options in `keywords`, adds the constraints
9273 in `args`, and invokes check.
9274
9275 >>> a = Int('a')
9276 >>> solve(a > 0, a < 2)
9277 [a = 1]
9278 """
9279 show = keywords.pop("show", False)
9280 s = Solver()
9281 s.set(**keywords)
9282 s.add(*args)
9283 if show:
9284 print(s)
9285 r = s.check()
9286 if r == unsat:
9287 print("no solution")
9288 elif r == unknown:
9289 print("failed to solve")
9290 try:
9291 print(s.model())
9292 except Z3Exception:
9293 return
9294 else:
9295 print(s.model())
9296
9297

◆ 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 9298 of file z3py.py.

9298def solve_using(s, *args, **keywords):
9299 """Solve the constraints `*args` using solver `s`.
9300
9301 This is a simple function for creating demonstrations. It is similar to `solve`,
9302 but it uses the given solver `s`.
9303 It configures solver `s` using the options in `keywords`, adds the constraints
9304 in `args`, and invokes check.
9305 """
9306 show = keywords.pop("show", False)
9307 if z3_debug():
9308 _z3_assert(isinstance(s, Solver), "Solver object expected")
9309 s.set(**keywords)
9310 s.add(*args)
9311 if show:
9312 print("Problem:")
9313 print(s)
9314 r = s.check()
9315 if r == unsat:
9316 print("no solution")
9317 elif r == unknown:
9318 print("failed to solve")
9319 try:
9320 print(s.model())
9321 except Z3Exception:
9322 return
9323 else:
9324 if show:
9325 print("Solution:")
9326 print(s.model())
9327
9328

◆ 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 7560 of file z3py.py.

7560def SolverFor(logic, ctx=None, logFile=None):
7561 """Create a solver customized for the given logic.
7562
7563 The parameter `logic` is a string. It should be contains
7564 the name of a SMT-LIB logic.
7565 See http://www.smtlib.org/ for the name of all available logics.
7566
7567 >>> s = SolverFor("QF_LIA")
7568 >>> x = Int('x')
7569 >>> s.add(x > 0)
7570 >>> s.add(x < 2)
7571 >>> s.check()
7572 sat
7573 >>> s.model()
7574 [x = 1]
7575 """
7576 ctx = _get_ctx(ctx)
7577 logic = to_symbol(logic)
7578 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7579
7580
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 3496 of file z3py.py.

3496def Sqrt(a, ctx=None):
3497 """ Return a Z3 expression which represents the square root of a.
3498
3499 >>> x = Real('x')
3500 >>> Sqrt(x)
3501 x**(1/2)
3502 """
3503 if not is_expr(a):
3504 ctx = _get_ctx(ctx)
3505 a = RealVal(a, ctx)
3506 return a ** "1/2"
3507
3508

◆ 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 4368 of file z3py.py.

4368def SRem(a, b):
4369 """Create the Z3 expression signed remainder.
4370
4371 Use the operator % for signed modulus, and URem() for unsigned remainder.
4372
4373 >>> x = BitVec('x', 32)
4374 >>> y = BitVec('y', 32)
4375 >>> SRem(x, y)
4376 SRem(x, y)
4377 >>> SRem(x, y).sort()
4378 BitVec(32)
4379 >>> (x % y).sexpr()
4380 '(bvsmod x y)'
4381 >>> SRem(x, y).sexpr()
4382 '(bvsrem x y)'
4383 """
4384 _check_bv_args(a, b)
4385 a, b = _coerce_exprs(a, b)
4386 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4387
4388
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 11533 of file z3py.py.

11533def Star(re):
11534 """Create the regular expression accepting zero or more repetitions of argument.
11535 >>> re = Star(Re("a"))
11536 >>> print(simplify(InRe("aa", re)))
11537 True
11538 >>> print(simplify(InRe("ab", re)))
11539 False
11540 >>> print(simplify(InRe("", re)))
11541 True
11542 """
11543 if z3_debug():
11544 _z3_assert(is_expr(re), "expression expected")
11545 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11546
11547
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.

◆ 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 4880 of file z3py.py.

4880def Store(a, *args):
4881 """Return a Z3 store array expression.
4882
4883 >>> a = Array('a', IntSort(), IntSort())
4884 >>> i, v = Ints('i v')
4885 >>> s = Store(a, i, v)
4886 >>> s.sort()
4887 Array(Int, Int)
4888 >>> prove(s[i] == v)
4889 proved
4890 >>> j = Int('j')
4891 >>> prove(Implies(i != j, s[j] == a[j]))
4892 proved
4893 """
4894 return Update(a, args)
4895
4896

Referenced by ModelRef.get_interp().

◆ StrFromCode()

StrFromCode ( c)
Convert code to a string

Definition at line 11401 of file z3py.py.

11401def StrFromCode(c):
11402 """Convert code to a string"""
11403 if not is_expr(c):
11404 c = _py2expr(c)
11405 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11406
Z3_ast Z3_API Z3_mk_string_from_code(Z3_context c, Z3_ast a)
Code to string conversion.

◆ 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 11176 of file z3py.py.

11176def String(name, ctx=None):
11177 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11178
11179 >>> x = String('x')
11180 """
11181 ctx = _get_ctx(ctx)
11182 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
11183
11184

◆ Strings()

Strings ( names,
ctx = None )
Return a tuple of String constants. 

Definition at line 11185 of file z3py.py.

11185def Strings(names, ctx=None):
11186 """Return a tuple of String constants. """
11187 ctx = _get_ctx(ctx)
11188 if isinstance(names, str):
11189 names = names.split(" ")
11190 return [String(name, ctx) for name in names]
11191
11192

◆ StringSort()

StringSort ( ctx = None)
Create a string sort
>>> s = StringSort()
>>> print(s)
String

Definition at line 10991 of file z3py.py.

10991def StringSort(ctx=None):
10992 """Create a string sort
10993 >>> s = StringSort()
10994 >>> print(s)
10995 String
10996 """
10997 ctx = _get_ctx(ctx)
10998 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10999

◆ StringVal()

StringVal ( s,
ctx = None )
create a string expression

Definition at line 11169 of file z3py.py.

11169def StringVal(s, ctx=None):
11170 """create a string expression"""
11171 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11172 ctx = _get_ctx(ctx)
11173 return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
11174
11175
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 11395 of file z3py.py.

11395def StrToCode(s):
11396 """Convert a unit length string to integer code"""
11397 if not is_expr(s):
11398 s = _py2expr(s)
11399 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11400
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 11372 of file z3py.py.

11372def StrToInt(s):
11373 """Convert string expression to integer
11374 >>> a = StrToInt("1")
11375 >>> simplify(1 == a)
11376 True
11377 >>> b = StrToInt("2")
11378 >>> simplify(1 == b)
11379 False
11380 >>> c = StrToInt(IntToStr(2))
11381 >>> simplify(1 == c)
11382 False
11383 """
11384 s = _coerce_seq(s)
11385 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11386
11387
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.

◆ SubSeq()

SubSeq ( s,
offset,
length )
Extract substring or subsequence starting at offset

Definition at line 11198 of file z3py.py.

11198def SubSeq(s, offset, length):
11199 """Extract substring or subsequence starting at offset"""
11200 return Extract(s, offset, length)
11201
11202

◆ 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 9041 of file z3py.py.

9041def substitute(t, *m):
9042 """Apply substitution m on t, m is a list of pairs of the form (from, to).
9043 Every occurrence in t of from is replaced with to.
9044
9045 >>> x = Int('x')
9046 >>> y = Int('y')
9047 >>> substitute(x + 1, (x, y + 1))
9048 y + 1 + 1
9049 >>> f = Function('f', IntSort(), IntSort())
9050 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
9051 1 + 1
9052 """
9053 if isinstance(m, tuple):
9054 m1 = _get_args(m)
9055 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9056 m = m1
9057 if z3_debug():
9058 _z3_assert(is_expr(t), "Z3 expression expected")
9059 _z3_assert(
9060 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
9061 "Z3 invalid substitution, expression pairs expected.")
9062 _z3_assert(
9063 all([p[0].sort().eq(p[1].sort()) for p in m]),
9064 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
9065 num = len(m)
9066 _from = (Ast * num)()
9067 _to = (Ast * num)()
9068 for i in range(num):
9069 _from[i] = m[i][0].as_ast()
9070 _to[i] = m[i][1].as_ast()
9071 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
9072
9073
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 9094 of file z3py.py.

9094def substitute_funs(t, *m):
9095 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
9096 Every occurrence in to of the function from is replaced with the expression to.
9097 The expression to can have free variables, that refer to the arguments of from.
9098 For examples, see
9099 """
9100 if isinstance(m, tuple):
9101 m1 = _get_args(m)
9102 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9103 m = m1
9104 if z3_debug():
9105 _z3_assert(is_expr(t), "Z3 expression expected")
9106 _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.")
9107 num = len(m)
9108 _from = (FuncDecl * num)()
9109 _to = (Ast * num)()
9110 for i in range(num):
9111 _from[i] = m[i][0].as_func_decl()
9112 _to[i] = m[i][1].as_ast()
9113 return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
9114
9115
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 9074 of file z3py.py.

9074def substitute_vars(t, *m):
9075 """Substitute the free variables in t with the expression in m.
9076
9077 >>> v0 = Var(0, IntSort())
9078 >>> v1 = Var(1, IntSort())
9079 >>> x = Int('x')
9080 >>> f = Function('f', IntSort(), IntSort(), IntSort())
9081 >>> # replace v0 with x+1 and v1 with x
9082 >>> substitute_vars(f(v0, v1), x + 1, x)
9083 f(x + 1, x)
9084 """
9085 if z3_debug():
9086 _z3_assert(is_expr(t), "Z3 expression expected")
9087 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
9088 num = len(m)
9089 _to = (Ast * num)()
9090 for i in range(num):
9091 _to[i] = m[i].as_ast()
9092 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
9093
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

Definition at line 11193 of file z3py.py.

11193def SubString(s, offset, length):
11194 """Extract substring or subsequence starting at offset"""
11195 return Extract(s, offset, length)
11196
11197

◆ 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 11258 of file z3py.py.

11258def SuffixOf(a, b):
11259 """Check if 'a' is a suffix of 'b'
11260 >>> s1 = SuffixOf("ab", "abc")
11261 >>> simplify(s1)
11262 False
11263 >>> s2 = SuffixOf("bc", "abc")
11264 >>> simplify(s2)
11265 True
11266 """
11267 ctx = _get_ctx2(a, b)
11268 a = _coerce_seq(a, ctx)
11269 b = _coerce_seq(b, ctx)
11270 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11271
11272
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 9116 of file z3py.py.

9116def Sum(*args):
9117 """Create the sum of the Z3 expressions.
9118
9119 >>> a, b, c = Ints('a b c')
9120 >>> Sum(a, b, c)
9121 a + b + c
9122 >>> Sum([a, b, c])
9123 a + b + c
9124 >>> A = IntVector('a', 5)
9125 >>> Sum(A)
9126 a__0 + a__1 + a__2 + a__3 + a__4
9127 """
9128 args = _get_args(args)
9129 if len(args) == 0:
9130 return 0
9131 ctx = _ctx_from_ast_arg_list(args)
9132 if ctx is None:
9133 return _reduce(lambda a, b: a + b, args, 0)
9134 args = _coerce_expr_list(args, ctx)
9135 if is_bv(args[0]):
9136 return _reduce(lambda a, b: a + b, args, 0)
9137 else:
9138 _args, sz = _to_ast_array(args)
9139 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
9140
9141
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 8695 of file z3py.py.

8695def tactic_description(name, ctx=None):
8696 """Return a short description for the tactic named `name`.
8697
8698 >>> d = tactic_description('simplify')
8699 """
8700 ctx = _get_ctx(ctx)
8701 return Z3_tactic_get_descr(ctx.ref(), name)
8702
8703
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 8684 of file z3py.py.

8684def tactics(ctx=None):
8685 """Return a list of all available tactics in Z3.
8686
8687 >>> l = tactics()
8688 >>> l.count('simplify') == 1
8689 True
8690 """
8691 ctx = _get_ctx(ctx)
8692 return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8693
8694
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 8552 of file z3py.py.

8552def Then(*ts, **ks):
8553 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8554
8555 >>> x, y = Ints('x y')
8556 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8557 >>> t(And(x == 0, y > x + 1))
8558 [[Not(y <= 1)]]
8559 >>> t(And(x == 0, y > x + 1)).as_expr()
8560 Not(y <= 1)
8561 """
8562 return AndThen(*ts, **ks)
8563
8564

◆ to_Ast()

to_Ast ( ptr)

Definition at line 11617 of file z3py.py.

11617def to_Ast(ptr,):
11618 ast = Ast(ptr)
11619 super(ctypes.c_void_p, ast).__init__(ptr)
11620 return ast
11621

◆ to_AstVectorObj()

to_AstVectorObj ( ptr)

Definition at line 11627 of file z3py.py.

11627def to_AstVectorObj(ptr,):
11628 v = AstVectorObj(ptr)
11629 super(ctypes.c_void_p, v).__init__(ptr)
11630 return v
11631
11632# NB. my-hacky-class only works for a single instance of OnClause
11633# it should be replaced with a proper correlation between OnClause
11634# and object references that can be passed over the FFI.
11635# for UserPropagator we use a global dictionary, which isn't great code.
11636

◆ to_ContextObj()

to_ContextObj ( ptr)

Definition at line 11622 of file z3py.py.

11622def to_ContextObj(ptr,):
11623 ctx = ContextObj(ptr)
11624 super(ctypes.c_void_p, ctx).__init__(ptr)
11625 return ctx
11626

◆ 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):
135 return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
136 else:
137 return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
138
139
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.

Referenced by _mk_quantifier(), Array(), BitVec(), Bool(), Const(), CreateDatatypes(), DatatypeSort(), DeclareSort(), DeclareTypeVar(), EnumSort(), Function(), ParamDescrsRef.get_documentation(), ParamDescrsRef.get_kind(), Int(), Real(), RecFunction(), and ParamsRef.set().

◆ ToInt()

ToInt ( a)
 Return the Z3 expression ToInt(a).

>>> x = Real('x')
>>> x.sort()
Real
>>> n = ToInt(x)
>>> n
ToInt(x)
>>> n.sort()
Int

Definition at line 3461 of file z3py.py.

3461def ToInt(a):
3462 """ Return the Z3 expression ToInt(a).
3463
3464 >>> x = Real('x')
3465 >>> x.sort()
3466 Real
3467 >>> n = ToInt(x)
3468 >>> n
3469 ToInt(x)
3470 >>> n.sort()
3471 Int
3472 """
3473 if z3_debug():
3474 _z3_assert(a.is_real(), "Z3 real expression expected.")
3475 ctx = a.ctx
3476 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3477
3478
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.

◆ 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 3441 of file z3py.py.

3441def ToReal(a):
3442 """ Return the Z3 expression ToReal(a).
3443
3444 >>> x = Int('x')
3445 >>> x.sort()
3446 Int
3447 >>> n = ToReal(x)
3448 >>> n
3449 ToReal(x)
3450 >>> n.sort()
3451 Real
3452 """
3453 ctx = a.ctx
3454 if isinstance(a, BoolRef):
3455 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3456 if z3_debug():
3457 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3458 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3459
3460
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.

◆ 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 11610 of file z3py.py.

11610def TransitiveClosure(f):
11611 """Given a binary relation R, such that the two arguments have the same sort
11612 create the transitive closure relation R+.
11613 The transitive closure R+ is a new relation.
11614 """
11615 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11616
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 )

Definition at line 11602 of file z3py.py.

11602def TreeOrder(a, index):
11603 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11604
11605
Z3_func_decl Z3_API Z3_mk_tree_order(Z3_context c, Z3_sort a, unsigned id)
create a tree ordering relation over signature a identified using index id.

◆ 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 8675 of file z3py.py.

8675def TryFor(t, ms, ctx=None):
8676 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8677
8678 If `t` does not terminate in `ms` milliseconds, then it fails.
8679 """
8680 t = _to_tactic(t, ctx)
8681 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8682
8683
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 5453 of file z3py.py.

5453def TupleSort(name, sorts, ctx=None):
5454 """Create a named tuple sort base on a set of underlying sorts
5455 Example:
5456 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5457 """
5458 tuple = Datatype(name, ctx)
5459 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5460 tuple.declare(name, *projects)
5461 tuple = tuple.create()
5462 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5463
5464

◆ 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 4326 of file z3py.py.

4326def UDiv(a, b):
4327 """Create the Z3 expression (unsigned) division `self / other`.
4328
4329 Use the operator / for signed division.
4330
4331 >>> x = BitVec('x', 32)
4332 >>> y = BitVec('y', 32)
4333 >>> UDiv(x, y)
4334 UDiv(x, y)
4335 >>> UDiv(x, y).sort()
4336 BitVec(32)
4337 >>> (x / y).sexpr()
4338 '(bvsdiv x y)'
4339 >>> UDiv(x, y).sexpr()
4340 '(bvudiv x y)'
4341 """
4342 _check_bv_args(a, b)
4343 a, b = _coerce_exprs(a, b)
4344 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4345
4346
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.

◆ 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 4290 of file z3py.py.

4290def UGE(a, b):
4291 """Create the Z3 expression (unsigned) `other >= self`.
4292
4293 Use the operator >= for signed greater than or equal to.
4294
4295 >>> x, y = BitVecs('x y', 32)
4296 >>> UGE(x, y)
4297 UGE(x, y)
4298 >>> (x >= y).sexpr()
4299 '(bvsge x y)'
4300 >>> UGE(x, y).sexpr()
4301 '(bvuge x y)'
4302 """
4303 _check_bv_args(a, b)
4304 a, b = _coerce_exprs(a, b)
4305 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4306
4307
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 4308 of file z3py.py.

4308def UGT(a, b):
4309 """Create the Z3 expression (unsigned) `other > self`.
4310
4311 Use the operator > for signed greater than.
4312
4313 >>> x, y = BitVecs('x y', 32)
4314 >>> UGT(x, y)
4315 UGT(x, y)
4316 >>> (x > y).sexpr()
4317 '(bvsgt x y)'
4318 >>> UGT(x, y).sexpr()
4319 '(bvugt x y)'
4320 """
4321 _check_bv_args(a, b)
4322 a, b = _coerce_exprs(a, b)
4323 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4324
4325
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.

◆ 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 4254 of file z3py.py.

4254def ULE(a, b):
4255 """Create the Z3 expression (unsigned) `other <= self`.
4256
4257 Use the operator <= for signed less than or equal to.
4258
4259 >>> x, y = BitVecs('x y', 32)
4260 >>> ULE(x, y)
4261 ULE(x, y)
4262 >>> (x <= y).sexpr()
4263 '(bvsle x y)'
4264 >>> ULE(x, y).sexpr()
4265 '(bvule x y)'
4266 """
4267 _check_bv_args(a, b)
4268 a, b = _coerce_exprs(a, b)
4269 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4270
4271
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 4272 of file z3py.py.

4272def ULT(a, b):
4273 """Create the Z3 expression (unsigned) `other < self`.
4274
4275 Use the operator < for signed less than.
4276
4277 >>> x, y = BitVecs('x y', 32)
4278 >>> ULT(x, y)
4279 ULT(x, y)
4280 >>> (x < y).sexpr()
4281 '(bvslt x y)'
4282 >>> ULT(x, y).sexpr()
4283 '(bvult x y)'
4284 """
4285 _check_bv_args(a, b)
4286 a, b = _coerce_exprs(a, b)
4287 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4288
4289
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.

◆ 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 11460 of file z3py.py.

11460def Union(*args):
11461 """Create union of regular expressions.
11462 >>> re = Union(Re("a"), Re("b"), Re("c"))
11463 >>> print (simplify(InRe("d", re)))
11464 False
11465 """
11466 args = _get_args(args)
11467 sz = len(args)
11468 if z3_debug():
11469 _z3_assert(sz > 0, "At least one argument expected.")
11470 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11471 if sz == 1:
11472 return args[0]
11473 ctx = args[0].ctx
11474 v = (Ast * sz)()
11475 for i in range(sz):
11476 v[i] = args[i].as_ast()
11477 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11478
11479
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)
Create a singleton sequence

Definition at line 11238 of file z3py.py.

11238def Unit(a):
11239 """Create a singleton sequence"""
11240 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11241
11242
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of 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 4837 of file z3py.py.

4837def Update(a, *args):
4838 """Return a Z3 store array expression.
4839
4840 >>> a = Array('a', IntSort(), IntSort())
4841 >>> i, v = Ints('i v')
4842 >>> s = Update(a, i, v)
4843 >>> s.sort()
4844 Array(Int, Int)
4845 >>> prove(s[i] == v)
4846 proved
4847 >>> j = Int('j')
4848 >>> prove(Implies(i != j, s[j] == a[j]))
4849 proved
4850 """
4851 if z3_debug():
4852 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4853 args = _get_args(args)
4854 ctx = a.ctx
4855 if len(args) <= 1:
4856 raise Z3Exception("array update requires index and value arguments")
4857 if len(args) == 2:
4858 i = args[0]
4859 v = args[1]
4860 i = a.sort().domain().cast(i)
4861 v = a.sort().range().cast(v)
4862 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4863 v = a.sort().range().cast(args[-1])
4864 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4865 _args, sz = _to_ast_array(idxs)
4866 return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4867
4868
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
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 4347 of file z3py.py.

4347def URem(a, b):
4348 """Create the Z3 expression (unsigned) remainder `self % other`.
4349
4350 Use the operator % for signed modulus, and SRem() for signed remainder.
4351
4352 >>> x = BitVec('x', 32)
4353 >>> y = BitVec('y', 32)
4354 >>> URem(x, y)
4355 URem(x, y)
4356 >>> URem(x, y).sort()
4357 BitVec(32)
4358 >>> (x % y).sexpr()
4359 '(bvsmod x y)'
4360 >>> URem(x, y).sexpr()
4361 '(bvurem x y)'
4362 """
4363 _check_bv_args(a, b)
4364 a, b = _coerce_exprs(a, b)
4365 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4366
4367
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.

◆ user_prop_created()

user_prop_created ( ctx,
cb,
id )

Definition at line 11738 of file z3py.py.

11738def user_prop_created(ctx, cb, id):
11739 prop = _prop_closures.get(ctx)
11740 old_cb = prop.cb
11741 prop.cb = cb
11742 id = _to_expr_ref(to_Ast(id), prop.ctx())
11743 prop.created(id)
11744 prop.cb = old_cb
11745
11746

◆ user_prop_decide()

user_prop_decide ( ctx,
cb,
t_ref,
idx,
phase )

Definition at line 11772 of file z3py.py.

11772def user_prop_decide(ctx, cb, t_ref, idx, phase):
11773 prop = _prop_closures.get(ctx)
11774 old_cb = prop.cb
11775 prop.cb = cb
11776 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11777 prop.decide(t, idx, phase)
11778 prop.cb = old_cb
11779
11780

◆ user_prop_diseq()

user_prop_diseq ( ctx,
cb,
x,
y )

Definition at line 11763 of file z3py.py.

11763def user_prop_diseq(ctx, cb, x, y):
11764 prop = _prop_closures.get(ctx)
11765 old_cb = prop.cb
11766 prop.cb = cb
11767 x = _to_expr_ref(to_Ast(x), prop.ctx())
11768 y = _to_expr_ref(to_Ast(y), prop.ctx())
11769 prop.diseq(x, y)
11770 prop.cb = old_cb
11771

◆ user_prop_eq()

user_prop_eq ( ctx,
cb,
x,
y )

Definition at line 11754 of file z3py.py.

11754def user_prop_eq(ctx, cb, x, y):
11755 prop = _prop_closures.get(ctx)
11756 old_cb = prop.cb
11757 prop.cb = cb
11758 x = _to_expr_ref(to_Ast(x), prop.ctx())
11759 y = _to_expr_ref(to_Ast(y), prop.ctx())
11760 prop.eq(x, y)
11761 prop.cb = old_cb
11762

◆ user_prop_final()

user_prop_final ( ctx,
cb )

Definition at line 11747 of file z3py.py.

11747def user_prop_final(ctx, cb):
11748 prop = _prop_closures.get(ctx)
11749 old_cb = prop.cb
11750 prop.cb = cb
11751 prop.final()
11752 prop.cb = old_cb
11753

◆ user_prop_fixed()

user_prop_fixed ( ctx,
cb,
id,
value )

Definition at line 11729 of file z3py.py.

11729def user_prop_fixed(ctx, cb, id, value):
11730 prop = _prop_closures.get(ctx)
11731 old_cb = prop.cb
11732 prop.cb = cb
11733 id = _to_expr_ref(to_Ast(id), prop.ctx())
11734 value = _to_expr_ref(to_Ast(value), prop.ctx())
11735 prop.fixed(id, value)
11736 prop.cb = old_cb
11737

◆ user_prop_fresh()

user_prop_fresh ( ctx,
_new_ctx )

Definition at line 11715 of file z3py.py.

11715def user_prop_fresh(ctx, _new_ctx):
11716 _prop_closures.set_threaded()
11717 prop = _prop_closures.get(ctx)
11718 nctx = Context()
11719 Z3_del_context(nctx.ctx)
11720 new_ctx = to_ContextObj(_new_ctx)
11721 nctx.ctx = new_ctx
11722 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11723 nctx.owner = False
11724 new_prop = prop.fresh(nctx)
11725 _prop_closures.set(new_prop.id, new_prop)
11726 return new_prop.id
11727
11728
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
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 )

Definition at line 11709 of file z3py.py.

11709def user_prop_pop(ctx, cb, num_scopes):
11710 prop = _prop_closures.get(ctx)
11711 prop.cb = cb
11712 prop.pop(num_scopes)
11713
11714

◆ user_prop_push()

user_prop_push ( ctx,
cb )

Definition at line 11703 of file z3py.py.

11703def user_prop_push(ctx, cb):
11704 prop = _prop_closures.get(ctx)
11705 prop.cb = cb
11706 prop.push()
11707
11708

◆ Var()

ExprRef Var ( int idx,
SortRef s )
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 1513 of file z3py.py.

1513def Var(idx : int, s : SortRef) -> ExprRef:
1514 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1515 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1516 declarations.
1517
1518 >>> Var(0, IntSort())
1519 Var(0)
1520 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1521 False
1522 """
1523 if z3_debug():
1524 _z3_assert(is_sort(s), "Z3 sort expected")
1525 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1526
1527
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a variable.

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 8969 of file z3py.py.

8969def When(p, t, ctx=None):
8970 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8971 Otherwise, it returns the input goal unmodified.
8972
8973 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8974 >>> x, y = Ints('x y')
8975 >>> g = Goal()
8976 >>> g.add(x > 0)
8977 >>> g.add(y > 0)
8978 >>> t(g)
8979 [[x > 0, y > 0]]
8980 >>> g.add(x == y + 1)
8981 >>> t(g)
8982 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8983 """
8984 p = _to_probe(p, ctx)
8985 t = _to_tactic(t, ctx)
8986 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8987
8988
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 8626 of file z3py.py.

8626def With(t, *args, **keys):
8627 """Return a tactic that applies tactic `t` using the given configuration options.
8628
8629 >>> x, y = Ints('x y')
8630 >>> t = With(Tactic('simplify'), som=True)
8631 >>> t((x + 1)*(y + 2) == 0)
8632 [[2*x + y + x*y == -2]]
8633 """
8634 ctx = keys.pop("ctx", None)
8635 t = _to_tactic(t, ctx)
8636 p = args2params(args, keys, t.ctx)
8637 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8638
8639
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 8640 of file z3py.py.

8640def WithParams(t, p):
8641 """Return a tactic that applies tactic `t` using the given configuration options.
8642
8643 >>> x, y = Ints('x y')
8644 >>> p = ParamsRef()
8645 >>> p.set("som", True)
8646 >>> t = WithParams(Tactic('simplify'), p)
8647 >>> t((x + 1)*(y + 2) == 0)
8648 [[2*x + y + x*y == -2]]
8649 """
8650 t = _to_tactic(t, None)
8651 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8652
8653

◆ 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 1870 of file z3py.py.

1870def Xor(a, b, ctx=None):
1871 """Create a Z3 Xor expression.
1872
1873 >>> p, q = Bools('p q')
1874 >>> Xor(p, q)
1875 Xor(p, q)
1876 >>> simplify(Xor(p, q))
1877 Not(p == q)
1878 """
1879 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1880 s = BoolSort(ctx)
1881 a = s.cast(a)
1882 b = s.cast(b)
1883 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1884
1885
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_error_handler()

z3_error_handler ( c,
e )

Definition at line 184 of file z3py.py.

184def z3_error_handler(c, e):
185 # Do nothing error handler, just avoid exit(0)
186 # The wrappers in z3core.py will raise a Z3Exception if an error is detected
187 return
188
189

◆ 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 4483 of file z3py.py.

4483def ZeroExt(n, a):
4484 """Return a bit-vector expression with `n` extra zero-bits.
4485
4486 >>> x = BitVec('x', 16)
4487 >>> n = ZeroExt(8, x)
4488 >>> n.size()
4489 24
4490 >>> n
4491 ZeroExt(8, x)
4492 >>> n.sort()
4493 BitVec(24)
4494 >>> v0 = BitVecVal(2, 2)
4495 >>> v0
4496 2
4497 >>> v0.size()
4498 2
4499 >>> v = simplify(ZeroExt(6, v0))
4500 >>> v
4501 2
4502 >>> v.size()
4503 8
4504 """
4505 if z3_debug():
4506 _z3_assert(_is_int(n), "First argument must be an integer")
4507 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4508 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4509
4510
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

int _dflt_fpsort_ebits = 11
protected

Definition at line 9521 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

Definition at line 9522 of file z3py.py.

◆ _dflt_rounding_mode

_dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN
protected

Floating-Point Arithmetic.

Definition at line 9520 of file z3py.py.

◆ _main_ctx

_main_ctx = None
protected

Definition at line 246 of file z3py.py.

◆ _my_hacky_class

_my_hacky_class = None
protected

Definition at line 11637 of file z3py.py.

◆ _on_clause_eh

_on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 11645 of file z3py.py.

◆ _on_model_eh

_on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 8025 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 8017 of file z3py.py.

◆ _prop_closures

_prop_closures = None
protected

Definition at line 11694 of file z3py.py.

◆ _ROUNDING_MODES

_ROUNDING_MODES
protected
Initial value:
1= frozenset({
2 Z3_OP_FPA_RM_TOWARD_ZERO,
3 Z3_OP_FPA_RM_TOWARD_NEGATIVE,
4 Z3_OP_FPA_RM_TOWARD_POSITIVE,
5 Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN,
6 Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY
7})

Definition at line 9540 of file z3py.py.

◆ _user_prop_created

_user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11785 of file z3py.py.

◆ _user_prop_decide

_user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11789 of file z3py.py.

◆ _user_prop_diseq

_user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11788 of file z3py.py.

◆ _user_prop_eq

_user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11787 of file z3py.py.

◆ _user_prop_final

_user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11786 of file z3py.py.

◆ _user_prop_fixed

_user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11784 of file z3py.py.

◆ _user_prop_fresh

_user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11783 of file z3py.py.

◆ _user_prop_pop

_user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11782 of file z3py.py.

◆ _user_prop_push

_user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11781 of file z3py.py.

◆ sat

Definition at line 7009 of file z3py.py.

◆ unknown

Definition at line 7011 of file z3py.py.

◆ unsat

Definition at line 7010 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 67 of file z3py.py.