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)
 
 main_ctx ()
 
 _get_ctx (ctx)
 
 get_ctx (ctx)
 
 set_param (*args, **kws)
 
 reset_params ()
 
 set_option (*args, **kws)
 
 get_param (name)
 
 is_ast (a)
 
 eq (a, b)
 
 _ast_kind (ctx, 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.
 
 is_sort (s)
 
 _to_sort_ref (s, ctx)
 
 _sort (ctx, a)
 
 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")
 
 Var (idx, s)
 
 RealVar (idx, ctx=None)
 
 RealVarVector (n, ctx=None)
 
 is_bool (a)
 
 is_true (a)
 
 is_false (a)
 
 is_and (a)
 
 is_or (a)
 
 is_implies (a)
 
 is_not (a)
 
 is_eq (a)
 
 is_distinct (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)
 
 is_arith_sort (s)
 
 is_arith (a)
 
 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)
 
 is_add (a)
 
 is_mul (a)
 
 is_sub (a)
 
 is_div (a)
 
 is_idiv (a)
 
 is_mod (a)
 
 is_le (a)
 
 is_lt (a)
 
 is_ge (a)
 
 is_gt (a)
 
 is_is_int (a)
 
 is_to_real (a)
 
 is_to_int (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)
 
 is_array (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)
 
 is_string (a)
 
 is_string_value (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 8507 of file z3py.py.

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

4679def _array_select(ar, arg):
4680 if isinstance(arg, tuple):
4681 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4682 _args, sz = _to_ast_array(args)
4683 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4684 arg = ar.sort().domain().cast(arg)
4685 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4686
4687
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()

_ast_kind ( ctx,
a )
protected

Definition at line 495 of file z3py.py.

495def _ast_kind(ctx, a):
496 if is_ast(a):
497 a = a.as_ast()
498 return Z3_get_ast_kind(ctx.ref(), a)
499
500
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 4240 of file z3py.py.

4240def _check_bv_args(a, b):
4241 if z3_debug():
4242 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4243
4244

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

10619def _check_fp_args(a, b):
10620 if z3_debug():
10621 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10622
10623

◆ _coerce_char()

_coerce_char ( ch,
ctx = None )
protected

Definition at line 11062 of file z3py.py.

11062def _coerce_char(ch, ctx=None):
11063 if isinstance(ch, str):
11064 ctx = _get_ctx(ctx)
11065 ch = CharVal(ch, ctx)
11066 if not is_expr(ch):
11067 raise Z3Exception("Character expression expected")
11068 return ch
11069

◆ _coerce_expr_list()

_coerce_expr_list ( alist,
ctx = None )
protected

Definition at line 1263 of file z3py.py.

1263def _coerce_expr_list(alist, ctx=None):
1264 has_expr = False
1265 for a in alist:
1266 if is_expr(a):
1267 has_expr = True
1268 break
1269 if not has_expr:
1270 alist = [_py2expr(a, ctx) for a in alist]
1271 s = _reduce(_coerce_expr_merge, alist, None)
1272 return [s.cast(a) for a in alist]
1273
1274

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

◆ _coerce_expr_merge()

_coerce_expr_merge ( s,
a )
protected

Definition at line 1216 of file z3py.py.

1216def _coerce_expr_merge(s, a):
1217 if is_expr(a):
1218 s1 = a.sort()
1219 if s is None:
1220 return s1
1221 if s1.eq(s):
1222 return s
1223 elif s.subsort(s1):
1224 return s1
1225 elif s1.subsort(s):
1226 return s
1227 else:
1228 if z3_debug():
1229 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1230 _z3_assert(False, "sort mismatch")
1231 else:
1232 return s
1233
1234

Referenced by _coerce_exprs().

◆ _coerce_exprs()

_coerce_exprs ( a,
b,
ctx = None )
protected

Definition at line 1235 of file z3py.py.

1235def _coerce_exprs(a, b, ctx=None):
1236 if not is_expr(a) and not is_expr(b):
1237 a = _py2expr(a, ctx)
1238 b = _py2expr(b, ctx)
1239 if isinstance(a, str) and isinstance(b, SeqRef):
1240 a = StringVal(a, b.ctx)
1241 if isinstance(b, str) and isinstance(a, SeqRef):
1242 b = StringVal(b, a.ctx)
1243 if isinstance(a, float) and isinstance(b, ArithRef):
1244 a = RealVal(a, b.ctx)
1245 if isinstance(b, float) and isinstance(a, ArithRef):
1246 b = RealVal(b, a.ctx)
1247
1248 s = None
1249 s = _coerce_expr_merge(s, a)
1250 s = _coerce_expr_merge(s, b)
1251 a = s.cast(a)
1252 b = s.cast(b)
1253 return (a, b)
1254
1255

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

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

◆ _coerce_seq()

_coerce_seq ( s,
ctx = None )
protected

Definition at line 11112 of file z3py.py.

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

Referenced by Concat().

◆ _ctx_from_ast_arg_list()

_ctx_from_ast_arg_list ( args,
default_ctx = None )
protected

Definition at line 501 of file z3py.py.

501def _ctx_from_ast_arg_list(args, default_ctx=None):
502 ctx = None
503 for a in args:
504 if is_ast(a) or is_probe(a):
505 if ctx is None:
506 ctx = a.ctx
507 else:
508 if z3_debug():
509 _z3_assert(ctx == a.ctx, "Context mismatch")
510 if ctx is None:
511 ctx = default_ctx
512 return ctx
513
514

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

515def _ctx_from_ast_args(*args):
516 return _ctx_from_ast_arg_list(args)
517
518

◆ _dflt_fps()

_dflt_fps ( ctx = None)
protected

Definition at line 9564 of file z3py.py.

9564def _dflt_fps(ctx=None):
9565 return get_default_fp_sort(ctx)
9566
9567

◆ _dflt_rm()

_dflt_rm ( ctx = None)
protected

Definition at line 9560 of file z3py.py.

9560def _dflt_rm(ctx=None):
9561 return get_default_rounding_mode(ctx)
9562
9563

◆ _dict2darray()

_dict2darray ( decls,
ctx )
protected

Definition at line 9433 of file z3py.py.

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

◆ _dict2sarray()

_dict2sarray ( sorts,
ctx )
protected

Definition at line 9417 of file z3py.py.

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

◆ _get_args()

_get_args ( args)
protected

Definition at line 144 of file z3py.py.

144def _get_args(args):
145 try:
146 if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)):
147 return args[0]
148 elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)):
149 return [arg for arg in args[0]]
150 else:
151 return args
152 except TypeError: # len is not necessarily defined when args is not a sequence (use reflection?)
153 return args
154
155# Use this when function takes multiple arguments
156
157

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

158def _get_args_ast_list(args):
159 try:
160 if isinstance(args, (set, AstVector, tuple)):
161 return [arg for arg in args]
162 else:
163 return args
164 except Exception:
165 return args
166
167

◆ _get_ctx()

_get_ctx ( ctx)
protected

◆ _get_ctx2()

_get_ctx2 ( a,
b,
ctx = None )
protected

Definition at line 11123 of file z3py.py.

11123def _get_ctx2(a, b, ctx=None):
11124 if is_expr(a):
11125 return a.ctx
11126 if is_expr(b):
11127 return b.ctx
11128 if ctx is None:
11129 ctx = main_ctx()
11130 return ctx
11131
11132

◆ _global_on_model()

_global_on_model ( ctx)
protected

Definition at line 8011 of file z3py.py.

8011def _global_on_model(ctx):
8012 (fn, mdl) = _on_models[ctx]
8013 fn(mdl)
8014
8015

◆ _has_probe()

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

Definition at line 1903 of file z3py.py.

1903def _has_probe(args):
1904 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1905 for arg in args:
1906 if is_probe(arg):
1907 return True
1908 return False
1909
1910

Referenced by And(), and Or().

◆ _is_algebraic()

_is_algebraic ( ctx,
a )
protected

Definition at line 2800 of file z3py.py.

2800def _is_algebraic(ctx, a):
2801 return Z3_is_algebraic_number(ctx.ref(), a)
2802
2803
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 68 of file z3py.py.

68 def _is_int(v):
69 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 2796 of file z3py.py.

2796def _is_numeral(ctx, a):
2797 return Z3_is_numeral_ast(ctx.ref(), a)
2798
2799
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 1461 of file z3py.py.

1461def _mk_bin(f, a, b):
1462 args = (Ast * 2)()
1463 if z3_debug():
1464 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1465 args[0] = a.as_ast()
1466 args[1] = b.as_ast()
1467 return f(a.ctx.ref(), 2, args)
1468
1469

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

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

◆ _mk_fp_bin_norm()

_mk_fp_bin_norm ( f,
a,
b,
ctx )
protected

Definition at line 10416 of file z3py.py.

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

◆ _mk_fp_bin_pred()

_mk_fp_bin_pred ( f,
a,
b,
ctx )
protected

Definition at line 10424 of file z3py.py.

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

◆ _mk_fp_tern()

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

Definition at line 10432 of file z3py.py.

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

◆ _mk_fp_unary()

_mk_fp_unary ( f,
rm,
a,
ctx )
protected

Definition at line 10390 of file z3py.py.

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

◆ _mk_fp_unary_pred()

_mk_fp_unary_pred ( f,
a,
ctx )
protected

Definition at line 10399 of file z3py.py.

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

◆ _mk_quantifier()

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

Definition at line 2259 of file z3py.py.

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

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

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

◆ _probe_and()

_probe_and ( args,
ctx )
protected

Definition at line 8930 of file z3py.py.

8930def _probe_and(args, ctx):
8931 return _probe_nary(Z3_probe_and, args, ctx)
8932
8933

Referenced by And().

◆ _probe_nary()

_probe_nary ( f,
args,
ctx )
protected

Definition at line 8920 of file z3py.py.

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

◆ _probe_or()

_probe_or ( args,
ctx )
protected

Definition at line 8934 of file z3py.py.

8934def _probe_or(args, ctx):
8935 return _probe_nary(Z3_probe_or, args, ctx)
8936
8937

Referenced by Or().

◆ _prove_html()

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

Definition at line 9397 of file z3py.py.

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

◆ _py2expr()

_py2expr ( a,
ctx = None )
protected

Definition at line 3201 of file z3py.py.

3201def _py2expr(a, ctx=None):
3202 if isinstance(a, bool):
3203 return BoolVal(a, ctx)
3204 if _is_int(a):
3205 return IntVal(a, ctx)
3206 if isinstance(a, float):
3207 return RealVal(a, ctx)
3208 if isinstance(a, str):
3209 return StringVal(a, ctx)
3210 if is_expr(a):
3211 return a
3212 if z3_debug():
3213 _z3_assert(False, "Python bool, int, long or float expected")
3214
3215

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

1256def _reduce(func, sequence, initial):
1257 result = initial
1258 for element in sequence:
1259 result = func(result, element)
1260 return result
1261
1262

Referenced by _coerce_expr_list().

◆ _reorder_pb_arg()

_reorder_pb_arg ( arg)
protected

Definition at line 9199 of file z3py.py.

9199def _reorder_pb_arg(arg):
9200 a, b = arg
9201 if not _is_int(b) and _is_int(a):
9202 return b, a
9203 return arg
9204
9205

◆ _solve_html()

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

Definition at line 9348 of file z3py.py.

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

◆ _solve_using_html()

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

Definition at line 9372 of file z3py.py.

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

◆ _sort()

_sort ( ctx,
a )
protected

Definition at line 695 of file z3py.py.

695def _sort(ctx, a):
696 return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
697
698
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 559 of file z3py.py.

559def _sort_kind(ctx, s):
560 return Z3_get_sort_kind(ctx.ref(), s)
561
562
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 132 of file z3py.py.

132def _symbol2py(ctx, s):
133 """Convert a Z3 symbol back into a Python object. """
134 if Z3_get_symbol_kind(ctx.ref(), s) == Z3_INT_SYMBOL:
135 return "k!%s" % Z3_get_symbol_int(ctx.ref(), s)
136 else:
137 return Z3_get_symbol_string(ctx.ref(), s)
138
139# Hack for having nary functions that can receive one argument that is the
140# list of arguments.
141# Use this when function takes a single list of arguments
142
143
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 527 of file z3py.py.

527def _to_ast_array(args):
528 sz = len(args)
529 _args = (Ast * sz)()
530 for i in range(sz):
531 _args[i] = args[i].as_ast()
532 return _args, sz
533
534

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

543def _to_ast_ref(a, ctx):
544 k = _ast_kind(ctx, a)
545 if k == Z3_SORT_AST:
546 return _to_sort_ref(a, ctx)
547 elif k == Z3_FUNC_DECL_AST:
548 return _to_func_decl_ref(a, ctx)
549 else:
550 return _to_expr_ref(a, ctx)
551
552

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

◆ _to_expr_ref()

_to_expr_ref ( a,
ctx )
protected

Definition at line 1166 of file z3py.py.

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

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

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

◆ _to_func_decl_array()

_to_func_decl_array ( args)
protected

Definition at line 519 of file z3py.py.

519def _to_func_decl_array(args):
520 sz = len(args)
521 _args = (FuncDecl * sz)()
522 for i in range(sz):
523 _args[i] = args[i].as_func_decl()
524 return _args, sz
525
526

