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

8511def _and_then(t1, t2, ctx=None):
8512 t1 = _to_tactic(t1, ctx)
8513 t2 = _to_tactic(t2, ctx)
8514 if z3_debug():
8515 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8516 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8517
8518
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 10623 of file z3py.py.

10623def _check_fp_args(a, b):
10624 if z3_debug():
10625 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10626
10627

◆ _coerce_char()

_coerce_char ( ch,
ctx = None )
protected

Definition at line 11066 of file z3py.py.

11066def _coerce_char(ch, ctx=None):
11067 if isinstance(ch, str):
11068 ctx = _get_ctx(ctx)
11069 ch = CharVal(ch, ctx)
11070 if not is_expr(ch):
11071 raise Z3Exception("Character expression expected")
11072 return ch
11073

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

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

◆ _coerce_seq()

_coerce_seq ( s,
ctx = None )
protected

Definition at line 11116 of file z3py.py.

11116def _coerce_seq(s, ctx=None):
11117 if isinstance(s, str):
11118 ctx = _get_ctx(ctx)
11119 s = StringVal(s, ctx)
11120 if not is_expr(s):
11121 raise Z3Exception("Non-expression passed as a sequence")
11122 if not is_seq(s):
11123 raise Z3Exception("Non-sequence passed as a sequence")
11124 return s
11125
11126

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

9568def _dflt_fps(ctx=None):
9569 return get_default_fp_sort(ctx)
9570
9571

◆ _dflt_rm()

_dflt_rm ( ctx = None)
protected

Definition at line 9564 of file z3py.py.

9564def _dflt_rm(ctx=None):
9565 return get_default_rounding_mode(ctx)
9566
9567

◆ _dict2darray()

_dict2darray ( decls,
ctx )
protected

Definition at line 9437 of file z3py.py.

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

◆ _dict2sarray()

_dict2sarray ( sorts,
ctx )
protected

Definition at line 9421 of file z3py.py.

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

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

11127def _get_ctx2(a, b, ctx=None):
11128 if is_expr(a):
11129 return a.ctx
11130 if is_expr(b):
11131 return b.ctx
11132 if ctx is None:
11133 ctx = main_ctx()
11134 return ctx
11135
11136

◆ _global_on_model()

_global_on_model ( ctx)
protected

Definition at line 8015 of file z3py.py.

8015def _global_on_model(ctx):
8016 (fn, mdl) = _on_models[ctx]
8017 fn(mdl)
8018
8019

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

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

◆ _mk_fp_bin_norm()

_mk_fp_bin_norm ( f,
a,
b,
ctx )
protected

Definition at line 10420 of file z3py.py.

10420def _mk_fp_bin_norm(f, a, b, ctx):
10421 ctx = _get_ctx(ctx)
10422 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10423 if z3_debug():
10424 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10425 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10426
10427

◆ _mk_fp_bin_pred()

_mk_fp_bin_pred ( f,
a,
b,
ctx )
protected

Definition at line 10428 of file z3py.py.

10428def _mk_fp_bin_pred(f, a, b, ctx):
10429 ctx = _get_ctx(ctx)
10430 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10431 if z3_debug():
10432 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10433 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10434
10435

◆ _mk_fp_tern()

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

Definition at line 10436 of file z3py.py.

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

◆ _mk_fp_unary()

_mk_fp_unary ( f,
rm,
a,
ctx )
protected

Definition at line 10394 of file z3py.py.

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

◆ _mk_fp_unary_pred()

_mk_fp_unary_pred ( f,
a,
ctx )
protected

Definition at line 10403 of file z3py.py.

10403def _mk_fp_unary_pred(f, a, ctx):
10404 ctx = _get_ctx(ctx)
10405 [a] = _coerce_fp_expr_list([a], ctx)
10406 if z3_debug():
10407 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10408 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10409
10410

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

8519def _or_else(t1, t2, ctx=None):
8520 t1 = _to_tactic(t1, ctx)
8521 t2 = _to_tactic(t2, ctx)
8522 if z3_debug():
8523 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8524 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8525
8526
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 9210 of file z3py.py.

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

◆ _probe_and()

_probe_and ( args,
ctx )
protected

Definition at line 8934 of file z3py.py.

8934def _probe_and(args, ctx):
8935 return _probe_nary(Z3_probe_and, args, ctx)
8936
8937

Referenced by And().

◆ _probe_nary()

_probe_nary ( f,
args,
ctx )
protected

Definition at line 8924 of file z3py.py.

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

◆ _probe_or()

_probe_or ( args,
ctx )
protected

Definition at line 8938 of file z3py.py.

8938def _probe_or(args, ctx):
8939 return _probe_nary(Z3_probe_or, args, ctx)
8940
8941

Referenced by Or().

◆ _prove_html()

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