◆ _to_func_decl_ref()

_to_func_decl_ref ( a,
ctx )
protected

Definition at line 931 of file z3py.py.

931def _to_func_decl_ref(a, ctx):
932 return FuncDeclRef(a, ctx)
933
934

Referenced by _to_ast_ref().

◆ _to_goal()

_to_goal ( a)
protected

Definition at line 8491 of file z3py.py.

8491def _to_goal(a):
8492 if isinstance(a, BoolRef):
8493 goal = Goal(ctx=a.ctx)
8494 goal.add(a)
8495 return goal
8496 else:
8497 return a
8498
8499

◆ _to_int_str()

_to_int_str ( val)
protected

Definition at line 3250 of file z3py.py.

3250def _to_int_str(val):
3251 if isinstance(val, float):
3252 return str(int(val))
3253 elif isinstance(val, bool):
3254 if val:
3255 return "1"
3256 else:
3257 return "0"
3258 else:
3259 return str(val)
3260
3261

Referenced by BitVecVal(), and IntVal().

◆ _to_param_value()

_to_param_value ( val)
protected

Definition at line 168 of file z3py.py.

168def _to_param_value(val):
169 if isinstance(val, bool):
170 return "true" if val else "false"
171 return str(val)
172
173

Referenced by Context.__init__(), and set_param().

◆ _to_pattern()

_to_pattern ( arg)
protected

Definition at line 2037 of file z3py.py.

2037def _to_pattern(arg):
2038 if is_pattern(arg):
2039 return arg
2040 else:
2041 return MultiPattern(arg)
2042

Referenced by _mk_quantifier().

◆ _to_probe()

_to_probe ( p,
ctx = None )
protected

Definition at line 8874 of file z3py.py.

8874def _to_probe(p, ctx=None):
8875 if is_probe(p):
8876 return p
8877 else:
8878 return Probe(p, ctx)
8879
8880

◆ _to_ref_array()

_to_ref_array ( ref,
args )
protected

Definition at line 535 of file z3py.py.

535def _to_ref_array(ref, args):
536 sz = len(args)
537 _args = (ref * sz)()
538 for i in range(sz):
539 _args[i] = args[i].as_ast()
540 return _args, sz
541
542

◆ _to_sort_ref()

_to_sort_ref ( s,
ctx )
protected

Definition at line 664 of file z3py.py.

664def _to_sort_ref(s, ctx):
665 if z3_debug():
666 _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
667 k = _sort_kind(ctx, s)
668 if k == Z3_BOOL_SORT:
669 return BoolSortRef(s, ctx)
670 elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
671 return ArithSortRef(s, ctx)
672 elif k == Z3_BV_SORT:
673 return BitVecSortRef(s, ctx)
674 elif k == Z3_ARRAY_SORT:
675 return ArraySortRef(s, ctx)
676 elif k == Z3_DATATYPE_SORT:
677 return DatatypeSortRef(s, ctx)
678 elif k == Z3_FINITE_DOMAIN_SORT:
679 return FiniteDomainSortRef(s, ctx)
680 elif k == Z3_FLOATING_POINT_SORT:
681 return FPSortRef(s, ctx)
682 elif k == Z3_ROUNDING_MODE_SORT:
683 return FPRMSortRef(s, ctx)
684 elif k == Z3_RE_SORT:
685 return ReSortRef(s, ctx)
686 elif k == Z3_SEQ_SORT:
687 return SeqSortRef(s, ctx)
688 elif k == Z3_CHAR_SORT:
689 return CharSortRef(s, ctx)
690 elif k == Z3_TYPE_VAR:
691 return TypeVarRef(s, ctx)
692 return SortRef(s, ctx)
693
694

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

8500def _to_tactic(t, ctx=None):
8501 if isinstance(t, Tactic):
8502 return t
8503 else:
8504 return Tactic(t, ctx)
8505
8506

◆ _valid_accessor()

_valid_accessor ( acc)
protected

Datatypes.

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

Definition at line 5118 of file z3py.py.

5118def _valid_accessor(acc):
5119 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5120 if not isinstance(acc, tuple):
5121 return False
5122 if len(acc) != 2:
5123 return False
5124 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5125
5126

Referenced by Datatype.declare_core().

◆ _z3_assert()

◆ _z3_check_cint_overflow()

_z3_check_cint_overflow ( n,
name )
protected

Definition at line 110 of file z3py.py.

110def _z3_check_cint_overflow(n, name):
111 _z3_assert(ctypes.c_int(n).value == n, name + " is too large")
112
113

◆ Abs()

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

Definition at line 9158 of file z3py.py.

9158def Abs(arg):
9159 """Create the absolute value of an arithmetic expression"""
9160 return If(arg > 0, arg, -arg)
9161
9162

◆ AllChar()

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

Definition at line 11577 of file z3py.py.

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

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

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

◆ append_log()

append_log ( s)
Append user-defined string to interaction log. 

Definition at line 119 of file z3py.py.

119def append_log(s):
120 """Append user-defined string to interaction log. """
122
123
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 5547 of file z3py.py.

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

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

4814def Array(name, *sorts):
4815 """Return an array constant named `name` with the given domain and range sorts.
4816
4817 >>> a = Array('a', IntSort(), IntSort())
4818 >>> a.sort()
4819 Array(Int, Int)
4820 >>> a[0]
4821 a[0]
4822 """
4823 s = ArraySort(sorts)
4824 ctx = s.ctx
4825 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4826
4827
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 4781 of file z3py.py.

4781def ArraySort(*sig):
4782 """Return the Z3 array sort with the given domain and range sorts.
4783
4784 >>> A = ArraySort(IntSort(), BoolSort())
4785 >>> A
4786 Array(Int, Bool)
4787 >>> A.domain()
4788 Int
4789 >>> A.range()
4790 Bool
4791 >>> AA = ArraySort(IntSort(), A)
4792 >>> AA
4793 Array(Int, Array(Int, Bool))
4794 """
4795 sig = _get_args(sig)
4796 if z3_debug():
4797 _z3_assert(len(sig) > 1, "At least two arguments expected")
4798 arity = len(sig) - 1
4799 r = sig[arity]
4800 d = sig[0]
4801 if z3_debug():
4802 for s in sig:
4803 _z3_assert(is_sort(s), "Z3 sort expected")
4804 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4805 ctx = d.ctx
4806 if len(sig) == 2:
4807 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4808 dom = (Sort * arity)()
4809 for i in range(arity):
4810 dom[i] = sig[i].ast
4811 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4812
4813
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 9181 of file z3py.py.

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

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

4118def BitVec(name, bv, ctx=None):
4119 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4120 If `ctx=None`, then the global context is used.
4121
4122 >>> x = BitVec('x', 16)
4123 >>> is_bv(x)
4124 True
4125 >>> x.size()
4126 16
4127 >>> x.sort()
4128 BitVec(16)
4129 >>> word = BitVecSort(16)
4130 >>> x2 = BitVec('x', word)
4131 >>> eq(x, x2)
4132 True
4133 """
4134 if isinstance(bv, BitVecSortRef):
4135 ctx = bv.ctx
4136 else:
4137 ctx = _get_ctx(ctx)
4138 bv = BitVecSort(bv, ctx)
4139 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4140
4141

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

4142def BitVecs(names, bv, ctx=None):
4143 """Return a tuple of bit-vector constants of size bv.
4144
4145 >>> x, y, z = BitVecs('x y z', 16)
4146 >>> x.size()
4147 16
4148 >>> x.sort()
4149 BitVec(16)
4150 >>> Sum(x, y, z)
4151 0 + x + y + z
4152 >>> Product(x, y, z)
4153 1*x*y*z
4154 >>> simplify(Product(x, y, z))
4155 x*y*z
4156 """
4157 ctx = _get_ctx(ctx)
4158 if isinstance(names, str):
4159 names = names.split(" ")
4160 return [BitVec(name, bv, ctx) for name in names]
4161
4162

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

4086def BitVecSort(sz, ctx=None):
4087 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4088
4089 >>> Byte = BitVecSort(8)
4090 >>> Word = BitVecSort(16)
4091 >>> Byte
4092 BitVec(8)
4093 >>> x = Const('x', Byte)
4094 >>> eq(x, BitVec('x', 8))
4095 True
4096 """
4097 ctx = _get_ctx(ctx)
4098 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4099
4100
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 4101 of file z3py.py.

4101def BitVecVal(val, bv, ctx=None):
4102 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4103
4104 >>> v = BitVecVal(10, 32)
4105 >>> v
4106 10
4107 >>> print("0x%.8x" % v.as_long())
4108 0x0000000a
4109 """
4110 if is_bv_sort(bv):
4111 ctx = bv.ctx
4112 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4113 else:
4114 ctx = _get_ctx(ctx)
4115 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4116
4117
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 1790 of file z3py.py.

1790def Bool(name, ctx=None):
1791 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1792
1793 >>> p = Bool('p')
1794 >>> q = Bool('q')
1795 >>> And(p, q)
1796 And(p, q)
1797 """
1798 ctx = _get_ctx(ctx)
1799 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1800
1801

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

1802def Bools(names, ctx=None):
1803 """Return a tuple of Boolean constants.
1804
1805 `names` is a single string containing all names separated by blank spaces.
1806 If `ctx=None`, then the global context is used.
1807
1808 >>> p, q, r = Bools('p q r')
1809 >>> And(p, Or(q, r))
1810 And(p, Or(q, r))
1811 """
1812 ctx = _get_ctx(ctx)
1813 if isinstance(names, str):
1814 names = names.split(" ")
1815 return [Bool(name, ctx) for name in names]
1816
1817

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

1753def BoolSort(ctx=None):
1754 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1755
1756 >>> BoolSort()
1757 Bool
1758 >>> p = Const('p', BoolSort())
1759 >>> is_bool(p)
1760 True
1761 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1762 >>> r(0, 1)
1763 r(0, 1)
1764 >>> is_bool(r(0, 1))
1765 True
1766 """
1767 ctx = _get_ctx(ctx)
1768 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1769
1770
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 1771 of file z3py.py.

1771def BoolVal(val, ctx=None):
1772 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1773
1774 >>> BoolVal(True)
1775 True
1776 >>> is_true(BoolVal(True))
1777 True
1778 >>> is_true(True)
1779 False
1780 >>> is_false(BoolVal(False))
1781 True
1782 """
1783 ctx = _get_ctx(ctx)
1784 if val:
1785 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1786 else:
1787 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1788
1789
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 1818 of file z3py.py.

1818def BoolVector(prefix, sz, ctx=None):
1819 """Return a list of Boolean constants of size `sz`.
1820
1821 The constants are named using the given prefix.
1822 If `ctx=None`, then the global context is used.
1823
1824 >>> P = BoolVector('p', 3)
1825 >>> P
1826 [p__0, p__1, p__2]
1827 >>> And(P)
1828 And(p__0, p__1, p__2)
1829 """
1830 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1831
1832

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

4054def BV2Int(a, is_signed=False):
4055 """Return the Z3 expression BV2Int(a).
4056
4057 >>> b = BitVec('b', 3)
4058 >>> BV2Int(b).sort()
4059 Int
4060 >>> x = Int('x')
4061 >>> x > BV2Int(b)
4062 x > BV2Int(b)
4063 >>> x > BV2Int(b, is_signed=False)
4064 x > BV2Int(b)
4065 >>> x > BV2Int(b, is_signed=True)
4066 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4067 >>> solve(x > BV2Int(b), b == 1, x < 3)
4068 [x = 2, b = 1]
4069 """
4070 if z3_debug():
4071 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4072 ctx = a.ctx
4073 # investigate problem with bv2int
4074 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
4075
4076
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 4540 of file z3py.py.

4540def BVAddNoOverflow(a, b, signed):
4541 """A predicate the determines that bit-vector addition does not overflow"""
4542 _check_bv_args(a, b)
4543 a, b = _coerce_exprs(a, b)
4544 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4545
4546
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 4547 of file z3py.py.

4547def BVAddNoUnderflow(a, b):
4548 """A predicate the determines that signed bit-vector addition does not underflow"""
4549 _check_bv_args(a, b)
4550 a, b = _coerce_exprs(a, b)
4551 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4552
4553
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 4582 of file z3py.py.

4582def BVMulNoOverflow(a, b, signed):
4583 """A predicate the determines that bit-vector multiplication does not overflow"""
4584 _check_bv_args(a, b)
4585 a, b = _coerce_exprs(a, b)
4586 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4587
4588
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 4589 of file z3py.py.

4589def BVMulNoUnderflow(a, b):
4590 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4591 _check_bv_args(a, b)
4592 a, b = _coerce_exprs(a, b)
4593 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4594
4595
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 4526 of file z3py.py.

4526def BVRedAnd(a):
4527 """Return the reduction-and expression of `a`."""
4528 if z3_debug():
4529 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4530 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4531
4532
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 4533 of file z3py.py.

4533def BVRedOr(a):
4534 """Return the reduction-or expression of `a`."""
4535 if z3_debug():
4536 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4537 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4538
4539
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 4568 of file z3py.py.

4568def BVSDivNoOverflow(a, b):
4569 """A predicate the determines that bit-vector signed division does not overflow"""
4570 _check_bv_args(a, b)
4571 a, b = _coerce_exprs(a, b)
4572 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4573
4574
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 4575 of file z3py.py.

4575def BVSNegNoOverflow(a):
4576 """A predicate the determines that bit-vector unary negation does not overflow"""
4577 if z3_debug():
4578 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4579 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4580
4581
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 4554 of file z3py.py.

4554def BVSubNoOverflow(a, b):
4555 """A predicate the determines that bit-vector subtraction does not overflow"""
4556 _check_bv_args(a, b)
4557 a, b = _coerce_exprs(a, b)
4558 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4559
4560
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 4561 of file z3py.py.

4561def BVSubNoUnderflow(a, b, signed):
4562 """A predicate the determines that bit-vector subtraction does not underflow"""
4563 _check_bv_args(a, b)
4564 a, b = _coerce_exprs(a, b)
4565 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4566
4567
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 3500 of file z3py.py.

3500def Cbrt(a, ctx=None):
3501 """ Return a Z3 expression which represents the cubic root of a.
3502
3503 >>> x = Real('x')
3504 >>> Cbrt(x)
3505 x**(1/3)
3506 """
3507 if not is_expr(a):
3508 ctx = _get_ctx(ctx)
3509 a = RealVal(a, ctx)
3510 return a ** "1/3"
3511

◆ CharFromBv()

CharFromBv ( bv)

Definition at line 11095 of file z3py.py.

11095def CharFromBv(bv):
11096 if not is_expr(bv):
11097 raise Z3Exception("Bit-vector expression needed")
11098 return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
11099
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 11108 of file z3py.py.

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

◆ CharSort()

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

Definition at line 10991 of file z3py.py.

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

11100def CharToBv(ch, ctx=None):
11101 ch = _coerce_char(ch, ctx)
11102 return ch.to_bv()
11103

◆ CharToInt()

CharToInt ( ch,
ctx = None )

Definition at line 11104 of file z3py.py.

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

◆ CharVal()

CharVal ( ch,
ctx = None )

Definition at line 11087 of file z3py.py.

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

11519def Complement(re):
11520 """Create the complement regular expression."""
11521 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11522
11523
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 4163 of file z3py.py.

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

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

1470def Const(name, sort):
1471 """Create a constant of the given sort.
1472
1473 >>> Const('x', IntSort())
1474 x
1475 """
1476 if z3_debug():
1477 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1478 ctx = sort.ctx
1479 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1480
1481

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

1482def Consts(names, sort):
1483 """Create several constants of the given sort.
1484
1485 `names` is a string containing the names of all constants to be created.
1486 Blank spaces separate the names of different constants.
1487
1488 >>> x, y, z = Consts('x y z', IntSort())
1489 >>> x + y + z
1490 x + y + z
1491 """
1492 if isinstance(names, str):
1493 names = names.split(" ")
1494 return [Const(name, sort) for name in names]
1495
1496

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

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

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

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

5439def DatatypeSort(name, ctx = None):
5440 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5441 ctx = _get_ctx(ctx)
5442 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5443
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()

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

699def DeclareSort(name, ctx=None):
700 """Create a new uninterpreted sort named `name`.
701
702 If `ctx=None`, then the new sort is declared in the global Z3Py context.
703
704 >>> A = DeclareSort('A')
705 >>> a = Const('a', A)
706 >>> b = Const('b', A)
707 >>> a.sort() == A
708 True
709 >>> b.sort() == A
710 True
711 >>> a == b
712 a == b
713 """
714 ctx = _get_ctx(ctx)
715 return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
716
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 727 of file z3py.py.

727def DeclareTypeVar(name, ctx=None):
728 """Create a new type variable named `name`.
729
730 If `ctx=None`, then the new sort is declared in the global Z3Py context.
731
732 """
733 ctx = _get_ctx(ctx)
734 return TypeVarRef(Z3_mk_type_variable(ctx.ref(), to_symbol(name, ctx)), ctx)
735
736
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 4860 of file z3py.py.

4860def Default(a):
4861 """ Return a default value for array expression.
4862 >>> b = K(IntSort(), 1)
4863 >>> prove(Default(b) == 1)
4864 proved
4865 """
4866 if z3_debug():
4867 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4868 return a.default()
4869
4870

◆ describe_probes()

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

Definition at line 8901 of file z3py.py.

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

◆ describe_tactics()

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

Definition at line 8695 of file z3py.py.

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

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

1152def deserialize(st):
1153 """inverse function to the serialize method on ExprRef.
1154 It is made available to make it easier for users to serialize expressions back and forth between
1155 strings. Solvers can be serialized using the 'sexpr()' method.
1156 """
1157 s = Solver()
1158 s.from_string(st)
1159 if len(s.assertions()) != 1:
1160 raise Z3Exception("single assertion expected")
1161 fml = s.assertions()[0]
1162 if fml.num_args() != 1:
1163 raise Z3Exception("dummy function 'F' expected")
1164 return fml.arg(0)
1165

◆ Diff()

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

Definition at line 11569 of file z3py.py.

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

79def disable_trace(msg):
81
82
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 5456 of file z3py.py.

5456def DisjointSum(name, sorts, ctx=None):
5457 """Create a named tagged union sort base on a set of underlying sorts
5458 Example:
5459 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5460 """
5461 sum = Datatype(name, ctx)
5462 for i in range(len(sorts)):
5463 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5464 sum = sum.create()
5465 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5466
5467

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

1437def Distinct(*args):
1438 """Create a Z3 distinct expression.
1439
1440 >>> x = Int('x')
1441 >>> y = Int('y')
1442 >>> Distinct(x, y)
1443 x != y
1444 >>> z = Int('z')
1445 >>> Distinct(x, y, z)
1446 Distinct(x, y, z)
1447 >>> simplify(Distinct(x, y, z))
1448 Distinct(x, y, z)
1449 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1450 And(Not(x == y), Not(x == z), Not(y == z))
1451 """
1452 args = _get_args(args)
1453 ctx = _ctx_from_ast_arg_list(args)
1454 if z3_debug():
1455 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1456 args = _coerce_expr_list(args, ctx)
1457 _args, sz = _to_ast_array(args)
1458 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1459
1460
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 11194 of file z3py.py.

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

5003def EmptySet(s):
5004 """Create the empty set
5005 >>> EmptySet(IntSort())
5006 K(Int, False)
5007 """
5008 ctx = s.ctx
5009 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
5010
5011
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 75 of file z3py.py.

75def enable_trace(msg):
77
78
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 11688 of file z3py.py.

11688def ensure_prop_closures():
11689 global _prop_closures
11690 if _prop_closures is None:
11691 _prop_closures = PropClosures()
11692
11693

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

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

eq ( a,
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 476 of file z3py.py.

476def eq(a, b):
477 """Return `True` if `a` and `b` are structurally identical AST nodes.
478
479 >>> x = Int('x')
480 >>> y = Int('y')
481 >>> eq(x, y)
482 False
483 >>> eq(x + 1, x + 1)
484 True
485 >>> eq(x + 1, 1 + x)
486 False
487 >>> eq(simplify(x + 1), simplify(1 + x))
488 True
489 """
490 if z3_debug():
491 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
492 return a.eq(b)
493
494

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

2312def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2313 """Create a Z3 exists formula.
2314
2315 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2316
2317
2318 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2319 >>> x = Int('x')
2320 >>> y = Int('y')
2321 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2322 >>> q
2323 Exists([x, y], f(x, y) >= x)
2324 >>> is_quantifier(q)
2325 True
2326 >>> r = Tactic('nnf')(q).as_expr()
2327 >>> is_quantifier(r)
2328 False
2329 """
2330 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2331
2332

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

4949def Ext(a, b):
4950 """Return extensionality index for one-dimensional arrays.
4951 >> a, b = Consts('a b', SetSort(IntSort()))
4952 >> Ext(a, b)
4953 Ext(a, b)
4954 """
4955 ctx = a.ctx
4956 if z3_debug():
4957 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4958 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4959
4960
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 4209 of file z3py.py.

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

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

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

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

◆ Float128()

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

Definition at line 9666 of file z3py.py.

9666def Float128(ctx=None):
9667 """Floating-point 128-bit (quadruple) sort."""
9668 ctx = _get_ctx(ctx)
9669 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9670
9671
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 9630 of file z3py.py.

9630def Float16(ctx=None):
9631 """Floating-point 16-bit (half) sort."""
9632 ctx = _get_ctx(ctx)
9633 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9634
9635
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 9642 of file z3py.py.

9642def Float32(ctx=None):
9643 """Floating-point 32-bit (single) sort."""
9644 ctx = _get_ctx(ctx)
9645 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9646
9647
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 9654 of file z3py.py.

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

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

9636def FloatHalf(ctx=None):
9637 """Floating-point 16-bit (half) sort."""
9638 ctx = _get_ctx(ctx)
9639 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9640
9641
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 9672 of file z3py.py.

9672def FloatQuadruple(ctx=None):
9673 """Floating-point 128-bit (quadruple) sort."""
9674 ctx = _get_ctx(ctx)
9675 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9676
9677
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 9648 of file z3py.py.

9648def FloatSingle(ctx=None):
9649 """Floating-point 32-bit (single) sort."""
9650 ctx = _get_ctx(ctx)
9651 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9652
9653
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 2294 of file z3py.py.

2294def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2295 """Create a Z3 forall formula.
2296
2297 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2298
2299 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2300 >>> x = Int('x')
2301 >>> y = Int('y')
2302 >>> ForAll([x, y], f(x, y) >= x)
2303 ForAll([x, y], f(x, y) >= x)
2304 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2305 ForAll([x, y], f(x, y) >= x)
2306 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2307 ForAll([x, y], f(x, y) >= x)
2308 """
2309 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2310
2311

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

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

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

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

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

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

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

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

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

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

◆ fpFMA()

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

Definition at line 10548 of file z3py.py.

10548def fpFMA(rm, a, b, c, ctx=None):
10549 """Create a Z3 floating-point fused multiply-add expression.
10550 """
10551 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10552
10553

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

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

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

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

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

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

◆ fpInfinity()

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

Definition at line 10236 of file z3py.py.

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

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

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

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

◆ fpIsNegative()

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

Definition at line 10607 of file z3py.py.

10607def fpIsNegative(a, ctx=None):
10608 """Create a Z3 floating-point isNegative expression.
10609 """
10610 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10611
10612

◆ fpIsNormal()

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

Definition at line 10595 of file z3py.py.

10595def fpIsNormal(a, ctx=None):
10596 """Create a Z3 floating-point isNormal expression.
10597 """
10598 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10599
10600

◆ fpIsPositive()

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

Definition at line 10613 of file z3py.py.

10613def fpIsPositive(a, ctx=None):
10614 """Create a Z3 floating-point isPositive expression.
10615 """
10616 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10617
10618

◆ fpIsSubnormal()

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

Definition at line 10601 of file z3py.py.

10601def fpIsSubnormal(a, ctx=None):
10602 """Create a Z3 floating-point isSubnormal expression.
10603 """
10604 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10605
10606

◆ fpIsZero()

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

Definition at line 10589 of file z3py.py.

10589def fpIsZero(a, ctx=None):
10590 """Create a Z3 floating-point isZero expression.
10591 """
10592 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10593
10594

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

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

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

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

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

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

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

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

◆ fpMinusInfinity()

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

Definition at line 10230 of file z3py.py.

10230def fpMinusInfinity(s):
10231 """Create a Z3 floating-point -oo term."""
10232 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10233 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10234
10235

◆ fpMinusZero()

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

Definition at line 10249 of file z3py.py.

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

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

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

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

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

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

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

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

◆ fpPlusZero()

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

Definition at line 10243 of file z3py.py.

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

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

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

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

◆ fpRoundToIntegral()

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

Definition at line 10560 of file z3py.py.

10560def fpRoundToIntegral(rm, a, ctx=None):
10561 """Create a Z3 floating-point roundToIntegral expression.
10562 """
10563 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10564
10565

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

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

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

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

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

10554def fpSqrt(rm, a, ctx=None):
10555 """Create a Z3 floating-point square root expression.
10556 """
10557 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10558
10559

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ fpZero()

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

Definition at line 10255 of file z3py.py.

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

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

1833def FreshBool(prefix="b", ctx=None):
1834 """Return a fresh Boolean constant in the given context using the given prefix.
1835
1836 If `ctx=None`, then the global context is used.
1837
1838 >>> b1 = FreshBool()
1839 >>> b2 = FreshBool()
1840 >>> eq(b1, b2)
1841 False
1842 """
1843 ctx = _get_ctx(ctx)
1844 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1845
1846
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 1497 of file z3py.py.

1497def FreshConst(sort, prefix="c"):
1498 """Create a fresh constant of a specified sort"""
1499 ctx = _get_ctx(sort.ctx)
1500 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1501
1502

◆ FreshFunction()

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

Definition at line 912 of file z3py.py.

912def FreshFunction(*sig):
913 """Create a new fresh Z3 uninterpreted function with the given sorts.
914 """
915 sig = _get_args(sig)
916 if z3_debug():
917 _z3_assert(len(sig) > 0, "At least two arguments expected")
918 arity = len(sig) - 1
919 rng = sig[arity]
920 if z3_debug():
921 _z3_assert(is_sort(rng), "Z3 sort expected")
922 dom = (z3.Sort * arity)()
923 for i in range(arity):
924 if z3_debug():
925 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
926 dom[i] = sig[i].ast
927 ctx = rng.ctx
928 return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), "f", arity, dom, rng.ast), ctx)
929
930
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 3361 of file z3py.py.