Definition at line 9401 of file z3py.py.

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

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

9203def _reorder_pb_arg(arg):
9204 a, b = arg
9205 if not _is_int(b) and _is_int(a):
9206 return b, a
9207 return arg
9208
9209

◆ _solve_html()

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

Definition at line 9352 of file z3py.py.

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

◆ _solve_using_html()

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

Definition at line 9376 of file z3py.py.

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

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

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

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

8495def _to_goal(a):
8496 if isinstance(a, BoolRef):
8497 goal = Goal(ctx=a.ctx)
8498 goal.add(a)
8499 return goal
8500 else:
8501 return a
8502
8503

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

8878def _to_probe(p, ctx=None):
8879 if is_probe(p):
8880 return p
8881 else:
8882 return Probe(p, ctx)
8883
8884

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

8504def _to_tactic(t, ctx=None):
8505 if isinstance(t, Tactic):
8506 return t
8507 else:
8508 return Tactic(t, ctx)
8509
8510

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

9162def Abs(arg):
9163 """Create the absolute value of an arithmetic expression"""
9164 return If(arg > 0, arg, -arg)
9165
9166

◆ AllChar()

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

Definition at line 11581 of file z3py.py.

11581def AllChar(regex_sort, ctx=None):
11582 """Create a regular expression that accepts all single character strings
11583 """
11584 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11585
11586# Special Relations
11587
11588
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 8527 of file z3py.py.

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

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

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

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

11099def CharFromBv(bv):
11100 if not is_expr(bv):
11101 raise Z3Exception("Bit-vector expression needed")
11102 return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
11103
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 11112 of file z3py.py.

11112def CharIsDigit(ch, ctx=None):
11113 ch = _coerce_char(ch, ctx)
11114 return ch.is_digit()
11115

◆ CharSort()

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

Definition at line 10995 of file z3py.py.

10995def CharSort(ctx=None):
10996 """Create a character sort
10997 >>> ch = CharSort()
10998 >>> print(ch)
10999 Char
11000 """
11001 ctx = _get_ctx(ctx)
11002 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
11003
11004
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 11104 of file z3py.py.

11104def CharToBv(ch, ctx=None):
11105 ch = _coerce_char(ch, ctx)
11106 return ch.to_bv()
11107

◆ CharToInt()

CharToInt ( ch,
ctx = None )

Definition at line 11108 of file z3py.py.

11108def CharToInt(ch, ctx=None):
11109 ch = _coerce_char(ch, ctx)
11110 return ch.to_int()
11111

◆ CharVal()

CharVal ( ch,
ctx = None )

Definition at line 11091 of file z3py.py.

11091def CharVal(ch, ctx=None):
11092 ctx = _get_ctx(ctx)
11093 if isinstance(ch, str):
11094 ch = ord(ch)
11095 if not isinstance(ch, int):
11096 raise Z3Exception("character value should be an ordinal")
11097 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
11098
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 11523 of file z3py.py.

11523def Complement(re):
11524 """Create the complement regular expression."""
11525 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11526
11527
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 8984 of file z3py.py.

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

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

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

◆ describe_tactics()

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

Definition at line 8699 of file z3py.py.

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

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

11573def Diff(a, b, ctx=None):
11574 """Create the difference regular expression
11575 """
11576 if z3_debug():
11577 _z3_assert(is_expr(a), "expression expected")
11578 _z3_assert(is_expr(b), "expression expected")
11579 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11580
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 11198 of file z3py.py.

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

11692def ensure_prop_closures():
11693 global _prop_closures
11694 if _prop_closures is None:
11695 _prop_closures = PropClosures()
11696
11697

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

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

7873def FiniteDomainSort(name, sz, ctx=None):
7874 """Create a named finite domain sort of a given size sz"""
7875 if not isinstance(name, Symbol):
7876 name = to_symbol(name)
7877 ctx = _get_ctx(ctx)
7878 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7879
7880
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 7943 of file z3py.py.

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

◆ Float128()

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

Definition at line 9670 of file z3py.py.

9670def Float128(ctx=None):
9671 """Floating-point 128-bit (quadruple) sort."""
9672 ctx = _get_ctx(ctx)
9673 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9674
9675
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 9634 of file z3py.py.

9634def Float16(ctx=None):
9635 """Floating-point 16-bit (half) sort."""
9636 ctx = _get_ctx(ctx)
9637 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9638
9639
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 9646 of file z3py.py.

9646def Float32(ctx=None):
9647 """Floating-point 32-bit (single) sort."""
9648 ctx = _get_ctx(ctx)
9649 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9650
9651
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 9658 of file z3py.py.

9658def Float64(ctx=None):
9659 """Floating-point 64-bit (double) sort."""
9660 ctx = _get_ctx(ctx)
9661 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9662
9663
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 9664 of file z3py.py.