3361def FreshInt(prefix="x", ctx=None):
3362 """Return a fresh integer constant in the given context using the given prefix.
3363
3364 >>> x = FreshInt()
3365 >>> y = FreshInt()
3366 >>> eq(x, y)
3367 False
3368 >>> x.sort()
3369 Int
3370 """
3371 ctx = _get_ctx(ctx)
3372 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3373
3374

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

3418def FreshReal(prefix="b", ctx=None):
3419 """Return a fresh real constant in the given context using the given prefix.
3420
3421 >>> x = FreshReal()
3422 >>> y = FreshReal()
3423 >>> eq(x, y)
3424 False
3425 >>> x.sort()
3426 Real
3427 """
3428 ctx = _get_ctx(ctx)
3429 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3430
3431

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

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

5012def FullSet(s):
5013 """Create the full set
5014 >>> FullSet(IntSort())
5015 K(Int, True)
5016 """
5017 ctx = s.ctx
5018 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
5019
5020
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 889 of file z3py.py.

889def Function(name, *sig):
890 """Create a new Z3 uninterpreted function with the given sorts.
891
892 >>> f = Function('f', IntSort(), IntSort())
893 >>> f(f(0))
894 f(f(0))
895 """
896 sig = _get_args(sig)
897 if z3_debug():
898 _z3_assert(len(sig) > 0, "At least two arguments expected")
899 arity = len(sig) - 1
900 rng = sig[arity]
901 if z3_debug():
902 _z3_assert(is_sort(rng), "Z3 sort expected")
903 dom = (Sort * arity)()
904 for i in range(arity):
905 if z3_debug():
906 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
907 dom[i] = sig[i].ast
908 ctx = rng.ctx
909 return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
910
911
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 6807 of file z3py.py.

6807def get_as_array_func(n):
6808 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6809 if z3_debug():
6810 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6811 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6812
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()

get_ctx ( ctx)

Definition at line 267 of file z3py.py.

267def get_ctx(ctx):
268 return _get_ctx(ctx)
269
270

◆ get_default_fp_sort()

get_default_fp_sort ( ctx = None)

Definition at line 9549 of file z3py.py.

9549def get_default_fp_sort(ctx=None):
9550 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9551
9552

◆ get_default_rounding_mode()

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

Definition at line 9516 of file z3py.py.

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

◆ get_full_version()

get_full_version ( )

Definition at line 101 of file z3py.py.

101def get_full_version():
102 return Z3_get_full_version()
103
104
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 4757 of file z3py.py.

4757def get_map_func(a):
4758 """Return the function declaration associated with a Z3 map array expression.
4759
4760 >>> f = Function('f', IntSort(), IntSort())
4761 >>> b = Array('b', IntSort(), IntSort())
4762 >>> a = Map(f, b)
4763 >>> eq(f, get_map_func(a))
4764 True
4765 >>> get_map_func(a)
4766 f
4767 >>> get_map_func(a)(0)
4768 f(0)
4769 """
4770 if z3_debug():
4771 _z3_assert(is_map(a), "Z3 array map expression expected.")
4772 return FuncDeclRef(
4774 a.ctx_ref(),
4775 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4776 ),
4777 ctx=a.ctx,
4778 )
4779
4780
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 307 of file z3py.py.

307def get_param(name):
308 """Return the value of a Z3 global (or module) parameter
309
310 >>> get_param('nlsat.reorder')
311 'true'
312 """
313 ptr = (ctypes.c_char_p * 1)()
314 if Z3_global_param_get(str(name), ptr):
315 r = z3core._to_pystr(ptr[0])
316 return r
317 raise Z3Exception("failed to retrieve value for '%s'" % name)
318
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 1368 of file z3py.py.

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

92def get_version():
93 major = ctypes.c_uint(0)
94 minor = ctypes.c_uint(0)
95 build = ctypes.c_uint(0)
96 rev = ctypes.c_uint(0)
97 Z3_get_version(major, minor, build, rev)
98 return (major.value, minor.value, build.value, rev.value)
99
100
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 83 of file z3py.py.

83def get_version_string():
84 major = ctypes.c_uint(0)
85 minor = ctypes.c_uint(0)
86 build = ctypes.c_uint(0)
87 rev = ctypes.c_uint(0)
88 Z3_get_version(major, minor, build, rev)
89 return "%s.%s.%s" % (major.value, minor.value, build.value)
90
91

◆ help_simplify()

help_simplify ( )
Return a string describing all options available for Z3 `simplify` procedure.

Definition at line 9022 of file z3py.py.

9022def help_simplify():
9023 """Return a string describing all options available for Z3 `simplify` procedure."""
9024 print(Z3_simplify_get_help(main_ctx().ref()))
9025
9026
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 1414 of file z3py.py.

1414def If(a, b, c, ctx=None):
1415 """Create a Z3 if-then-else expression.
1416
1417 >>> x = Int('x')
1418 >>> y = Int('y')
1419 >>> max = If(x > y, x, y)
1420 >>> max
1421 If(x > y, x, y)
1422 >>> simplify(max)
1423 If(x <= y, y, x)
1424 """
1425 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1426 return Cond(a, b, c, ctx)
1427 else:
1428 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1429 s = BoolSort(ctx)
1430 a = s.cast(a)
1431 b, c = _coerce_exprs(b, c, ctx)
1432 if z3_debug():
1433 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1434 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1435
1436
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 1847 of file z3py.py.

1847def Implies(a, b, ctx=None):
1848 """Create a Z3 implies expression.
1849
1850 >>> p, q = Bools('p q')
1851 >>> Implies(p, q)
1852 Implies(p, q)
1853 """
1854 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1855 s = BoolSort(ctx)
1856 a = s.cast(a)
1857 b = s.cast(b)
1858 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1859
1860
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 11298 of file z3py.py.

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

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

3322def Int(name, ctx=None):
3323 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3324
3325 >>> x = Int('x')
3326 >>> is_int(x)
3327 True
3328 >>> is_int(x + 1)
3329 True
3330 """
3331 ctx = _get_ctx(ctx)
3332 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3333
3334

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

4077def Int2BV(a, num_bits):
4078 """Return the z3 expression Int2BV(a, num_bits).
4079 It is a bit-vector of width num_bits and represents the
4080 modulo of a by 2^num_bits
4081 """
4082 ctx = a.ctx
4083 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4084
4085
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 11471 of file z3py.py.

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

3335def Ints(names, ctx=None):
3336 """Return a tuple of Integer constants.
3337
3338 >>> x, y, z = Ints('x y z')
3339 >>> Sum(x, y, z)
3340 x + y + z
3341 """
3342 ctx = _get_ctx(ctx)
3343 if isinstance(names, str):
3344 names = names.split(" ")
3345 return [Int(name, ctx) for name in names]
3346
3347

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

3216def IntSort(ctx=None):
3217 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3218
3219 >>> IntSort()
3220 Int
3221 >>> x = Const('x', IntSort())
3222 >>> is_int(x)
3223 True
3224 >>> x.sort() == IntSort()
3225 True
3226 >>> x.sort() == BoolSort()
3227 False
3228 """
3229 ctx = _get_ctx(ctx)
3230 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3231
3232
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 11379 of file z3py.py.

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