9664def FloatDouble(ctx=None):
9665 """Floating-point 64-bit (double) sort."""
9666 ctx = _get_ctx(ctx)
9667 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9668
9669
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 9640 of file z3py.py.

9640def FloatHalf(ctx=None):
9641 """Floating-point 16-bit (half) sort."""
9642 ctx = _get_ctx(ctx)
9643 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9644
9645
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 9676 of file z3py.py.

9676def FloatQuadruple(ctx=None):
9677 """Floating-point 128-bit (quadruple) sort."""
9678 ctx = _get_ctx(ctx)
9679 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9680
9681
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 9652 of file z3py.py.

9652def FloatSingle(ctx=None):
9653 """Floating-point 32-bit (single) sort."""
9654 ctx = _get_ctx(ctx)
9655 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9656
9657
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 10312 of file z3py.py.

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

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

10355def fpAbs(a, ctx=None):
10356 """Create a Z3 floating-point absolute value expression.
10357
10358 >>> s = FPSort(8, 24)
10359 >>> rm = RNE()
10360 >>> x = FPVal(1.0, s)
10361 >>> fpAbs(x)
10362 fpAbs(1)
10363 >>> y = FPVal(-20.0, s)
10364 >>> y
10365 -1.25*(2**4)
10366 >>> fpAbs(y)
10367 fpAbs(-1.25*(2**4))
10368 >>> fpAbs(-1.25*(2**4))
10369 fpAbs(-1.25*(2**4))
10370 >>> fpAbs(x).sort()
10371 FPSort(8, 24)
10372 """
10373 ctx = _get_ctx(ctx)
10374 [a] = _coerce_fp_expr_list([a], ctx)
10375 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10376
10377
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 10446 of file z3py.py.

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

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

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

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

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

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

◆ fpFMA()

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

Definition at line 10552 of file z3py.py.

10552def fpFMA(rm, a, b, c, ctx=None):
10553 """Create a Z3 floating-point fused multiply-add expression.
10554 """
10555 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10556
10557

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

10700def fpFP(sgn, exp, sig, ctx=None):
10701 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10702
10703 >>> s = FPSort(8, 24)
10704 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10705 >>> print(x)
10706 fpFP(1, 127, 4194304)
10707 >>> xv = FPVal(-1.5, s)
10708 >>> print(xv)
10709 -1.5
10710 >>> slvr = Solver()
10711 >>> slvr.add(fpEQ(x, xv))
10712 >>> slvr.check()
10713 sat
10714 >>> xv = FPVal(+1.5, s)
10715 >>> print(xv)
10716 1.5
10717 >>> slvr = Solver()
10718 >>> slvr.add(fpEQ(x, xv))
10719 >>> slvr.check()
10720 unsat
10721 """
10722 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10723 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10724 ctx = _get_ctx(ctx)
10725 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10726 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10727
10728
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 10785 of file z3py.py.

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

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

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

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

◆ fpInfinity()

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

Definition at line 10240 of file z3py.py.

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

10582def fpIsInf(a, ctx=None):
10583 """Create a Z3 floating-point isInfinite expression.
10584
10585 >>> s = FPSort(8, 24)
10586 >>> x = FP('x', s)
10587 >>> fpIsInf(x)
10588 fpIsInf(x)
10589 """
10590 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10591
10592

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

10570def fpIsNaN(a, ctx=None):
10571 """Create a Z3 floating-point isNaN expression.
10572
10573 >>> s = FPSort(8, 24)
10574 >>> x = FP('x', s)
10575 >>> y = FP('y', s)
10576 >>> fpIsNaN(x)
10577 fpIsNaN(x)
10578 """
10579 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10580
10581

◆ fpIsNegative()

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

Definition at line 10611 of file z3py.py.

10611def fpIsNegative(a, ctx=None):
10612 """Create a Z3 floating-point isNegative expression.
10613 """
10614 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10615
10616

◆ fpIsNormal()

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

Definition at line 10599 of file z3py.py.

10599def fpIsNormal(a, ctx=None):
10600 """Create a Z3 floating-point isNormal expression.
10601 """
10602 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10603
10604

◆ fpIsPositive()

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

Definition at line 10617 of file z3py.py.

10617def fpIsPositive(a, ctx=None):
10618 """Create a Z3 floating-point isPositive expression.
10619 """
10620 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10621
10622

◆ fpIsSubnormal()

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

Definition at line 10605 of file z3py.py.

10605def fpIsSubnormal(a, ctx=None):
10606 """Create a Z3 floating-point isSubnormal expression.
10607 """
10608 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10609
10610

◆ fpIsZero()

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

Definition at line 10593 of file z3py.py.

10593def fpIsZero(a, ctx=None):
10594 """Create a Z3 floating-point isZero expression.
10595 """
10596 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10597
10598

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

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

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

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

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

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

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

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

◆ fpMinusInfinity()

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

Definition at line 10234 of file z3py.py.

10234def fpMinusInfinity(s):
10235 """Create a Z3 floating-point -oo term."""
10236 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10237 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10238
10239

◆ fpMinusZero()

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

Definition at line 10253 of file z3py.py.

10253def fpMinusZero(s):
10254 """Create a Z3 floating-point -0.0 term."""
10255 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10256 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10257
10258
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 10478 of file z3py.py.

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

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

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

10378def fpNeg(a, ctx=None):
10379 """Create a Z3 floating-point addition expression.
10380
10381 >>> s = FPSort(8, 24)
10382 >>> rm = RNE()
10383 >>> x = FP('x', s)
10384 >>> fpNeg(x)
10385 -x
10386 >>> fpNeg(x).sort()
10387 FPSort(8, 24)
10388 """
10389 ctx = _get_ctx(ctx)
10390 [a] = _coerce_fp_expr_list([a], ctx)
10391 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10392
10393
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 10688 of file z3py.py.

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

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

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

◆ fpPlusZero()

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

Definition at line 10247 of file z3py.py.

10247def fpPlusZero(s):
10248 """Create a Z3 floating-point +0.0 term."""
10249 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10250 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10251
10252

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

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

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

◆ fpRoundToIntegral()

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

Definition at line 10564 of file z3py.py.

10564def fpRoundToIntegral(rm, a, ctx=None):
10565 """Create a Z3 floating-point roundToIntegral expression.
10566 """
10567 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10568
10569

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

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

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

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

10141def FPSort(ebits, sbits, ctx=None):
10142 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10143
10144 >>> Single = FPSort(8, 24)
10145 >>> Double = FPSort(11, 53)
10146 >>> Single
10147 FPSort(8, 24)
10148 >>> x = Const('x', Single)
10149 >>> eq(x, FP('x', FPSort(8, 24)))
10150 True
10151 """
10152 ctx = _get_ctx(ctx)
10153 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
10154
10155
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 10558 of file z3py.py.