3262def IntVal(val, ctx=None):
3263 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3264
3265 >>> IntVal(1)
3266 1
3267 >>> IntVal("100")
3268 100
3269 """
3270 ctx = _get_ctx(ctx)
3271 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3272
3273

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

3348def IntVector(prefix, sz, ctx=None):
3349 """Return a list of integer constants of size `sz`.
3350
3351 >>> X = IntVector('x', 3)
3352 >>> X
3353 [x__0, x__1, x__2]
3354 >>> Sum(X)
3355 x__0 + x__1 + x__2
3356 """
3357 ctx = _get_ctx(ctx)
3358 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3359
3360

◆ is_add()

is_add ( 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 2864 of file z3py.py.

2864def is_add(a):
2865 """Return `True` if `a` is an expression of the form b + c.
2866
2867 >>> x, y = Ints('x y')
2868 >>> is_add(x + y)
2869 True
2870 >>> is_add(x - y)
2871 False
2872 """
2873 return is_app_of(a, Z3_OP_ADD)
2874
2875

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

2850def is_algebraic_value(a):
2851 """Return `True` if `a` is an algebraic value of sort Real.
2852
2853 >>> is_algebraic_value(RealVal("3/5"))
2854 False
2855 >>> n = simplify(Sqrt(2))
2856 >>> n
2857 1.4142135623?
2858 >>> is_algebraic_value(n)
2859 True
2860 """
2861 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2862
2863

◆ is_and()

is_and ( 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 1683 of file z3py.py.

1683def is_and(a):
1684 """Return `True` if `a` is a Z3 and expression.
1685
1686 >>> p, q = Bools('p q')
1687 >>> is_and(And(p, q))
1688 True
1689 >>> is_and(Or(p, q))
1690 False
1691 """
1692 return is_app_of(a, Z3_OP_AND)
1693
1694

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

1298def is_app(a):
1299 """Return `True` if `a` is a Z3 function application.
1300
1301 Note that, constants are function applications with 0 arguments.
1302
1303 >>> a = Int('a')
1304 >>> is_app(a)
1305 True
1306 >>> is_app(a + 1)
1307 True
1308 >>> is_app(IntSort())
1309 False
1310 >>> is_app(1)
1311 False
1312 >>> is_app(IntVal(1))
1313 True
1314 >>> x = Int('x')
1315 >>> is_app(ForAll(x, x >= 0))
1316 False
1317 """
1318 if not isinstance(a, ExprRef):
1319 return False
1320 k = _ast_kind(a.ctx, a)
1321 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1322
1323

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

1401def is_app_of(a, k):
1402 """Return `True` if `a` is an application of the given kind `k`.
1403
1404 >>> x = Int('x')
1405 >>> n = x + 1
1406 >>> is_app_of(n, Z3_OP_ADD)
1407 True
1408 >>> is_app_of(n, Z3_OP_MUL)
1409 False
1410 """
1411 return is_app(a) and a.kind() == k
1412
1413

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

2737def is_arith(a):
2738 """Return `True` if `a` is an arithmetical expression.
2739
2740 >>> x = Int('x')
2741 >>> is_arith(x)
2742 True
2743 >>> is_arith(x + 1)
2744 True
2745 >>> is_arith(1)
2746 False
2747 >>> is_arith(IntVal(1))
2748 True
2749 >>> y = Real('y')
2750 >>> is_arith(y)
2751 True
2752 >>> is_arith(y + 1)
2753 True
2754 """
2755 return isinstance(a, ArithRef)
2756
2757

Referenced by is_algebraic_value(), is_int(), is_int_value(), is_rational_value(), and is_real().

◆ is_arith_sort()

is_arith_sort ( 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 2436 of file z3py.py.

2436def is_arith_sort(s):
2437 """Return `True` if s is an arithmetical sort (type).
2438
2439 >>> is_arith_sort(IntSort())
2440 True
2441 >>> is_arith_sort(RealSort())
2442 True
2443 >>> is_arith_sort(BoolSort())
2444 False
2445 >>> n = Int('x') + 1
2446 >>> is_arith_sort(n.sort())
2447 True
2448 """
2449 return isinstance(s, ArithSortRef)
2450
2451

Referenced by ArithSortRef.subsort().

◆ is_array()

is_array ( 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 4692 of file z3py.py.

4692def is_array(a):
4693 """Return `True` if `a` is a Z3 array expression.
4694
4695 >>> a = Array('a', IntSort(), IntSort())
4696 >>> is_array(a)
4697 True
4698 >>> is_array(Store(a, 0, 1))
4699 True
4700 >>> is_array(a[0])
4701 False
4702 """
4703 return isinstance(a, ArrayRef)
4704
4705

Referenced by Ext(), and Map().

◆ is_array_sort()

is_array_sort ( a)

Definition at line 4688 of file z3py.py.

4688def is_array_sort(a):
4689 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4690
4691

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

6802def is_as_array(n):
6803 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6804 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6805
6806
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()

is_ast ( 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 455 of file z3py.py.

455def is_ast(a):
456 """Return `True` if `a` is an AST node.
457
458 >>> is_ast(10)
459 False
460 >>> is_ast(IntVal(10))
461 True
462 >>> is_ast(Int('x'))
463 True
464 >>> is_ast(BoolSort())
465 True
466 >>> is_ast(Function('f', IntSort(), IntSort()))
467 True
468 >>> is_ast("x")
469 False
470 >>> is_ast(Solver())
471 False
472 """
473 return isinstance(a, AstRef)
474
475

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

◆ is_bool()

is_bool ( 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 1633 of file z3py.py.

1633def is_bool(a):
1634 """Return `True` if `a` is a Z3 Boolean expression.
1635
1636 >>> p = Bool('p')
1637 >>> is_bool(p)
1638 True
1639 >>> q = Bool('q')
1640 >>> is_bool(And(p, q))
1641 True
1642 >>> x = Real('x')
1643 >>> is_bool(x)
1644 False
1645 >>> is_bool(x == 0)
1646 True
1647 """
1648 return isinstance(a, BoolRef)
1649
1650

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

4025def is_bv(a):
4026 """Return `True` if `a` is a Z3 bit-vector expression.
4027
4028 >>> b = BitVec('b', 32)
4029 >>> is_bv(b)
4030 True
4031 >>> is_bv(b + 10)
4032 True
4033 >>> is_bv(Int('x'))
4034 False
4035 """
4036 return isinstance(a, BitVecRef)
4037
4038

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

3552def is_bv_sort(s):
3553 """Return True if `s` is a Z3 bit-vector sort.
3554
3555 >>> is_bv_sort(BitVecSort(32))
3556 True
3557 >>> is_bv_sort(IntSort())
3558 False
3559 """
3560 return isinstance(s, BitVecSortRef)
3561
3562

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

4039def is_bv_value(a):
4040 """Return `True` if `a` is a Z3 bit-vector numeral value.
4041
4042 >>> b = BitVec('b', 32)
4043 >>> is_bv_value(b)
4044 False
4045 >>> b = BitVecVal(10, 32)
4046 >>> b
4047 10
4048 >>> is_bv_value(b)
4049 True
4050 """
4051 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4052
4053

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

1324def is_const(a):
1325 """Return `True` if `a` is Z3 constant/variable expression.
1326
1327 >>> a = Int('a')
1328 >>> is_const(a)
1329 True
1330 >>> is_const(a + 1)
1331 False
1332 >>> is_const(1)
1333 False
1334 >>> is_const(IntVal(1))
1335 True
1336 >>> x = Int('x')
1337 >>> is_const(ForAll(x, x >= 0))
1338 False
1339 """
1340 return is_app(a) and a.num_args() == 0
1341
1342

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

4706def is_const_array(a):
4707 """Return `True` if `a` is a Z3 constant array.
4708
4709 >>> a = K(IntSort(), 10)
4710 >>> is_const_array(a)
4711 True
4712 >>> a = Array('a', IntSort(), IntSort())
4713 >>> is_const_array(a)
4714 False
4715 """
4716 return is_app_of(a, Z3_OP_CONST_ARRAY)
4717
4718

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

4748def is_default(a):
4749 """Return `True` if `a` is a Z3 default array expression.
4750 >>> d = Default(K(IntSort(), 10))
4751 >>> is_default(d)
4752 True
4753 """
4754 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4755
4756

◆ is_distinct()

is_distinct ( 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 1741 of file z3py.py.

1741def is_distinct(a):
1742 """Return `True` if `a` is a Z3 distinct expression.
1743
1744 >>> x, y, z = Ints('x y z')
1745 >>> is_distinct(x == y)
1746 False
1747 >>> is_distinct(Distinct(x, y, z))
1748 True
1749 """
1750 return is_app_of(a, Z3_OP_DISTINCT)
1751
1752

◆ is_div()

is_div ( 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 2900 of file z3py.py.

2900def is_div(a):
2901 """Return `True` if `a` is an expression of the form b / c.
2902
2903 >>> x, y = Reals('x y')
2904 >>> is_div(x / y)
2905 True
2906 >>> is_div(x + y)
2907 False
2908 >>> x, y = Ints('x y')
2909 >>> is_div(x / y)
2910 False
2911 >>> is_idiv(x / y)
2912 True
2913 """
2914 return is_app_of(a, Z3_OP_DIV)
2915
2916

◆ is_eq()

is_eq ( a)
Return `True` if `a` is a Z3 equality expression.

>>> x, y = Ints('x y')
>>> is_eq(x == y)
True

Definition at line 1731 of file z3py.py.

1731def is_eq(a):
1732 """Return `True` if `a` is a Z3 equality expression.
1733
1734 >>> x, y = Ints('x y')
1735 >>> is_eq(x == y)
1736 True
1737 """
1738 return is_app_of(a, Z3_OP_EQ)
1739
1740

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

1275def is_expr(a):
1276 """Return `True` if `a` is a Z3 expression.
1277
1278 >>> a = Int('a')
1279 >>> is_expr(a)
1280 True
1281 >>> is_expr(a + 1)
1282 True
1283 >>> is_expr(IntSort())
1284 False
1285 >>> is_expr(1)
1286 False
1287 >>> is_expr(IntVal(1))
1288 True
1289 >>> x = Int('x')
1290 >>> is_expr(ForAll(x, x >= 0))
1291 True
1292 >>> is_expr(FPVal(1.0))
1293 True
1294 """
1295 return isinstance(a, ExprRef)
1296
1297

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

is_false ( 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 1669 of file z3py.py.

1669def is_false(a):
1670 """Return `True` if `a` is the Z3 false expression.
1671
1672 >>> p = Bool('p')
1673 >>> is_false(p)
1674 False
1675 >>> is_false(False)
1676 False
1677 >>> is_false(BoolVal(False))
1678 True
1679 """
1680 return is_app_of(a, Z3_OP_FALSE)
1681
1682

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

◆ is_fprm_value()

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

Definition at line 9955 of file z3py.py.

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

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

876def is_func_decl(a):
877 """Return `True` if `a` is a Z3 function declaration.
878
879 >>> f = Function('f', IntSort(), IntSort())
880 >>> is_func_decl(f)
881 True
882 >>> x = Real('x')
883 >>> is_func_decl(x)
884 False
885 """
886 return isinstance(a, FuncDeclRef)
887
888

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

◆ is_ge()

is_ge ( 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 2965 of file z3py.py.

2965def is_ge(a):
2966 """Return `True` if `a` is an expression of the form b >= c.
2967
2968 >>> x, y = Ints('x y')
2969 >>> is_ge(x >= y)
2970 True
2971 >>> is_ge(x == y)
2972 False
2973 """
2974 return is_app_of(a, Z3_OP_GE)
2975
2976

◆ is_gt()

is_gt ( 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 2977 of file z3py.py.

2977def is_gt(a):
2978 """Return `True` if `a` is an expression of the form b > c.
2979
2980 >>> x, y = Ints('x y')
2981 >>> is_gt(x > y)
2982 True
2983 >>> is_gt(x == y)
2984 False
2985 """
2986 return is_app_of(a, Z3_OP_GT)
2987
2988

◆ is_idiv()

is_idiv ( 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 2917 of file z3py.py.

2917def is_idiv(a):
2918 """Return `True` if `a` is an expression of the form b div c.
2919
2920 >>> x, y = Ints('x y')
2921 >>> is_idiv(x / y)
2922 True
2923 >>> is_idiv(x + y)
2924 False
2925 """
2926 return is_app_of(a, Z3_OP_IDIV)
2927
2928

◆ is_implies()

is_implies ( 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 1707 of file z3py.py.

1707def is_implies(a):
1708 """Return `True` if `a` is a Z3 implication expression.
1709
1710 >>> p, q = Bools('p q')
1711 >>> is_implies(Implies(p, q))
1712 True
1713 >>> is_implies(And(p, q))
1714 False
1715 """
1716 return is_app_of(a, Z3_OP_IMPLIES)
1717
1718

◆ is_int()

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

2758def is_int(a):
2759 """Return `True` if `a` is an integer expression.
2760
2761 >>> x = Int('x')
2762 >>> is_int(x + 1)
2763 True
2764 >>> is_int(1)
2765 False
2766 >>> is_int(IntVal(1))
2767 True
2768 >>> y = Real('y')
2769 >>> is_int(y)
2770 False
2771 >>> is_int(y + 1)
2772 False
2773 """
2774 return is_arith(a) and a.is_int()
2775
2776

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

2804def is_int_value(a):
2805 """Return `True` if `a` is an integer value of sort Int.
2806
2807 >>> is_int_value(IntVal(1))
2808 True
2809 >>> is_int_value(1)
2810 False
2811 >>> is_int_value(Int('x'))
2812 False
2813 >>> n = Int('x') + 1
2814 >>> n
2815 x + 1
2816 >>> n.arg(1)
2817 1
2818 >>> is_int_value(n.arg(1))
2819 True
2820 >>> is_int_value(RealVal("1/3"))
2821 False
2822 >>> is_int_value(RealVal(1))
2823 False
2824 """
2825 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2826
2827

◆ is_is_int()

is_is_int ( 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 2989 of file z3py.py.

2989def is_is_int(a):
2990 """Return `True` if `a` is an expression of the form IsInt(b).
2991
2992 >>> x = Real('x')
2993 >>> is_is_int(IsInt(x))
2994 True
2995 >>> is_is_int(x)
2996 False
2997 """
2998 return is_app_of(a, Z3_OP_IS_INT)
2999
3000

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

4719def is_K(a):
4720 """Return `True` if `a` is a Z3 constant array.
4721
4722 >>> a = K(IntSort(), 10)
4723 >>> is_K(a)
4724 True
4725 >>> a = Array('a', IntSort(), IntSort())
4726 >>> is_K(a)
4727 False
4728 """
4729 return is_app_of(a, Z3_OP_CONST_ARRAY)
4730
4731

◆ is_le()

is_le ( 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 2941 of file z3py.py.

2941def is_le(a):
2942 """Return `True` if `a` is an expression of the form b <= c.
2943
2944 >>> x, y = Ints('x y')
2945 >>> is_le(x <= y)
2946 True
2947 >>> is_le(x < y)
2948 False
2949 """
2950 return is_app_of(a, Z3_OP_LE)
2951
2952

◆ is_lt()

is_lt ( 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 2953 of file z3py.py.

2953def is_lt(a):
2954 """Return `True` if `a` is an expression of the form b < c.
2955
2956 >>> x, y = Ints('x y')
2957 >>> is_lt(x < y)
2958 True
2959 >>> is_lt(x == y)
2960 False
2961 """
2962 return is_app_of(a, Z3_OP_LT)
2963
2964

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

4732def is_map(a):
4733 """Return `True` if `a` is a Z3 map array expression.
4734
4735 >>> f = Function('f', IntSort(), IntSort())
4736 >>> b = Array('b', IntSort(), IntSort())
4737 >>> a = Map(f, b)
4738 >>> a
4739 Map(f, b)
4740 >>> is_map(a)
4741 True
4742 >>> is_map(b)
4743 False
4744 """
4745 return is_app_of(a, Z3_OP_ARRAY_MAP)
4746
4747

Referenced by get_map_func().

◆ is_mod()

is_mod ( 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 2929 of file z3py.py.

2929def is_mod(a):
2930 """Return `True` if `a` is an expression of the form b % c.
2931
2932 >>> x, y = Ints('x y')
2933 >>> is_mod(x % y)
2934 True
2935 >>> is_mod(x + y)
2936 False
2937 """
2938 return is_app_of(a, Z3_OP_MOD)
2939
2940

◆ is_mul()

is_mul ( 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 2876 of file z3py.py.

2876def is_mul(a):
2877 """Return `True` if `a` is an expression of the form b * c.
2878
2879 >>> x, y = Ints('x y')
2880 >>> is_mul(x * y)
2881 True
2882 >>> is_mul(x - y)
2883 False
2884 """
2885 return is_app_of(a, Z3_OP_MUL)
2886
2887

◆ is_not()

is_not ( 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 1719 of file z3py.py.

1719def is_not(a):
1720 """Return `True` if `a` is a Z3 not expression.
1721
1722 >>> p = Bool('p')
1723 >>> is_not(p)
1724 False
1725 >>> is_not(Not(p))
1726 True
1727 """
1728 return is_app_of(a, Z3_OP_NOT)
1729
1730

Referenced by mk_not().

◆ is_or()

is_or ( 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 1695 of file z3py.py.

1695def is_or(a):
1696 """Return `True` if `a` is a Z3 or expression.
1697
1698 >>> p, q = Bools('p q')
1699 >>> is_or(Or(p, q))
1700 True
1701 >>> is_or(And(p, q))
1702 False
1703 """
1704 return is_app_of(a, Z3_OP_OR)
1705
1706

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

1995def is_pattern(a):
1996 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1997
1998 >>> f = Function('f', IntSort(), IntSort())
1999 >>> x = Int('x')
2000 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2001 >>> q
2002 ForAll(x, f(x) == 0)
2003 >>> q.num_patterns()
2004 1
2005 >>> is_pattern(q.pattern(0))
2006 True
2007 >>> q.pattern(0)
2008 f(Var(0))
2009 """
2010 return isinstance(a, PatternRef)
2011
2012

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

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

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

2245def is_quantifier(a):
2246 """Return `True` if `a` is a Z3 quantifier.
2247
2248 >>> f = Function('f', IntSort(), IntSort())
2249 >>> x = Int('x')
2250 >>> q = ForAll(x, f(x) == 0)
2251 >>> is_quantifier(q)
2252 True
2253 >>> is_quantifier(f(x))
2254 False
2255 """
2256 return isinstance(a, QuantifierRef)
2257
2258

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