10558def fpSqrt(rm, a, ctx=None):
10559 """Create a Z3 floating-point square root expression.
10560 """
10561 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10562
10563

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ fpZero()

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

Definition at line 10259 of file z3py.py.

10259def fpZero(s, negative):
10260 """Create a Z3 floating-point +0.0 or -0.0 term."""
10261 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10262 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10263 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10264
10265

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

11218def Full(s):
11219 """Create the regular expression that accepts the universal language
11220 >>> e = Full(ReSort(SeqSort(IntSort())))
11221 >>> print(e)
11222 Full(ReSort(Seq(Int)))
11223 >>> e1 = Full(ReSort(StringSort()))
11224 >>> print(e1)
11225 Full(ReSort(String))
11226 """
11227 if isinstance(s, ReSortRef):
11228 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11229 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11230
11231
11232
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 9553 of file z3py.py.

9553def get_default_fp_sort(ctx=None):
9554 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9555
9556

◆ get_default_rounding_mode()

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

Definition at line 9520 of file z3py.py.

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

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

9026def help_simplify():
9027 """Return a string describing all options available for Z3 `simplify` procedure."""
9028 print(Z3_simplify_get_help(main_ctx().ref()))
9029
9030
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 11302 of file z3py.py.

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

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

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

11383def IntToStr(s):
11384 """Convert integer expression to string"""
11385 if not is_expr(s):
11386 s = _py2expr(s)
11387 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11388
11389
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 7904 of file z3py.py.

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

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

7881def is_finite_domain_sort(s):
7882 """Return True if `s` is a Z3 finite-domain sort.
7883
7884 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7885 True
7886 >>> is_finite_domain_sort(IntSort())
7887 False
7888 """
7889 return isinstance(s, FiniteDomainSortRef)
7890
7891

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

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

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

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

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

9686def is_fp_sort(s):
9687 """Return True if `s` is a Z3 floating-point sort.
9688
9689 >>> is_fp_sort(FPSort(8, 24))
9690 True
9691 >>> is_fp_sort(IntSort())
9692 False
9693 """
9694 return isinstance(s, FPSortRef)
9695
9696

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

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

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