2828def is_rational_value(a):
2829 """Return `True` if `a` is rational value of sort Real.
2830
2831 >>> is_rational_value(RealVal(1))
2832 True
2833 >>> is_rational_value(RealVal("3/5"))
2834 True
2835 >>> is_rational_value(IntVal(1))
2836 False
2837 >>> is_rational_value(1)
2838 False
2839 >>> n = Real('x') + 1
2840 >>> n.arg(1)
2841 1
2842 >>> is_rational_value(n.arg(1))
2843 True
2844 >>> is_rational_value(Real('x'))
2845 False
2846 """
2847 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2848
2849

◆ is_re()

is_re ( s)

Definition at line 11433 of file z3py.py.

11433def is_re(s):
11434 return isinstance(s, ReRef)
11435
11436

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

2777def is_real(a):
2778 """Return `True` if `a` is a real expression.
2779
2780 >>> x = Int('x')
2781 >>> is_real(x + 1)
2782 False
2783 >>> y = Real('y')
2784 >>> is_real(y)
2785 True
2786 >>> is_real(y + 1)
2787 True
2788 >>> is_real(1)
2789 False
2790 >>> is_real(RealVal(1))
2791 True
2792 """
2793 return is_arith(a) and a.is_real()
2794
2795

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

4967def is_select(a):
4968 """Return `True` if `a` is a Z3 array select application.
4969
4970 >>> a = Array('a', IntSort(), IntSort())
4971 >>> is_select(a)
4972 False
4973 >>> i = Int('i')
4974 >>> is_select(a[i])
4975 True
4976 """
4977 return is_app_of(a, Z3_OP_SELECT)
4978
4979

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

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

Referenced by Concat(), and Extract().

◆ is_sort()