9946def is_fprm(a):
9947 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9948
9949 >>> rm = RNE()
9950 >>> is_fprm(rm)
9951 True
9952 >>> rm = 1.0
9953 >>> is_fprm(rm)
9954 False
9955 """
9956 return isinstance(a, FPRMRef)
9957
9958

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

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

◆ is_fprm_value()

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

Definition at line 9959 of file z3py.py.

9959def is_fprm_value(a):
9960 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9961 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9962
9963# FP Numerals
9964
9965

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

8867def is_probe(p):
8868 """Return `True` if `p` is a Z3 probe.
8869
8870 >>> is_probe(Int('x'))
8871 False
8872 >>> is_probe(Probe('memory'))
8873 True
8874 """
8875 return isinstance(p, Probe)
8876
8877

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

11437def is_re(s):
11438 return isinstance(s, ReRef)
11439
11440

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

11137def is_seq(a):
11138 """Return `True` if `a` is a Z3 sequence expression.
11139 >>> print (is_seq(Unit(IntVal(0))))
11140 True
11141 >>> print (is_seq(StringVal("abc")))
11142 True
11143 """
11144 return isinstance(a, SeqRef)
11145
11146

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

11147def is_string(a: Any) -> bool:
11148 """Return `True` if `a` is a Z3 string expression.
11149 >>> print (is_string(StringVal("ab")))
11150 True
11151 """
11152 return isinstance(a, SeqRef) and a.is_string()
11153
11154

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

11155def is_string_value(a: Any) -> bool:
11156 """return 'True' if 'a' is a Z3 string constant expression.
11157 >>> print (is_string_value(StringVal("a")))
11158 True
11159 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11160 False
11161 """
11162 return isinstance(a, SeqRef) and a.is_string_value()
11163

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

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

11331def Length(s):
11332 """Obtain the length of a sequence 's'
11333 >>> l = Length(StringVal("abc"))
11334 >>> simplify(l)
11335 3
11336 """
11337 s = _coerce_seq(s)
11338 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11339
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 11593 of file z3py.py.

11593def LinearOrder(a, index):
11594 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11595
11596
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 11543 of file z3py.py.

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

11633def on_clause_eh(ctx, p, n, dep, clause):
11634 onc = _my_hacky_class
11635 p = _to_expr_ref(to_Ast(p), onc.ctx)
11636 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11637 deps = [dep[i] for i in range(n)]
11638 onc.on_clause(p, deps, clause)
11639

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

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

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

◆ ParAndThen()

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

Definition at line 8616 of file z3py.py.

8616def ParAndThen(t1, t2, ctx=None):
8617 """Alias for ParThen(t1, t2, ctx)."""
8618 return ParThen(t1, t2, ctx)
8619
8620

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

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

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

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

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

11589def PartialOrder(a, index):
11590 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11591
11592
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 9252 of file z3py.py.

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

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

9230def PbLe(args, k):
9231 """Create a Pseudo-Boolean inequality k constraint.
9232
9233 >>> a, b, c = Bools('a b c')
9234 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9235 """
9236 _z3_check_cint_overflow(k, "k")
9237 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9238 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9239
9240
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 11601 of file z3py.py.

11601def PiecewiseLinearOrder(a, index):
11602 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11603
11604
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 11493 of file z3py.py.

11493def Plus(re):
11494 """Create the regular expression accepting one or more repetitions of argument.
11495 >>> re = Plus(Re("a"))
11496 >>> print(simplify(InRe("aa", re)))
11497 True
11498 >>> print(simplify(InRe("ab", re)))
11499 False
11500 >>> print(simplify(InRe("", re)))
11501 False
11502 """
11503 if z3_debug():
11504 _z3_assert(is_expr(re), "expression expected")
11505 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11506
11507
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 11238 of file z3py.py.

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

8896def probe_description(name, ctx=None):
8897 """Return a short description for the probe named `name`.
8898
8899 >>> d = probe_description('memory')
8900 """
8901 ctx = _get_ctx(ctx)
8902 return Z3_probe_get_descr(ctx.ref(), name)
8903
8904
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 8885 of file z3py.py.

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

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

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

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

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

11558def Range(lo, hi, ctx=None):
11559 """Create the range regular expression over two sequences of length 1
11560 >>> range = Range("a","z")
11561 >>> print(simplify(InRe("b", range)))
11562 True
11563 >>> print(simplify(InRe("bb", range)))
11564 False
11565 """
11566 lo = _coerce_seq(lo, ctx)
11567 hi = _coerce_seq(hi, ctx)
11568 if z3_debug():
11569 _z3_assert(is_expr(lo), "expression expected")
11570 _z3_assert(is_expr(hi), "expression expected")
11571 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11572
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 11402 of file z3py.py.

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

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

11287def Replace(s, src, dst):
11288 """Replace the first occurrence of 'src' by 'dst' in 's'
11289 >>> r = Replace("aaa", "a", "b")
11290 >>> simplify(r)
11291 "baa"
11292 """
11293 ctx = _get_ctx2(dst, s)
11294 if ctx is None and is_expr(src):
11295 ctx = src.ctx
11296 src = _coerce_seq(src, ctx)
11297 dst = _coerce_seq(dst, ctx)
11298 s = _coerce_seq(s, ctx)
11299 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11300
11301
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 11421 of file z3py.py.

11421def ReSort(s):
11422 if is_ast(s):
11423 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11424 if s is None or isinstance(s, Context):
11425 ctx = _get_ctx(s)
11426 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11427 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11428
11429
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 9911 of file z3py.py.

9911def RNA(ctx=None):
9912 ctx = _get_ctx(ctx)
9913 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9914
9915
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 9901 of file z3py.py.

9901def RNE(ctx=None):
9902 ctx = _get_ctx(ctx)
9903 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9904
9905
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 9906 of file z3py.py.

9906def RoundNearestTiesToAway(ctx=None):
9907 ctx = _get_ctx(ctx)
9908 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9909
9910

◆ RoundNearestTiesToEven()

RoundNearestTiesToEven ( ctx = None)

Definition at line 9896 of file z3py.py.

9896def RoundNearestTiesToEven(ctx=None):
9897 ctx = _get_ctx(ctx)
9898 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9899
9900

◆ RoundTowardNegative()

RoundTowardNegative ( ctx = None)

Definition at line 9926 of file z3py.py.

9926def RoundTowardNegative(ctx=None):
9927 ctx = _get_ctx(ctx)
9928 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9929
9930
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 9916 of file z3py.py.

9916def RoundTowardPositive(ctx=None):
9917 ctx = _get_ctx(ctx)
9918 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9919
9920
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 9936 of file z3py.py.

9936def RoundTowardZero(ctx=None):
9937 ctx = _get_ctx(ctx)
9938 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9939
9940
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 9931 of file z3py.py.

9931def RTN(ctx=None):
9932 ctx = _get_ctx(ctx)
9933 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9934
9935

◆ RTP()

RTP ( ctx = None)

Definition at line 9921 of file z3py.py.

9921def RTP(ctx=None):
9922 ctx = _get_ctx(ctx)
9923 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9924
9925

◆ RTZ()

RTZ ( ctx = None)

Definition at line 9941 of file z3py.py.

9941def RTZ(ctx=None):
9942 ctx = _get_ctx(ctx)
9943 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9944
9945

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

11354def SeqFoldLeft(f, a, s):
11355 ctx = _get_ctx2(f, s)
11356 s = _coerce_seq(s, ctx)
11357 a = _py2expr(a)
11358 return _to_expr_ref(Z3_mk_seq_foldl(s.ctx_ref(), f.as_ast(), a.as_ast(), s.as_ast()), ctx)
11359
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 11360 of file z3py.py.

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

11340def SeqMap(f, s):
11341 """Map function 'f' over sequence 's'"""
11342 ctx = _get_ctx2(f, s)
11343 s = _coerce_seq(s, ctx)
11344 return _to_expr_ref(Z3_mk_seq_map(s.ctx_ref(), f.as_ast(), s.as_ast()), ctx)
11345
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 11346 of file z3py.py.

11346def SeqMapI(f, i, s):
11347 """Map function 'f' over sequence 's' at index 'i'"""
11348 ctx = _get_ctx2(f, s)
11349 s = _coerce_seq(s, ctx)
11350 if not is_expr(i):
11351 i = _py2expr(i)
11352 return _to_expr_ref(Z3_mk_seq_mapi(s.ctx_ref(), f.as_ast(), i.as_ast(), s.as_ast()), ctx)
11353
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 11005 of file z3py.py.

11005def SeqSort(s):
11006 """Create a sequence sort over elements provided in the argument
11007 >>> s = SeqSort(IntSort())
11008 >>> s == Unit(IntVal(1)).sort()
11009 True
11010 """
11011 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
11012
11013
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 9557 of file z3py.py.

9557def set_default_fp_sort(ebits, sbits, ctx=None):
9558 global _dflt_fpsort_ebits
9559 global _dflt_fpsort_sbits
9560 _dflt_fpsort_ebits = ebits
9561 _dflt_fpsort_sbits = sbits
9562
9563

◆ set_default_rounding_mode()

set_default_rounding_mode ( rm,
ctx = None )

Definition at line 9544 of file z3py.py.

9544def set_default_rounding_mode(rm, ctx=None):
9545 global _dflt_rounding_mode
9546 if is_fprm_value(rm):
9547 _dflt_rounding_mode = rm.kind()
9548 else:
9549 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9550 _dflt_rounding_mode = rm
9551
9552

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

7576def SimpleSolver(ctx=None, logFile=None):
7577 """Return a simple general purpose solver with limited amount of preprocessing.
7578
7579 >>> s = SimpleSolver()
7580 >>> x = Int('x')
7581 >>> s.add(x > 0)
7582 >>> s.check()
7583 sat
7584 """
7585 ctx = _get_ctx(ctx)
7586 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7587
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 9001 of file z3py.py.

9001def simplify(a, *arguments, **keywords):
9002 """Simplify the expression `a` using the given options.
9003
9004 This function has many options. Use `help_simplify` to obtain the complete list.
9005
9006 >>> x = Int('x')
9007 >>> y = Int('y')
9008 >>> simplify(x + 1 + y + x + 1)
9009 2 + 2*x + y
9010 >>> simplify((x + 1)*(y + 1), som=True)
9011 1 + x + y + x*y
9012 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9013 And(Not(x == y), Not(x == 1), Not(y == 1))
9014 >>> simplify(And(x == 0, y == 1), elim_and=True)
9015 Not(Or(Not(x == 0), Not(y == 1)))
9016 """
9017 if z3_debug():
9018 _z3_assert(is_expr(a), "Z3 expression expected")
9019 if len(arguments) > 0 or len(keywords) > 0:
9020 p = args2params(arguments, keywords, a.ctx)
9021 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
9022 else:
9023 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
9024
9025
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 9031 of file z3py.py.

9031def simplify_param_descrs():
9032 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9033 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
9034
9035
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 9263 of file z3py.py.

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

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

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

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

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

11528def Star(re):
11529 """Create the regular expression accepting zero or more repetitions of argument.
11530 >>> re = Star(Re("a"))
11531 >>> print(simplify(InRe("aa", re)))
11532 True
11533 >>> print(simplify(InRe("ab", re)))
11534 False
11535 >>> print(simplify(InRe("", re)))
11536 True
11537 """
11538 if z3_debug():
11539 _z3_assert(is_expr(re), "expression expected")
11540 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11541
11542
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 11396 of file z3py.py.

11396def StrFromCode(c):
11397 """Convert code to a string"""
11398 if not is_expr(c):
11399 c = _py2expr(c)
11400 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11401
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 11171 of file z3py.py.

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

◆ Strings()

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

Definition at line 11180 of file z3py.py.

11180def Strings(names, ctx=None):
11181 """Return a tuple of String constants. """
11182 ctx = _get_ctx(ctx)
11183 if isinstance(names, str):
11184 names = names.split(" ")
11185 return [String(name, ctx) for name in names]
11186
11187

◆ StringSort()

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

Definition at line 10986 of file z3py.py.

10986def StringSort(ctx=None):
10987 """Create a string sort
10988 >>> s = StringSort()
10989 >>> print(s)
10990 String
10991 """
10992 ctx = _get_ctx(ctx)
10993 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10994

◆ StringVal()

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

Definition at line 11164 of file z3py.py.

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

11390def StrToCode(s):
11391 """Convert a unit length string to integer code"""
11392 if not is_expr(s):
11393 s = _py2expr(s)
11394 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11395
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 11367 of file z3py.py.

11367def StrToInt(s):
11368 """Convert string expression to integer
11369 >>> a = StrToInt("1")
11370 >>> simplify(1 == a)
11371 True
11372 >>> b = StrToInt("2")
11373 >>> simplify(1 == b)
11374 False
11375 >>> c = StrToInt(IntToStr(2))
11376 >>> simplify(1 == c)
11377 False
11378 """
11379 s = _coerce_seq(s)
11380 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11381
11382
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 11193 of file z3py.py.

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

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

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

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

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

11188def SubString(s, offset, length):
11189 """Extract substring or subsequence starting at offset"""
11190 return Extract(s, offset, length)
11191
11192

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

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

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

8690def tactic_description(name, ctx=None):
8691 """Return a short description for the tactic named `name`.
8692
8693 >>> d = tactic_description('simplify')
8694 """
8695 ctx = _get_ctx(ctx)
8696 return Z3_tactic_get_descr(ctx.ref(), name)
8697
8698
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 8679 of file z3py.py.

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

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

◆ to_Ast()

to_Ast ( ptr)

Definition at line 11612 of file z3py.py.

11612def to_Ast(ptr,):
11613 ast = Ast(ptr)
11614 super(ctypes.c_void_p, ast).__init__(ptr)
11615 return ast
11616

◆ to_AstVectorObj()

to_AstVectorObj ( ptr)

Definition at line 11622 of file z3py.py.

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

◆ to_ContextObj()

to_ContextObj ( ptr)

Definition at line 11617 of file z3py.py.

11617def to_ContextObj(ptr,):
11618 ctx = ContextObj(ptr)
11619 super(ctypes.c_void_p, ctx).__init__(ptr)
11620 return ctx
11621

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

11605def TransitiveClosure(f):
11606 """Given a binary relation R, such that the two arguments have the same sort
11607 create the transitive closure relation R+.
11608 The transitive closure R+ is a new relation.
11609 """
11610 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11611
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 11597 of file z3py.py.

11597def TreeOrder(a, index):
11598 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11599
11600
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 8670 of file z3py.py.

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

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

11233def Unit(a):
11234 """Create a singleton sequence"""
11235 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11236
11237
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 11733 of file z3py.py.

11733def user_prop_created(ctx, cb, id):
11734 prop = _prop_closures.get(ctx)
11735 old_cb = prop.cb
11736 prop.cb = cb
11737 id = _to_expr_ref(to_Ast(id), prop.ctx())
11738 prop.created(id)
11739 prop.cb = old_cb
11740
11741

◆ user_prop_decide()

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

Definition at line 11767 of file z3py.py.

11767def user_prop_decide(ctx, cb, t_ref, idx, phase):
11768 prop = _prop_closures.get(ctx)
11769 old_cb = prop.cb
11770 prop.cb = cb
11771 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11772 prop.decide(t, idx, phase)
11773 prop.cb = old_cb
11774
11775

◆ user_prop_diseq()

user_prop_diseq ( ctx,
cb,
x,
y )

Definition at line 11758 of file z3py.py.

11758def user_prop_diseq(ctx, cb, x, y):
11759 prop = _prop_closures.get(ctx)
11760 old_cb = prop.cb
11761 prop.cb = cb
11762 x = _to_expr_ref(to_Ast(x), prop.ctx())
11763 y = _to_expr_ref(to_Ast(y), prop.ctx())
11764 prop.diseq(x, y)
11765 prop.cb = old_cb
11766

◆ user_prop_eq()

user_prop_eq ( ctx,
cb,
x,
y )

Definition at line 11749 of file z3py.py.

11749def user_prop_eq(ctx, cb, x, y):
11750 prop = _prop_closures.get(ctx)
11751 old_cb = prop.cb
11752 prop.cb = cb
11753 x = _to_expr_ref(to_Ast(x), prop.ctx())
11754 y = _to_expr_ref(to_Ast(y), prop.ctx())
11755 prop.eq(x, y)
11756 prop.cb = old_cb
11757

◆ user_prop_final()

user_prop_final ( ctx,
cb )

Definition at line 11742 of file z3py.py.

11742def user_prop_final(ctx, cb):
11743 prop = _prop_closures.get(ctx)
11744 old_cb = prop.cb
11745 prop.cb = cb
11746 prop.final()
11747 prop.cb = old_cb
11748

◆ user_prop_fixed()

user_prop_fixed ( ctx,
cb,
id,
value )

Definition at line 11724 of file z3py.py.

11724def user_prop_fixed(ctx, cb, id, value):
11725 prop = _prop_closures.get(ctx)
11726 old_cb = prop.cb
11727 prop.cb = cb
11728 id = _to_expr_ref(to_Ast(id), prop.ctx())
11729 value = _to_expr_ref(to_Ast(value), prop.ctx())
11730 prop.fixed(id, value)
11731 prop.cb = old_cb
11732

◆ user_prop_fresh()

user_prop_fresh ( ctx,
_new_ctx )

Definition at line 11710 of file z3py.py.

11710def user_prop_fresh(ctx, _new_ctx):
11711 _prop_closures.set_threaded()
11712 prop = _prop_closures.get(ctx)
11713 nctx = Context()
11714 Z3_del_context(nctx.ctx)
11715 new_ctx = to_ContextObj(_new_ctx)
11716 nctx.ctx = new_ctx
11717 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11718 nctx.owner = False
11719 new_prop = prop.fresh(nctx)
11720 _prop_closures.set(new_prop.id, new_prop)
11721 return new_prop.id
11722
11723
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 11704 of file z3py.py.

11704def user_prop_pop(ctx, cb, num_scopes):
11705 prop = _prop_closures.get(ctx)
11706 prop.cb = cb
11707 prop.pop(num_scopes)
11708
11709

◆ user_prop_push()

user_prop_push ( ctx,
cb )

Definition at line 11698 of file z3py.py.

11698def user_prop_push(ctx, cb):
11699 prop = _prop_closures.get(ctx)
11700 prop.cb = cb
11701 prop.push()
11702
11703

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

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

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

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

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

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

Definition at line 9517 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 9515 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 11632 of file z3py.py.

◆ _on_clause_eh

_on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 11640 of file z3py.py.

◆ _on_model_eh

_on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 8020 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 8012 of file z3py.py.

◆ _prop_closures

_prop_closures = None
protected

Definition at line 11689 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 9535 of file z3py.py.

◆ _user_prop_created

_user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11780 of file z3py.py.

◆ _user_prop_decide

_user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11784 of file z3py.py.

◆ _user_prop_diseq

_user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11783 of file z3py.py.

◆ _user_prop_eq

_user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11782 of file z3py.py.

◆ _user_prop_final

_user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11781 of file z3py.py.

◆ _user_prop_fixed

_user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11779 of file z3py.py.

◆ _user_prop_fresh

_user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11778 of file z3py.py.

◆ _user_prop_pop

_user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11777 of file z3py.py.

◆ _user_prop_push

_user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11776 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.