is_sort ( 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 651 of file z3py.py.

651def is_sort(s):
652 """Return `True` if `s` is a Z3 sort.
653
654 >>> is_sort(IntSort())
655 True
656 >>> is_sort(Int('x'))
657 False
658 >>> is_expr(Int('x'))
659 True
660 """
661 return isinstance(s, SortRef)
662
663

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

4980def is_store(a):
4981 """Return `True` if `a` is a Z3 array store application.
4982
4983 >>> a = Array('a', IntSort(), IntSort())
4984 >>> is_store(a)
4985 False
4986 >>> is_store(Store(a, 0, 1))
4987 True
4988 """
4989 return is_app_of(a, Z3_OP_STORE)
4990

◆ is_string()

is_string ( a)
Return `True` if `a` is a Z3 string expression.
>>> print (is_string(StringVal("ab")))
True

Definition at line 11143 of file z3py.py.

11143def is_string(a):
11144 """Return `True` if `a` is a Z3 string expression.
11145 >>> print (is_string(StringVal("ab")))
11146 True
11147 """
11148 return isinstance(a, SeqRef) and a.is_string()
11149
11150

◆ is_string_value()

is_string_value ( 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 11151 of file z3py.py.

11151def is_string_value(a):
11152 """return 'True' if 'a' is a Z3 string constant expression.
11153 >>> print (is_string_value(StringVal("a")))
11154 True
11155 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11156 False
11157 """
11158 return isinstance(a, SeqRef) and a.is_string_value()
11159

◆ is_sub()

is_sub ( 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 2888 of file z3py.py.

2888def is_sub(a):
2889 """Return `True` if `a` is an expression of the form b - c.
2890
2891 >>> x, y = Ints('x y')
2892 >>> is_sub(x - y)
2893 True
2894 >>> is_sub(x + y)
2895 False
2896 """
2897 return is_app_of(a, Z3_OP_SUB)
2898
2899

◆ is_to_int()

is_to_int ( 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 3016 of file z3py.py.

3016def is_to_int(a):
3017 """Return `True` if `a` is an expression of the form ToInt(b).
3018
3019 >>> x = Real('x')
3020 >>> n = ToInt(x)
3021 >>> n
3022 ToInt(x)
3023 >>> is_to_int(n)
3024 True
3025 >>> is_to_int(x)
3026 False
3027 """
3028 return is_app_of(a, Z3_OP_TO_INT)
3029
3030

◆ is_to_real()

is_to_real ( 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 3001 of file z3py.py.

3001def is_to_real(a):
3002 """Return `True` if `a` is an expression of the form ToReal(b).
3003
3004 >>> x = Int('x')
3005 >>> n = ToReal(x)
3006 >>> n
3007 ToReal(x)
3008 >>> is_to_real(n)
3009 True
3010 >>> is_to_real(x)
3011 False
3012 """
3013 return is_app_of(a, Z3_OP_TO_REAL)
3014
3015

◆ is_true()

is_true ( 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 1651 of file z3py.py.

1651def is_true(a):
1652 """Return `True` if `a` is the Z3 true expression.
1653
1654 >>> p = Bool('p')
1655 >>> is_true(p)
1656 False
1657 >>> is_true(simplify(p == p))
1658 True
1659 >>> x = Real('x')
1660 >>> is_true(x == 0)
1661 False
1662 >>> # True is a Python Boolean expression
1663 >>> is_true(True)
1664 False
1665 """
1666 return is_app_of(a, Z3_OP_TRUE)
1667
1668

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

1343def is_var(a):
1344 """Return `True` if `a` is variable.
1345
1346 Z3 uses de-Bruijn indices for representing bound variables in
1347 quantifiers.
1348
1349 >>> x = Int('x')
1350 >>> is_var(x)
1351 False
1352 >>> is_const(x)
1353 True
1354 >>> f = Function('f', IntSort(), IntSort())
1355 >>> # Z3 replaces x with bound variables when ForAll is executed.
1356 >>> q = ForAll(x, f(x) == x)
1357 >>> b = q.body()
1358 >>> b
1359 f(Var(0)) == Var(0)
1360 >>> b.arg(1)
1361 Var(0)
1362 >>> is_var(b.arg(1))
1363 True
1364 """
1365 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1366
1367

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

3470def IsInt(a):
3471 """ Return the Z3 predicate IsInt(a).
3472
3473 >>> x = Real('x')
3474 >>> IsInt(x + "1/2")
3475 IsInt(x + 1/2)
3476 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3477 [x = 1/2]
3478 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3479 no solution
3480 """
3481 if z3_debug():
3482 _z3_assert(a.is_real(), "Z3 real expression expected.")
3483 ctx = a.ctx
3484 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3485
3486
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 5090 of file z3py.py.

5090def IsMember(e, s):
5091 """ Check if e is a member of set s
5092 >>> a = Const('a', SetSort(IntSort()))
5093 >>> IsMember(1, a)
5094 a[1]
5095 """
5096 ctx = _ctx_from_ast_arg_list([s, e])
5097 e = _py2expr(e, ctx)
5098 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5099
5100
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 5101 of file z3py.py.

5101def IsSubset(a, b):
5102 """ Check if a is a subset of b
5103 >>> a = Const('a', SetSort(IntSort()))
5104 >>> b = Const('b', SetSort(IntSort()))
5105 >>> IsSubset(a, b)
5106 subset(a, b)
5107 """
5108 ctx = _ctx_from_ast_arg_list([a, b])
5109 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5110
5111
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 4927 of file z3py.py.

4927def K(dom, v):
4928 """Return a Z3 constant array expression.
4929
4930 >>> a = K(IntSort(), 10)
4931 >>> a
4932 K(Int, 10)
4933 >>> a.sort()
4934 Array(Int, Int)
4935 >>> i = Int('i')
4936 >>> a[i]
4937 K(Int, 10)[i]
4938 >>> simplify(a[i])
4939 10
4940 """
4941 if z3_debug():
4942 _z3_assert(is_sort(dom), "Z3 sort expected")
4943 ctx = dom.ctx
4944 if not is_expr(v):
4945 v = _py2expr(v, ctx)
4946 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4947
4948
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 2333 of file z3py.py.

2333def Lambda(vs, body):
2334 """Create a Z3 lambda expression.
2335
2336 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2337 >>> mem0 = Array('mem0', IntSort(), IntSort())
2338 >>> lo, hi, e, i = Ints('lo hi e i')
2339 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2340 >>> mem1
2341 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2342 """
2343 ctx = body.ctx
2344 if is_app(vs):
2345 vs = [vs]
2346 num_vars = len(vs)
2347 _vs = (Ast * num_vars)()
2348 for i in range(num_vars):
2349 # TODO: Check if is constant
2350 _vs[i] = vs[i].as_ast()
2351 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2352
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 11318 of file z3py.py.

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

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

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

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

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

◆ main_ctx()

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

239def main_ctx():
240 """Return a reference to the global Z3 context.
241
242 >>> x = Real('x')
243 >>> x.ctx == main_ctx()
244 True
245 >>> c = Context()
246 >>> c == main_ctx()
247 False
248 >>> x2 = Real('x', c)
249 >>> x2.ctx == c
250 True
251 >>> eq(x, x2)
252 False
253 """
254 global _main_ctx
255 if _main_ctx is None:
256 _main_ctx = Context()
257 return _main_ctx
258
259

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

4904def Map(f, *args):
4905 """Return a Z3 map array expression.
4906
4907 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4908 >>> a1 = Array('a1', IntSort(), IntSort())
4909 >>> a2 = Array('a2', IntSort(), IntSort())
4910 >>> b = Map(f, a1, a2)
4911 >>> b
4912 Map(f, a1, a2)
4913 >>> prove(b[0] == f(a1[0], a2[0]))
4914 proved
4915 """
4916 args = _get_args(args)
4917 if z3_debug():
4918 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4919 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4920 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4921 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4922 _args, sz = _to_ast_array(args)
4923 ctx = f.ctx
4924 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4925
4926
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 1896 of file z3py.py.

1896def mk_not(a):
1897 if is_not(a):
1898 return a.arg(0)
1899 else:
1900 return Not(a)
1901
1902

◆ Model()

Model ( ctx = None,
eval = {} )

Definition at line 6794 of file z3py.py.

6794def Model(ctx=None, eval = {}):
6795 ctx = _get_ctx(ctx)
6796 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
6797 for k, v in eval.items():
6798 mdl.update_value(k, v)
6799 return mdl
6800
6801
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 2013 of file z3py.py.

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

1877def Not(a, ctx=None):
1878 """Create a Z3 not expression or probe.
1879
1880 >>> p = Bool('p')
1881 >>> Not(Not(p))
1882 Not(Not(p))
1883 >>> simplify(Not(Not(p)))
1884 p
1885 """
1886 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1887 if is_probe(a):
1888 # Not is also used to build probes
1889 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1890 else:
1891 s = BoolSort(ctx)
1892 a = s.cast(a)
1893 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1894
1895
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 11629 of file z3py.py.

11629def on_clause_eh(ctx, p, n, dep, clause):
11630 onc = _my_hacky_class
11631 p = _to_expr_ref(to_Ast(p), onc.ctx)
11632 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11633 deps = [dep[i] for i in range(n)]
11634 onc.on_clause(p, deps, clause)
11635

◆ open_log()

open_log ( fname)
Log interaction to a file. This function must be invoked immediately after init(). 

Definition at line 114 of file z3py.py.

114def open_log(fname):
115 """Log interaction to a file. This function must be invoked immediately after init(). """
116 Z3_open_log(fname)
117
118
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 11504 of file z3py.py.

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

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

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

◆ ParAndThen()

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

Definition at line 8612 of file z3py.py.

8612def ParAndThen(t1, t2, ctx=None):
8613 """Alias for ParThen(t1, t2, ctx)."""
8614 return ParThen(t1, t2, ctx)
8615
8616

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

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

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

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

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

11585def PartialOrder(a, index):
11586 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11587
11588
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 9248 of file z3py.py.

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

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

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

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

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

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

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

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

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

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

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

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

3309def Q(a, b, ctx=None):
3310 """Return a Z3 rational a/b.
3311
3312 If `ctx=None`, then the global context is used.
3313
3314 >>> Q(3,5)
3315 3/5
3316 >>> Q(3,5).sort()
3317 Real
3318 """
3319 return simplify(RatVal(a, b, ctx=ctx))
3320
3321

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

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

3293def RatVal(a, b, ctx=None):
3294 """Return a Z3 rational a/b.
3295
3296 If `ctx=None`, then the global context is used.
3297
3298 >>> RatVal(3,5)
3299 3/5
3300 >>> RatVal(3,5).sort()
3301 Real
3302 """
3303 if z3_debug():
3304 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3305 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3306 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3307
3308

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

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

3375def Real(name, ctx=None):
3376 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3377
3378 >>> x = Real('x')
3379 >>> is_real(x)
3380 True
3381 >>> is_real(x + 1)
3382 True
3383 """
3384 ctx = _get_ctx(ctx)
3385 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3386
3387

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

3388def Reals(names, ctx=None):
3389 """Return a tuple of real constants.
3390
3391 >>> x, y, z = Reals('x y z')
3392 >>> Sum(x, y, z)
3393 x + y + z
3394 >>> Sum(x, y, z).sort()
3395 Real
3396 """
3397 ctx = _get_ctx(ctx)
3398 if isinstance(names, str):
3399 names = names.split(" ")
3400 return [Real(name, ctx) for name in names]
3401
3402

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

3233def RealSort(ctx=None):
3234 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3235
3236 >>> RealSort()
3237 Real
3238 >>> x = Const('x', RealSort())
3239 >>> is_real(x)
3240 True
3241 >>> is_int(x)
3242 False
3243 >>> x.sort() == RealSort()
3244 True
3245 """
3246 ctx = _get_ctx(ctx)
3247 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3248
3249
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 3274 of file z3py.py.

3274def RealVal(val, ctx=None):
3275 """Return a Z3 real value.
3276
3277 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3278 If `ctx=None`, then the global context is used.
3279
3280 >>> RealVal(1)
3281 1
3282 >>> RealVal(1).sort()
3283 Real
3284 >>> RealVal("3/5")
3285 3/5
3286 >>> RealVal("1.5")
3287 3/2
3288 """
3289 ctx = _get_ctx(ctx)
3290 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3291
3292

Referenced by _coerce_exprs(), _py2expr(), Cbrt(), RatVal(), Sqrt(), and ToReal().

◆ RealVar()

RealVar ( 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 1518 of file z3py.py.

1518def RealVar(idx, ctx=None):
1519 """
1520 Create a real free variable. Free variables are used to create quantified formulas.
1521 They are also used to create polynomials.
1522
1523 >>> RealVar(0)
1524 Var(0)
1525 """
1526 return Var(idx, RealSort(ctx))
1527
1528

Referenced by RealVarVector().

◆ RealVarVector()

RealVarVector ( 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 1529 of file z3py.py.

1529def RealVarVector(n, ctx=None):
1530 """
1531 Create a list of Real free variables.
1532 The variables have ids: 0, 1, ..., n-1
1533
1534 >>> x0, x1, x2, x3 = RealVarVector(4)
1535 >>> x2
1536 Var(2)
1537 """
1538 return [RealVar(i, ctx) for i in range(n)]
1539

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

3403def RealVector(prefix, sz, ctx=None):
3404 """Return a list of real constants of size `sz`.
3405
3406 >>> X = RealVector('x', 3)
3407 >>> X
3408 [x__0, x__1, x__2]
3409 >>> Sum(X)
3410 x__0 + x__1 + x__2
3411 >>> Sum(X).sort()
3412 Real
3413 """
3414 ctx = _get_ctx(ctx)
3415 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3416
3417

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

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

935def RecFunction(name, *sig):
936 """Create a new Z3 recursive with the given sorts."""
937 sig = _get_args(sig)
938 if z3_debug():
939 _z3_assert(len(sig) > 0, "At least two arguments expected")
940 arity = len(sig) - 1
941 rng = sig[arity]
942 if z3_debug():
943 _z3_assert(is_sort(rng), "Z3 sort expected")
944 dom = (Sort * arity)()
945 for i in range(arity):
946 if z3_debug():
947 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
948 dom[i] = sig[i].ast
949 ctx = rng.ctx
950 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
951
952
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 8645 of file z3py.py.

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

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

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

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

Definition at line 295 of file z3py.py.

295def reset_params():
296 """Reset all global (or module) parameters.
297 """
299
300
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 11417 of file z3py.py.

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

9907def RNA(ctx=None):
9908 ctx = _get_ctx(ctx)
9909 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9910
9911
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 9897 of file z3py.py.

9897def RNE(ctx=None):
9898 ctx = _get_ctx(ctx)
9899 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9900
9901
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 4412 of file z3py.py.

4412def RotateLeft(a, b):
4413 """Return an expression representing `a` rotated to the left `b` times.
4414
4415 >>> a, b = BitVecs('a b', 16)
4416 >>> RotateLeft(a, b)
4417 RotateLeft(a, b)
4418 >>> simplify(RotateLeft(a, 0))
4419 a
4420 >>> simplify(RotateLeft(a, 16))
4421 a
4422 """
4423 _check_bv_args(a, b)
4424 a, b = _coerce_exprs(a, b)
4425 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4426
4427
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 4428 of file z3py.py.

4428def RotateRight(a, b):
4429 """Return an expression representing `a` rotated to the right `b` times.
4430
4431 >>> a, b = BitVecs('a b', 16)
4432 >>> RotateRight(a, b)
4433 RotateRight(a, b)
4434 >>> simplify(RotateRight(a, 0))
4435 a
4436 >>> simplify(RotateRight(a, 16))
4437 a
4438 """
4439 _check_bv_args(a, b)
4440 a, b = _coerce_exprs(a, b)
4441 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4442
4443
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 9902 of file z3py.py.

9902def RoundNearestTiesToAway(ctx=None):
9903 ctx = _get_ctx(ctx)
9904 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9905
9906

◆ RoundNearestTiesToEven()

RoundNearestTiesToEven ( ctx = None)

Definition at line 9892 of file z3py.py.

9892def RoundNearestTiesToEven(ctx=None):
9893 ctx = _get_ctx(ctx)
9894 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9895
9896

◆ RoundTowardNegative()

RoundTowardNegative ( ctx = None)

Definition at line 9922 of file z3py.py.

9922def RoundTowardNegative(ctx=None):
9923 ctx = _get_ctx(ctx)
9924 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9925
9926
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 9912 of file z3py.py.

9912def RoundTowardPositive(ctx=None):
9913 ctx = _get_ctx(ctx)
9914 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9915
9916
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 9932 of file z3py.py.

9932def RoundTowardZero(ctx=None):
9933 ctx = _get_ctx(ctx)
9934 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9935
9936
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 9927 of file z3py.py.

9927def RTN(ctx=None):
9928 ctx = _get_ctx(ctx)
9929 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9930
9931

◆ RTP()

RTP ( ctx = None)

Definition at line 9917 of file z3py.py.

9917def RTP(ctx=None):
9918 ctx = _get_ctx(ctx)
9919 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9920
9921

◆ RTZ()

RTZ ( ctx = None)

Definition at line 9937 of file z3py.py.

9937def RTZ(ctx=None):
9938 ctx = _get_ctx(ctx)
9939 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9940
9941

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

4888def Select(a, *args):
4889 """Return a Z3 select array expression.
4890
4891 >>> a = Array('a', IntSort(), IntSort())
4892 >>> i = Int('i')
4893 >>> Select(a, i)
4894 a[i]
4895 >>> eq(Select(a, i), a[i])
4896 True
4897 """
4898 args = _get_args(args)
4899 if z3_debug():
4900 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4901 return a[args]
4902
4903

◆ SeqFoldLeft()

SeqFoldLeft ( f,
a,
s )

Definition at line 11350 of file z3py.py.

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

11356def SeqFoldLeftI(f, i, a, s):
11357 ctx = _get_ctx2(f, s)
11358 s = _coerce_seq(s, ctx)
11359 a = _py2expr(a)
11360 i = _py2epxr(i)
11361 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11362
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 11336 of file z3py.py.

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

11342def SeqMapI(f, i, s):
11343 """Map function 'f' over sequence 's' at index 'i'"""
11344 ctx = _get_ctx(f, s)
11345 s = _coerce_seq(s, ctx)
11346 if not is_expr(i):
11347 i = _py2expr(i)
11348 return _to_expr_ref(Z3_mk_seq_mapi(s.ctx_ref(), f.as_ast(), i.as_ast(), s.as_ast()), ctx)
11349
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 11001 of file z3py.py.

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

9553def set_default_fp_sort(ebits, sbits, ctx=None):
9554 global _dflt_fpsort_ebits
9555 global _dflt_fpsort_sbits
9556 _dflt_fpsort_ebits = ebits
9557 _dflt_fpsort_sbits = sbits
9558
9559

◆ set_default_rounding_mode()

set_default_rounding_mode ( rm,
ctx = None )

Definition at line 9540 of file z3py.py.

9540def set_default_rounding_mode(rm, ctx=None):
9541 global _dflt_rounding_mode
9542 if is_fprm_value(rm):
9543 _dflt_rounding_mode = rm.kind()
9544 else:
9545 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9546 _dflt_rounding_mode = rm
9547
9548

◆ set_option()

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

Definition at line 301 of file z3py.py.

301def set_option(*args, **kws):
302 """Alias for 'set_param' for backward compatibility.
303 """
304 return set_param(*args, **kws)
305
306

◆ set_param()

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

>>> set_param(precision=10)

Definition at line 271 of file z3py.py.

271def set_param(*args, **kws):
272 """Set Z3 global (or module) parameters.
273
274 >>> set_param(precision=10)
275 """
276 if z3_debug():
277 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
278 new_kws = {}
279 for k in kws:
280 v = kws[k]
281 if not set_pp_option(k, v):
282 new_kws[k] = v
283 for key in new_kws:
284 value = new_kws[key]
285 Z3_global_param_set(str(key).upper(), _to_param_value(value))
286 prev = None
287 for a in args:
288 if prev is None:
289 prev = a
290 else:
291 Z3_global_param_set(str(prev), _to_param_value(a))
292 prev = None
293
294
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 5047 of file z3py.py.

5047def SetAdd(s, e):
5048 """ Add element e to set s
5049 >>> a = Const('a', SetSort(IntSort()))
5050 >>> SetAdd(a, 1)
5051 Store(a, 1, True)
5052 """
5053 ctx = _ctx_from_ast_arg_list([s, e])
5054 e = _py2expr(e, ctx)
5055 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5056
5057
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 5069 of file z3py.py.

5069def SetComplement(s):
5070 """ The complement of set s
5071 >>> a = Const('a', SetSort(IntSort()))
5072 >>> SetComplement(a)
5073 complement(a)
5074 """
5075 ctx = s.ctx
5076 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
5077
5078
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 5058 of file z3py.py.

5058def SetDel(s, e):
5059 """ Remove element e to set s
5060 >>> a = Const('a', SetSort(IntSort()))
5061 >>> SetDel(a, 1)
5062 Store(a, 1, False)
5063 """
5064 ctx = _ctx_from_ast_arg_list([s, e])
5065 e = _py2expr(e, ctx)
5066 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5067
5068
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 5079 of file z3py.py.

5079def SetDifference(a, b):
5080 """ The set difference of a and b
5081 >>> a = Const('a', SetSort(IntSort()))
5082 >>> b = Const('b', SetSort(IntSort()))
5083 >>> SetDifference(a, b)
5084 setminus(a, b)
5085 """
5086 ctx = _ctx_from_ast_arg_list([a, b])
5087 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5088
5089
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 4961 of file z3py.py.

4961def SetHasSize(a, k):
4962 ctx = a.ctx
4963 k = _py2expr(k, ctx)
4964 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4965
4966
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 5034 of file z3py.py.

5034def SetIntersect(*args):
5035 """ Take the union of sets
5036 >>> a = Const('a', SetSort(IntSort()))
5037 >>> b = Const('b', SetSort(IntSort()))
5038 >>> SetIntersect(a, b)
5039 intersection(a, b)
5040 """
5041 args = _get_args(args)
5042 ctx = _ctx_from_ast_arg_list(args)
5043 _args, sz = _to_ast_array(args)
5044 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
5045
5046
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 4998 of file z3py.py.

4998def SetSort(s):
4999 """ Create a set sort over element sort s"""
5000 return ArraySort(s, BoolSort())
5001
5002

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

5021def SetUnion(*args):
5022 """ Take the union of sets
5023 >>> a = Const('a', SetSort(IntSort()))
5024 >>> b = Const('b', SetSort(IntSort()))
5025 >>> SetUnion(a, b)
5026 union(a, b)
5027 """
5028 args = _get_args(args)
5029 ctx = _ctx_from_ast_arg_list(args)
5030 _args, sz = _to_ast_array(args)
5031 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
5032
5033
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 4444 of file z3py.py.

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

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

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

9027def simplify_param_descrs():
9028 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9029 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
9030
9031
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 9259 of file z3py.py.

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

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

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

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

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

3487def Sqrt(a, ctx=None):
3488 """ Return a Z3 expression which represents the square root of a.
3489
3490 >>> x = Real('x')
3491 >>> Sqrt(x)
3492 x**(1/2)
3493 """
3494 if not is_expr(a):
3495 ctx = _get_ctx(ctx)
3496 a = RealVal(a, ctx)
3497 return a ** "1/2"
3498
3499

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

4359def SRem(a, b):
4360 """Create the Z3 expression signed remainder.
4361
4362 Use the operator % for signed modulus, and URem() for unsigned remainder.
4363
4364 >>> x = BitVec('x', 32)
4365 >>> y = BitVec('y', 32)
4366 >>> SRem(x, y)
4367 SRem(x, y)
4368 >>> SRem(x, y).sort()
4369 BitVec(32)
4370 >>> (x % y).sexpr()
4371 '(bvsmod x y)'
4372 >>> SRem(x, y).sexpr()
4373 '(bvsrem x y)'
4374 """
4375 _check_bv_args(a, b)
4376 a, b = _coerce_exprs(a, b)
4377 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4378
4379
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 11524 of file z3py.py.

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

4871def Store(a, *args):
4872 """Return a Z3 store array expression.
4873
4874 >>> a = Array('a', IntSort(), IntSort())
4875 >>> i, v = Ints('i v')
4876 >>> s = Store(a, i, v)
4877 >>> s.sort()
4878 Array(Int, Int)
4879 >>> prove(s[i] == v)
4880 proved
4881 >>> j = Int('j')
4882 >>> prove(Implies(i != j, s[j] == a[j]))
4883 proved
4884 """
4885 return Update(a, args)
4886
4887

Referenced by ModelRef.get_interp().

◆ StrFromCode()

StrFromCode ( c)
Convert code to a string

Definition at line 11392 of file z3py.py.

11392def StrFromCode(c):
11393 """Convert code to a string"""
11394 if not is_expr(c):
11395 c = _py2expr(c)
11396 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11397
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 11167 of file z3py.py.

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

◆ Strings()

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

Definition at line 11176 of file z3py.py.

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

◆ StringSort()

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

Definition at line 10982 of file z3py.py.

10982def StringSort(ctx=None):
10983 """Create a string sort
10984 >>> s = StringSort()
10985 >>> print(s)
10986 String
10987 """
10988 ctx = _get_ctx(ctx)
10989 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10990

◆ StringVal()

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

Definition at line 11160 of file z3py.py.

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

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

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

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

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

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

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

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

11184def SubString(s, offset, length):
11185 """Extract substring or subsequence starting at offset"""
11186 return Extract(s, offset, length)
11187
11188

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

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

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

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

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

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

◆ to_Ast()

to_Ast ( ptr)

Definition at line 11608 of file z3py.py.

11608def to_Ast(ptr,):
11609 ast = Ast(ptr)
11610 super(ctypes.c_void_p, ast).__init__(ptr)
11611 return ast
11612

◆ to_AstVectorObj()

to_AstVectorObj ( ptr)

Definition at line 11618 of file z3py.py.

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

◆ to_ContextObj()

to_ContextObj ( ptr)

Definition at line 11613 of file z3py.py.

11613def to_ContextObj(ptr,):
11614 ctx = ContextObj(ptr)
11615 super(ctypes.c_void_p, ctx).__init__(ptr)
11616 return ctx
11617

◆ to_symbol()

to_symbol ( s,
ctx = None )
Convert an integer or string into a Z3 symbol.

Definition at line 124 of file z3py.py.

124def to_symbol(s, ctx=None):
125 """Convert an integer or string into a Z3 symbol."""
126 if _is_int(s):
127 return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
128 else:
129 return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
130
131
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 3452 of file z3py.py.

3452def ToInt(a):
3453 """ Return the Z3 expression ToInt(a).
3454
3455 >>> x = Real('x')
3456 >>> x.sort()
3457 Real
3458 >>> n = ToInt(x)
3459 >>> n
3460 ToInt(x)
3461 >>> n.sort()
3462 Int
3463 """
3464 if z3_debug():
3465 _z3_assert(a.is_real(), "Z3 real expression expected.")
3466 ctx = a.ctx
3467 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3468
3469
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 3432 of file z3py.py.

3432def ToReal(a):
3433 """ Return the Z3 expression ToReal(a).
3434
3435 >>> x = Int('x')
3436 >>> x.sort()
3437 Int
3438 >>> n = ToReal(x)
3439 >>> n
3440 ToReal(x)
3441 >>> n.sort()
3442 Real
3443 """
3444 ctx = a.ctx
3445 if isinstance(a, BoolRef):
3446 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3447 if z3_debug():
3448 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3449 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3450
3451
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 11601 of file z3py.py.

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

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

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

5444def TupleSort(name, sorts, ctx=None):
5445 """Create a named tuple sort base on a set of underlying sorts
5446 Example:
5447 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5448 """
5449 tuple = Datatype(name, ctx)
5450 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5451 tuple.declare(name, *projects)
5452 tuple = tuple.create()
5453 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5454
5455

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

4317def UDiv(a, b):
4318 """Create the Z3 expression (unsigned) division `self / other`.
4319
4320 Use the operator / for signed division.
4321
4322 >>> x = BitVec('x', 32)
4323 >>> y = BitVec('y', 32)
4324 >>> UDiv(x, y)
4325 UDiv(x, y)
4326 >>> UDiv(x, y).sort()
4327 BitVec(32)
4328 >>> (x / y).sexpr()
4329 '(bvsdiv x y)'
4330 >>> UDiv(x, y).sexpr()
4331 '(bvudiv x y)'
4332 """
4333 _check_bv_args(a, b)
4334 a, b = _coerce_exprs(a, b)
4335 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4336
4337
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 4281 of file z3py.py.

4281def UGE(a, b):
4282 """Create the Z3 expression (unsigned) `other >= self`.
4283
4284 Use the operator >= for signed greater than or equal to.
4285
4286 >>> x, y = BitVecs('x y', 32)
4287 >>> UGE(x, y)
4288 UGE(x, y)
4289 >>> (x >= y).sexpr()
4290 '(bvsge x y)'
4291 >>> UGE(x, y).sexpr()
4292 '(bvuge x y)'
4293 """
4294 _check_bv_args(a, b)
4295 a, b = _coerce_exprs(a, b)
4296 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4297
4298
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 4299 of file z3py.py.

4299def UGT(a, b):
4300 """Create the Z3 expression (unsigned) `other > self`.
4301
4302 Use the operator > for signed greater than.
4303
4304 >>> x, y = BitVecs('x y', 32)
4305 >>> UGT(x, y)
4306 UGT(x, y)
4307 >>> (x > y).sexpr()
4308 '(bvsgt x y)'
4309 >>> UGT(x, y).sexpr()
4310 '(bvugt x y)'
4311 """
4312 _check_bv_args(a, b)
4313 a, b = _coerce_exprs(a, b)
4314 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4315
4316
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 4245 of file z3py.py.

4245def ULE(a, b):
4246 """Create the Z3 expression (unsigned) `other <= self`.
4247
4248 Use the operator <= for signed less than or equal to.
4249
4250 >>> x, y = BitVecs('x y', 32)
4251 >>> ULE(x, y)
4252 ULE(x, y)
4253 >>> (x <= y).sexpr()
4254 '(bvsle x y)'
4255 >>> ULE(x, y).sexpr()
4256 '(bvule x y)'
4257 """
4258 _check_bv_args(a, b)
4259 a, b = _coerce_exprs(a, b)
4260 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4261
4262
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 4263 of file z3py.py.

4263def ULT(a, b):
4264 """Create the Z3 expression (unsigned) `other < self`.
4265
4266 Use the operator < for signed less than.
4267
4268 >>> x, y = BitVecs('x y', 32)
4269 >>> ULT(x, y)
4270 ULT(x, y)
4271 >>> (x < y).sexpr()
4272 '(bvslt x y)'
4273 >>> ULT(x, y).sexpr()
4274 '(bvult x y)'
4275 """
4276 _check_bv_args(a, b)
4277 a, b = _coerce_exprs(a, b)
4278 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4279
4280
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 11451 of file z3py.py.

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

11229def Unit(a):
11230 """Create a singleton sequence"""
11231 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11232
11233
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 4828 of file z3py.py.

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

4338def URem(a, b):
4339 """Create the Z3 expression (unsigned) remainder `self % other`.
4340
4341 Use the operator % for signed modulus, and SRem() for signed remainder.
4342
4343 >>> x = BitVec('x', 32)
4344 >>> y = BitVec('y', 32)
4345 >>> URem(x, y)
4346 URem(x, y)
4347 >>> URem(x, y).sort()
4348 BitVec(32)
4349 >>> (x % y).sexpr()
4350 '(bvsmod x y)'
4351 >>> URem(x, y).sexpr()
4352 '(bvurem x y)'
4353 """
4354 _check_bv_args(a, b)
4355 a, b = _coerce_exprs(a, b)
4356 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4357
4358
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 11729 of file z3py.py.

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

◆ user_prop_decide()

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

Definition at line 11763 of file z3py.py.

11763def user_prop_decide(ctx, cb, t_ref, idx, phase):
11764 prop = _prop_closures.get(ctx)
11765 old_cb = prop.cb
11766 prop.cb = cb
11767 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11768 prop.decide(t, idx, phase)
11769 prop.cb = old_cb
11770
11771

◆ user_prop_diseq()

user_prop_diseq ( ctx,
cb,
x,
y )

Definition at line 11754 of file z3py.py.

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

◆ user_prop_eq()

user_prop_eq ( ctx,
cb,
x,
y )

Definition at line 11745 of file z3py.py.

11745def user_prop_eq(ctx, cb, x, y):
11746 prop = _prop_closures.get(ctx)
11747 old_cb = prop.cb
11748 prop.cb = cb
11749 x = _to_expr_ref(to_Ast(x), prop.ctx())
11750 y = _to_expr_ref(to_Ast(y), prop.ctx())
11751 prop.eq(x, y)
11752 prop.cb = old_cb
11753

◆ user_prop_final()

user_prop_final ( ctx,
cb )

Definition at line 11738 of file z3py.py.

11738def user_prop_final(ctx, cb):
11739 prop = _prop_closures.get(ctx)
11740 old_cb = prop.cb
11741 prop.cb = cb
11742 prop.final()
11743 prop.cb = old_cb
11744

◆ user_prop_fixed()

user_prop_fixed ( ctx,
cb,
id,
value )

Definition at line 11720 of file z3py.py.

11720def user_prop_fixed(ctx, cb, id, value):
11721 prop = _prop_closures.get(ctx)
11722 old_cb = prop.cb
11723 prop.cb = cb
11724 id = _to_expr_ref(to_Ast(id), prop.ctx())
11725 value = _to_expr_ref(to_Ast(value), prop.ctx())
11726 prop.fixed(id, value)
11727 prop.cb = old_cb
11728

◆ user_prop_fresh()

user_prop_fresh ( ctx,
_new_ctx )

Definition at line 11706 of file z3py.py.

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

11700def user_prop_pop(ctx, cb, num_scopes):
11701 prop = _prop_closures.get(ctx)
11702 prop.cb = cb
11703 prop.pop(num_scopes)
11704
11705

◆ user_prop_push()

user_prop_push ( ctx,
cb )

Definition at line 11694 of file z3py.py.

11694def user_prop_push(ctx, cb):
11695 prop = _prop_closures.get(ctx)
11696 prop.cb = cb
11697 prop.push()
11698
11699

◆ Var()

Var ( idx,
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 1503 of file z3py.py.

1503def Var(idx, s):
1504 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1505 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1506 declarations.
1507
1508 >>> Var(0, IntSort())
1509 Var(0)
1510 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1511 False
1512 """
1513 if z3_debug():
1514 _z3_assert(is_sort(s), "Z3 sort expected")
1515 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1516
1517
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 8960 of file z3py.py.

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

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

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

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

1861def Xor(a, b, ctx=None):
1862 """Create a Z3 Xor expression.
1863
1864 >>> p, q = Bools('p q')
1865 >>> Xor(p, q)
1866 Xor(p, q)
1867 >>> simplify(Xor(p, q))
1868 Not(p == q)
1869 """
1870 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1871 s = BoolSort(ctx)
1872 a = s.cast(a)
1873 b = s.cast(b)
1874 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1875
1876
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 174 of file z3py.py.

174def z3_error_handler(c, e):
175 # Do nothing error handler, just avoid exit(0)
176 # The wrappers in z3core.py will raise a Z3Exception if an error is detected
177 return
178
179

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

4474def ZeroExt(n, a):
4475 """Return a bit-vector expression with `n` extra zero-bits.
4476
4477 >>> x = BitVec('x', 16)
4478 >>> n = ZeroExt(8, x)
4479 >>> n.size()
4480 24
4481 >>> n
4482 ZeroExt(8, x)
4483 >>> n.sort()
4484 BitVec(24)
4485 >>> v0 = BitVecVal(2, 2)
4486 >>> v0
4487 2
4488 >>> v0.size()
4489 2
4490 >>> v = simplify(ZeroExt(6, v0))
4491 >>> v
4492 2
4493 >>> v.size()
4494 8
4495 """
4496 if z3_debug():
4497 _z3_assert(_is_int(n), "First argument must be an integer")
4498 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4499 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4500
4501
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 9512 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

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

◆ _main_ctx

_main_ctx = None
protected

Definition at line 236 of file z3py.py.

◆ _my_hacky_class

_my_hacky_class = None
protected

Definition at line 11628 of file z3py.py.

◆ _on_clause_eh

_on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 11636 of file z3py.py.

◆ _on_model_eh

_on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 8016 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 8008 of file z3py.py.

◆ _prop_closures

_prop_closures = None
protected

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

◆ _user_prop_created

_user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11776 of file z3py.py.

◆ _user_prop_decide

_user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11780 of file z3py.py.

◆ _user_prop_diseq

_user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11779 of file z3py.py.

◆ _user_prop_eq

_user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11778 of file z3py.py.

◆ _user_prop_final

_user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11777 of file z3py.py.

◆ _user_prop_fixed

_user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11775 of file z3py.py.

◆ _user_prop_fresh

_user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11774 of file z3py.py.

◆ _user_prop_pop

_user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11773 of file z3py.py.

◆ _user_prop_push

_user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11772 of file z3py.py.

◆ sat

Definition at line 7000 of file z3py.py.

◆ unknown

Definition at line 7002 of file z3py.py.

◆ unsat

Definition at line 7001 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.