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)
 
 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, 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 8414 of file z3py.py.

8414def _and_then(t1, t2, ctx=None):
8415 t1 = _to_tactic(t1, ctx)
8416 t2 = _to_tactic(t2, ctx)
8417 if z3_debug():
8418 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8419 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8420
8421
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 4644 of file z3py.py.

4644def _array_select(ar, arg):
4645 if isinstance(arg, tuple):
4646 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4647 _args, sz = _to_ast_array(args)
4648 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4649 arg = ar.sort().domain().cast(arg)
4650 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4651
4652
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 491 of file z3py.py.

491def _ast_kind(ctx, a):
492 if is_ast(a):
493 a = a.as_ast()
494 return Z3_get_ast_kind(ctx.ref(), a)
495
496
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 4205 of file z3py.py.

4205def _check_bv_args(a, b):
4206 if z3_debug():
4207 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4208
4209

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

10516def _check_fp_args(a, b):
10517 if z3_debug():
10518 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10519
10520

◆ _coerce_char()

_coerce_char ( ch,
ctx = None )
protected

Definition at line 10956 of file z3py.py.

10956def _coerce_char(ch, ctx=None):
10957 if isinstance(ch, str):
10958 ctx = _get_ctx(ctx)
10959 ch = CharVal(ch, ctx)
10960 if not is_expr(ch):
10961 raise Z3Exception("Character expression expected")
10962 return ch
10963

◆ _coerce_expr_list()

_coerce_expr_list ( alist,
ctx = None )
protected

Definition at line 1248 of file z3py.py.

1248def _coerce_expr_list(alist, ctx=None):
1249 has_expr = False
1250 for a in alist:
1251 if is_expr(a):
1252 has_expr = True
1253 break
1254 if not has_expr:
1255 alist = [_py2expr(a, ctx) for a in alist]
1256 s = _reduce(_coerce_expr_merge, alist, None)
1257 return [s.cast(a) for a in alist]
1258
1259

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

◆ _coerce_expr_merge()

_coerce_expr_merge ( s,
a )
protected

Definition at line 1201 of file z3py.py.

1201def _coerce_expr_merge(s, a):
1202 if is_expr(a):
1203 s1 = a.sort()
1204 if s is None:
1205 return s1
1206 if s1.eq(s):
1207 return s
1208 elif s.subsort(s1):
1209 return s1
1210 elif s1.subsort(s):
1211 return s
1212 else:
1213 if z3_debug():
1214 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1215 _z3_assert(False, "sort mismatch")
1216 else:
1217 return s
1218
1219

Referenced by _coerce_exprs().

◆ _coerce_exprs()

_coerce_exprs ( a,
b,
ctx = None )
protected

Definition at line 1220 of file z3py.py.

1220def _coerce_exprs(a, b, ctx=None):
1221 if not is_expr(a) and not is_expr(b):
1222 a = _py2expr(a, ctx)
1223 b = _py2expr(b, ctx)
1224 if isinstance(a, str) and isinstance(b, SeqRef):
1225 a = StringVal(a, b.ctx)
1226 if isinstance(b, str) and isinstance(a, SeqRef):
1227 b = StringVal(b, a.ctx)
1228 if isinstance(a, float) and isinstance(b, ArithRef):
1229 a = RealVal(a, b.ctx)
1230 if isinstance(b, float) and isinstance(a, ArithRef):
1231 b = RealVal(b, a.ctx)
1232
1233 s = None
1234 s = _coerce_expr_merge(s, a)
1235 s = _coerce_expr_merge(s, b)
1236 a = s.cast(a)
1237 b = s.cast(b)
1238 return (a, b)
1239
1240

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

9475def _coerce_fp_expr_list(alist, ctx):
9476 first_fp_sort = None
9477 for a in alist:
9478 if is_fp(a):
9479 if first_fp_sort is None:
9480 first_fp_sort = a.sort()
9481 elif first_fp_sort == a.sort():
9482 pass # OK, same as before
9483 else:
9484 # we saw at least 2 different float sorts; something will
9485 # throw a sort mismatch later, for now assume None.
9486 first_fp_sort = None
9487 break
9488
9489 r = []
9490 for i in range(len(alist)):
9491 a = alist[i]
9492 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9493 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9494 r.append(FPVal(a, None, first_fp_sort, ctx))
9495 else:
9496 r.append(a)
9497 return _coerce_expr_list(r, ctx)
9498
9499
9500# FP Sorts
9501

◆ _coerce_seq()

_coerce_seq ( s,
ctx = None )
protected

Definition at line 11006 of file z3py.py.

11006def _coerce_seq(s, ctx=None):
11007 if isinstance(s, str):
11008 ctx = _get_ctx(ctx)
11009 s = StringVal(s, ctx)
11010 if not is_expr(s):
11011 raise Z3Exception("Non-expression passed as a sequence")
11012 if not is_seq(s):
11013 raise Z3Exception("Non-sequence passed as a sequence")
11014 return s
11015
11016

Referenced by Concat().

◆ _ctx_from_ast_arg_list()

_ctx_from_ast_arg_list ( args,
default_ctx = None )
protected

Definition at line 497 of file z3py.py.

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

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

511def _ctx_from_ast_args(*args):
512 return _ctx_from_ast_arg_list(args)
513
514

◆ _dflt_fps()

_dflt_fps ( ctx = None)
protected

Definition at line 9471 of file z3py.py.

9471def _dflt_fps(ctx=None):
9472 return get_default_fp_sort(ctx)
9473
9474

◆ _dflt_rm()

_dflt_rm ( ctx = None)
protected

Definition at line 9467 of file z3py.py.

9467def _dflt_rm(ctx=None):
9468 return get_default_rounding_mode(ctx)
9469
9470

◆ _dict2darray()

_dict2darray ( decls,
ctx )
protected

Definition at line 9340 of file z3py.py.

9340def _dict2darray(decls, ctx):
9341 sz = len(decls)
9342 _names = (Symbol * sz)()
9343 _decls = (FuncDecl * sz)()
9344 i = 0
9345 for k in decls:
9346 v = decls[k]
9347 if z3_debug():
9348 _z3_assert(isinstance(k, str), "String expected")
9349 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9350 _names[i] = to_symbol(k, ctx)
9351 if is_const(v):
9352 _decls[i] = v.decl().ast
9353 else:
9354 _decls[i] = v.ast
9355 i = i + 1
9356 return sz, _names, _decls
9357

◆ _dict2sarray()

_dict2sarray ( sorts,
ctx )
protected

Definition at line 9324 of file z3py.py.

9324def _dict2sarray(sorts, ctx):
9325 sz = len(sorts)
9326 _names = (Symbol * sz)()
9327 _sorts = (Sort * sz)()
9328 i = 0
9329 for k in sorts:
9330 v = sorts[k]
9331 if z3_debug():
9332 _z3_assert(isinstance(k, str), "String expected")
9333 _z3_assert(is_sort(v), "Z3 sort expected")
9334 _names[i] = to_symbol(k, ctx)
9335 _sorts[i] = v.ast
9336 i = i + 1
9337 return sz, _names, _sorts
9338
9339

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

11017def _get_ctx2(a, b, ctx=None):
11018 if is_expr(a):
11019 return a.ctx
11020 if is_expr(b):
11021 return b.ctx
11022 if ctx is None:
11023 ctx = main_ctx()
11024 return ctx
11025
11026

◆ _global_on_model()

_global_on_model ( ctx)
protected

Definition at line 7925 of file z3py.py.

7925def _global_on_model(ctx):
7926 (fn, mdl) = _on_models[ctx]
7927 fn(mdl)
7928
7929

◆ _has_probe()

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

Definition at line 1881 of file z3py.py.

1881def _has_probe(args):
1882 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1883 for arg in args:
1884 if is_probe(arg):
1885 return True
1886 return False
1887
1888

Referenced by And(), and Or().

◆ _is_algebraic()

_is_algebraic ( ctx,
a )
protected

Definition at line 2778 of file z3py.py.

2778def _is_algebraic(ctx, a):
2779 return Z3_is_algebraic_number(ctx.ref(), a)
2780
2781
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 2774 of file z3py.py.

2774def _is_numeral(ctx, a):
2775 return Z3_is_numeral_ast(ctx.ref(), a)
2776
2777
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 1446 of file z3py.py.

1446def _mk_bin(f, a, b):
1447 args = (Ast * 2)()
1448 if z3_debug():
1449 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1450 args[0] = a.as_ast()
1451 args[1] = b.as_ast()
1452 return f(a.ctx.ref(), 2, args)
1453
1454

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

10304def _mk_fp_bin(f, rm, a, b, ctx):
10305 ctx = _get_ctx(ctx)
10306 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10307 if z3_debug():
10308 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10309 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10310 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10311
10312

◆ _mk_fp_bin_norm()

_mk_fp_bin_norm ( f,
a,
b,
ctx )
protected

Definition at line 10313 of file z3py.py.

10313def _mk_fp_bin_norm(f, a, b, ctx):
10314 ctx = _get_ctx(ctx)
10315 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10316 if z3_debug():
10317 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10318 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10319
10320

◆ _mk_fp_bin_pred()

_mk_fp_bin_pred ( f,
a,
b,
ctx )
protected

Definition at line 10321 of file z3py.py.

10321def _mk_fp_bin_pred(f, a, b, ctx):
10322 ctx = _get_ctx(ctx)
10323 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10324 if z3_debug():
10325 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10326 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10327
10328

◆ _mk_fp_tern()

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

Definition at line 10329 of file z3py.py.

10329def _mk_fp_tern(f, rm, a, b, c, ctx):
10330 ctx = _get_ctx(ctx)
10331 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10332 if z3_debug():
10333 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10334 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10335 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10336 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10337
10338

◆ _mk_fp_unary()

_mk_fp_unary ( f,
rm,
a,
ctx )
protected

Definition at line 10287 of file z3py.py.

10287def _mk_fp_unary(f, rm, a, ctx):
10288 ctx = _get_ctx(ctx)
10289 [a] = _coerce_fp_expr_list([a], ctx)
10290 if z3_debug():
10291 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10292 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10293 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10294
10295

◆ _mk_fp_unary_pred()

_mk_fp_unary_pred ( f,
a,
ctx )
protected

Definition at line 10296 of file z3py.py.

10296def _mk_fp_unary_pred(f, a, ctx):
10297 ctx = _get_ctx(ctx)
10298 [a] = _coerce_fp_expr_list([a], ctx)
10299 if z3_debug():
10300 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10301 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10302
10303

◆ _mk_quantifier()

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

Definition at line 2237 of file z3py.py.

2237def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2238 if z3_debug():
2239 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2240 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2241 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2242 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2243 if is_app(vs):
2244 ctx = vs.ctx
2245 vs = [vs]
2246 else:
2247 ctx = vs[0].ctx
2248 if not is_expr(body):
2249 body = BoolVal(body, ctx)
2250 num_vars = len(vs)
2251 if num_vars == 0:
2252 return body
2253 _vs = (Ast * num_vars)()
2254 for i in range(num_vars):
2255 # TODO: Check if is constant
2256 _vs[i] = vs[i].as_ast()
2257 patterns = [_to_pattern(p) for p in patterns]
2258 num_pats = len(patterns)
2259 _pats = (Pattern * num_pats)()
2260 for i in range(num_pats):
2261 _pats[i] = patterns[i].ast
2262 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2263 qid = to_symbol(qid, ctx)
2264 skid = to_symbol(skid, ctx)
2265 return QuantifierRef(Z3_mk_quantifier_const_ex(ctx.ref(), is_forall, weight, qid, skid,
2266 num_vars, _vs,
2267 num_pats, _pats,
2268 num_no_pats, _no_pats,
2269 body.as_ast()), ctx)
2270
2271
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 8422 of file z3py.py.

8422def _or_else(t1, t2, ctx=None):
8423 t1 = _to_tactic(t1, ctx)
8424 t2 = _to_tactic(t2, ctx)
8425 if z3_debug():
8426 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8427 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8428
8429
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 9113 of file z3py.py.

9113def _pb_args_coeffs(args, default_ctx=None):
9114 args = _get_args_ast_list(args)
9115 if len(args) == 0:
9116 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9117 args = [_reorder_pb_arg(arg) for arg in args]
9118 args, coeffs = zip(*args)
9119 if z3_debug():
9120 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9121 ctx = _ctx_from_ast_arg_list(args)
9122 if z3_debug():
9123 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9124 args = _coerce_expr_list(args, ctx)
9125 _args, sz = _to_ast_array(args)
9126 _coeffs = (ctypes.c_int * len(coeffs))()
9127 for i in range(len(coeffs)):
9128 _z3_check_cint_overflow(coeffs[i], "coefficient")
9129 _coeffs[i] = coeffs[i]
9130 return ctx, sz, _args, _coeffs, args
9131
9132

◆ _probe_and()

_probe_and ( args,
ctx )
protected

Definition at line 8837 of file z3py.py.

8837def _probe_and(args, ctx):
8838 return _probe_nary(Z3_probe_and, args, ctx)
8839
8840

Referenced by And().

◆ _probe_nary()

_probe_nary ( f,
args,
ctx )
protected

Definition at line 8827 of file z3py.py.

8827def _probe_nary(f, args, ctx):
8828 if z3_debug():
8829 _z3_assert(len(args) > 0, "At least one argument expected")
8830 num = len(args)
8831 r = _to_probe(args[0], ctx)
8832 for i in range(num - 1):
8833 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8834 return r
8835
8836

◆ _probe_or()

_probe_or ( args,
ctx )
protected

Definition at line 8841 of file z3py.py.

8841def _probe_or(args, ctx):
8842 return _probe_nary(Z3_probe_or, args, ctx)
8843
8844

Referenced by Or().

◆ _prove_html()

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

Definition at line 9304 of file z3py.py.

9304def _prove_html(claim, show=False, **keywords):
9305 """Version of function `prove` that renders HTML."""
9306 if z3_debug():
9307 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9308 s = Solver()
9309 s.set(**keywords)
9310 s.add(Not(claim))
9311 if show:
9312 print(s)
9313 r = s.check()
9314 if r == unsat:
9315 print("<b>proved</b>")
9316 elif r == unknown:
9317 print("<b>failed to prove</b>")
9318 print(s.model())
9319 else:
9320 print("<b>counterexample</b>")
9321 print(s.model())
9322
9323

◆ _py2expr()

_py2expr ( a,
ctx = None )
protected

Definition at line 3173 of file z3py.py.

3173def _py2expr(a, ctx=None):
3174 if isinstance(a, bool):
3175 return BoolVal(a, ctx)
3176 if _is_int(a):
3177 return IntVal(a, ctx)
3178 if isinstance(a, float):
3179 return RealVal(a, ctx)
3180 if isinstance(a, str):
3181 return StringVal(a, ctx)
3182 if is_expr(a):
3183 return a
3184 if z3_debug():
3185 _z3_assert(False, "Python bool, int, long or float expected")
3186
3187

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

1241def _reduce(func, sequence, initial):
1242 result = initial
1243 for element in sequence:
1244 result = func(result, element)
1245 return result
1246
1247

Referenced by _coerce_expr_list().

◆ _reorder_pb_arg()

_reorder_pb_arg ( arg)
protected

Definition at line 9106 of file z3py.py.

9106def _reorder_pb_arg(arg):
9107 a, b = arg
9108 if not _is_int(b) and _is_int(a):
9109 return b, a
9110 return arg
9111
9112

◆ _solve_html()

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

Definition at line 9255 of file z3py.py.

9255def _solve_html(*args, **keywords):
9256 """Version of function `solve` that renders HTML output."""
9257 show = keywords.pop("show", False)
9258 s = Solver()
9259 s.set(**keywords)
9260 s.add(*args)
9261 if show:
9262 print("<b>Problem:</b>")
9263 print(s)
9264 r = s.check()
9265 if r == unsat:
9266 print("<b>no solution</b>")
9267 elif r == unknown:
9268 print("<b>failed to solve</b>")
9269 try:
9270 print(s.model())
9271 except Z3Exception:
9272 return
9273 else:
9274 if show:
9275 print("<b>Solution:</b>")
9276 print(s.model())
9277
9278

◆ _solve_using_html()

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

Definition at line 9279 of file z3py.py.

9279def _solve_using_html(s, *args, **keywords):
9280 """Version of function `solve_using` that renders HTML."""
9281 show = keywords.pop("show", False)
9282 if z3_debug():
9283 _z3_assert(isinstance(s, Solver), "Solver object expected")
9284 s.set(**keywords)
9285 s.add(*args)
9286 if show:
9287 print("<b>Problem:</b>")
9288 print(s)
9289 r = s.check()
9290 if r == unsat:
9291 print("<b>no solution</b>")
9292 elif r == unknown:
9293 print("<b>failed to solve</b>")
9294 try:
9295 print(s.model())
9296 except Z3Exception:
9297 return
9298 else:
9299 if show:
9300 print("<b>Solution:</b>")
9301 print(s.model())
9302
9303

◆ _sort()

_sort ( ctx,
a )
protected

Definition at line 691 of file z3py.py.

691def _sort(ctx, a):
692 return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
693
694
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 555 of file z3py.py.

555def _sort_kind(ctx, s):
556 return Z3_get_sort_kind(ctx.ref(), s)
557
558
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 523 of file z3py.py.

523def _to_ast_array(args):
524 sz = len(args)
525 _args = (Ast * sz)()
526 for i in range(sz):
527 _args[i] = args[i].as_ast()
528 return _args, sz
529
530

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

539def _to_ast_ref(a, ctx):
540 k = _ast_kind(ctx, a)
541 if k == Z3_SORT_AST:
542 return _to_sort_ref(a, ctx)
543 elif k == Z3_FUNC_DECL_AST:
544 return _to_func_decl_ref(a, ctx)
545 else:
546 return _to_expr_ref(a, ctx)
547
548

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

◆ _to_expr_ref()

_to_expr_ref ( a,
ctx )
protected

Definition at line 1151 of file z3py.py.

1151def _to_expr_ref(a, ctx):
1152 if isinstance(a, Pattern):
1153 return PatternRef(a, ctx)
1154 ctx_ref = ctx.ref()
1155 k = Z3_get_ast_kind(ctx_ref, a)
1156 if k == Z3_QUANTIFIER_AST:
1157 return QuantifierRef(a, ctx)
1158 sk = Z3_get_sort_kind(ctx_ref, Z3_get_sort(ctx_ref, a))
1159 if sk == Z3_BOOL_SORT:
1160 return BoolRef(a, ctx)
1161 if sk == Z3_INT_SORT:
1162 if k == Z3_NUMERAL_AST:
1163 return IntNumRef(a, ctx)
1164 return ArithRef(a, ctx)
1165 if sk == Z3_REAL_SORT:
1166 if k == Z3_NUMERAL_AST:
1167 return RatNumRef(a, ctx)
1168 if _is_algebraic(ctx, a):
1169 return AlgebraicNumRef(a, ctx)
1170 return ArithRef(a, ctx)
1171 if sk == Z3_BV_SORT:
1172 if k == Z3_NUMERAL_AST:
1173 return BitVecNumRef(a, ctx)
1174 else:
1175 return BitVecRef(a, ctx)
1176 if sk == Z3_ARRAY_SORT:
1177 return ArrayRef(a, ctx)
1178 if sk == Z3_DATATYPE_SORT:
1179 return DatatypeRef(a, ctx)
1180 if sk == Z3_FLOATING_POINT_SORT:
1181 if k == Z3_APP_AST and _is_numeral(ctx, a):
1182 return FPNumRef(a, ctx)
1183 else:
1184 return FPRef(a, ctx)
1185 if sk == Z3_FINITE_DOMAIN_SORT:
1186 if k == Z3_NUMERAL_AST:
1187 return FiniteDomainNumRef(a, ctx)
1188 else:
1189 return FiniteDomainRef(a, ctx)
1190 if sk == Z3_ROUNDING_MODE_SORT:
1191 return FPRMRef(a, ctx)
1192 if sk == Z3_SEQ_SORT:
1193 return SeqRef(a, ctx)
1194 if sk == Z3_CHAR_SORT:
1195 return CharRef(a, ctx)
1196 if sk == Z3_RE_SORT:
1197 return ReRef(a, ctx)
1198 return ExprRef(a, ctx)
1199
1200

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(), SetHasSize(), Update(), FuncEntry.value(), and Var().

◆ _to_float_str()

_to_float_str ( val,
exp = 0 )
protected

Definition at line 10049 of file z3py.py.

10049def _to_float_str(val, exp=0):
10050 if isinstance(val, float):
10051 if math.isnan(val):
10052 res = "NaN"
10053 elif val == 0.0:
10054 sone = math.copysign(1.0, val)
10055 if sone < 0.0:
10056 return "-0.0"
10057 else:
10058 return "+0.0"
10059 elif val == float("+inf"):
10060 res = "+oo"
10061 elif val == float("-inf"):
10062 res = "-oo"
10063 else:
10064 v = val.as_integer_ratio()
10065 num = v[0]
10066 den = v[1]
10067 rvs = str(num) + "/" + str(den)
10068 res = rvs + "p" + _to_int_str(exp)
10069 elif isinstance(val, bool):
10070 if val:
10071 res = "1.0"
10072 else:
10073 res = "0.0"
10074 elif _is_int(val):
10075 res = str(val)
10076 elif isinstance(val, str):
10077 inx = val.find("*(2**")
10078 if inx == -1:
10079 res = val
10080 elif val[-1] == ")":
10081 res = val[0:inx]
10082 exp = str(int(val[inx + 5:-1]) + int(exp))
10083 else:
10084 _z3_assert(False, "String does not have floating-point numeral form.")
10085 elif z3_debug():
10086 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10087 if exp == 0:
10088 return res
10089 else:
10090 return res + "p" + exp
10091
10092

◆ _to_func_decl_array()

_to_func_decl_array ( args)
protected

Definition at line 515 of file z3py.py.

515def _to_func_decl_array(args):
516 sz = len(args)
517 _args = (FuncDecl * sz)()
518 for i in range(sz):
519 _args[i] = args[i].as_func_decl()
520 return _args, sz
521
522

◆ _to_func_decl_ref()

_to_func_decl_ref ( a,
ctx )
protected

Definition at line 923 of file z3py.py.

923def _to_func_decl_ref(a, ctx):
924 return FuncDeclRef(a, ctx)
925
926

Referenced by _to_ast_ref().

◆ _to_goal()

_to_goal ( a)
protected

Definition at line 8398 of file z3py.py.

8398def _to_goal(a):
8399 if isinstance(a, BoolRef):
8400 goal = Goal(ctx=a.ctx)
8401 goal.add(a)
8402 return goal
8403 else:
8404 return a
8405
8406

◆ _to_int_str()

_to_int_str ( val)
protected

Definition at line 3222 of file z3py.py.

3222def _to_int_str(val):
3223 if isinstance(val, float):
3224 return str(int(val))
3225 elif isinstance(val, bool):
3226 if val:
3227 return "1"
3228 else:
3229 return "0"
3230 else:
3231 return str(val)
3232
3233

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

2015def _to_pattern(arg):
2016 if is_pattern(arg):
2017 return arg
2018 else:
2019 return MultiPattern(arg)
2020

Referenced by _mk_quantifier().

◆ _to_probe()

_to_probe ( p,
ctx = None )
protected

Definition at line 8781 of file z3py.py.

8781def _to_probe(p, ctx=None):
8782 if is_probe(p):
8783 return p
8784 else:
8785 return Probe(p, ctx)
8786
8787

◆ _to_ref_array()

_to_ref_array ( ref,
args )
protected

Definition at line 531 of file z3py.py.

531def _to_ref_array(ref, args):
532 sz = len(args)
533 _args = (ref * sz)()
534 for i in range(sz):
535 _args[i] = args[i].as_ast()
536 return _args, sz
537
538

◆ _to_sort_ref()

_to_sort_ref ( s,
ctx )
protected

Definition at line 660 of file z3py.py.

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

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

8407def _to_tactic(t, ctx=None):
8408 if isinstance(t, Tactic):
8409 return t
8410 else:
8411 return Tactic(t, ctx)
8412
8413

◆ _valid_accessor()

_valid_accessor ( acc)
protected

Datatypes.

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

Definition at line 5083 of file z3py.py.

5083def _valid_accessor(acc):
5084 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5085 if not isinstance(acc, tuple):
5086 return False
5087 if len(acc) != 2:
5088 return False
5089 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5090
5091

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

9065def Abs(arg):
9066 """Create the absolute value of an arithmetic expression"""
9067 return If(arg > 0, arg, -arg)
9068
9069

◆ AllChar()

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

Definition at line 11471 of file z3py.py.

11471def AllChar(regex_sort, ctx=None):
11472 """Create a regular expression that accepts all single character strings
11473 """
11474 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11475
11476# Special Relations
11477
11478
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 1889 of file z3py.py.

1889def And(*args):
1890 """Create a Z3 and-expression or and-probe.
1891
1892 >>> p, q, r = Bools('p q r')
1893 >>> And(p, q, r)
1894 And(p, q, r)
1895 >>> P = BoolVector('p', 5)
1896 >>> And(P)
1897 And(p__0, p__1, p__2, p__3, p__4)
1898 """
1899 last_arg = None
1900 if len(args) > 0:
1901 last_arg = args[len(args) - 1]
1902 if isinstance(last_arg, Context):
1903 ctx = args[len(args) - 1]
1904 args = args[:len(args) - 1]
1905 elif len(args) == 1 and isinstance(args[0], AstVector):
1906 ctx = args[0].ctx
1907 args = [a for a in args[0]]
1908 else:
1909 ctx = None
1910 args = _get_args(args)
1911 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1912 if z3_debug():
1913 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1914 if _has_probe(args):
1915 return _probe_and(args, ctx)
1916 else:
1917 args = _coerce_expr_list(args, ctx)
1918 _args, sz = _to_ast_array(args)
1919 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1920
1921
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 8430 of file z3py.py.

8430def AndThen(*ts, **ks):
8431 """Return a tactic that applies the tactics in `*ts` in sequence.
8432
8433 >>> x, y = Ints('x y')
8434 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8435 >>> t(And(x == 0, y > x + 1))
8436 [[Not(y <= 1)]]
8437 >>> t(And(x == 0, y > x + 1)).as_expr()
8438 Not(y <= 1)
8439 """
8440 if z3_debug():
8441 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8442 ctx = ks.get("ctx", None)
8443 num = len(ts)
8444 r = ts[0]
8445 for i in range(num - 1):
8446 r = _and_then(r, ts[i + 1], ctx)
8447 return r
8448
8449

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

5512def args2params(arguments, keywords, ctx=None):
5513 """Convert python arguments into a Z3_params object.
5514 A ':' is added to the keywords, and '_' is replaced with '-'
5515
5516 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5517 (params model true relevancy 2 elim_and true)
5518 """
5519 if z3_debug():
5520 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5521 prev = None
5522 r = ParamsRef(ctx)
5523 for a in arguments:
5524 if prev is None:
5525 prev = a
5526 else:
5527 r.set(prev, a)
5528 prev = None
5529 for k in keywords:
5530 v = keywords[k]
5531 r.set(k, v)
5532 return r
5533
5534

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

4779def Array(name, *sorts):
4780 """Return an array constant named `name` with the given domain and range sorts.
4781
4782 >>> a = Array('a', IntSort(), IntSort())
4783 >>> a.sort()
4784 Array(Int, Int)
4785 >>> a[0]
4786 a[0]
4787 """
4788 s = ArraySort(sorts)
4789 ctx = s.ctx
4790 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4791
4792
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 4746 of file z3py.py.

4746def ArraySort(*sig):
4747 """Return the Z3 array sort with the given domain and range sorts.
4748
4749 >>> A = ArraySort(IntSort(), BoolSort())
4750 >>> A
4751 Array(Int, Bool)
4752 >>> A.domain()
4753 Int
4754 >>> A.range()
4755 Bool
4756 >>> AA = ArraySort(IntSort(), A)
4757 >>> AA
4758 Array(Int, Array(Int, Bool))
4759 """
4760 sig = _get_args(sig)
4761 if z3_debug():
4762 _z3_assert(len(sig) > 1, "At least two arguments expected")
4763 arity = len(sig) - 1
4764 r = sig[arity]
4765 d = sig[0]
4766 if z3_debug():
4767 for s in sig:
4768 _z3_assert(is_sort(s), "Z3 sort expected")
4769 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4770 ctx = d.ctx
4771 if len(sig) == 2:
4772 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4773 dom = (Sort * arity)()
4774 for i in range(arity):
4775 dom[i] = sig[i].ast
4776 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4777
4778
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 9088 of file z3py.py.

9088def AtLeast(*args):
9089 """Create an at-least Pseudo-Boolean k constraint.
9090
9091 >>> a, b, c = Bools('a b c')
9092 >>> f = AtLeast(a, b, c, 2)
9093 """
9094 args = _get_args(args)
9095 if z3_debug():
9096 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9097 ctx = _ctx_from_ast_arg_list(args)
9098 if z3_debug():
9099 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9100 args1 = _coerce_expr_list(args[:-1], ctx)
9101 k = args[-1]
9102 _args, sz = _to_ast_array(args1)
9103 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9104
9105
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 9070 of file z3py.py.

9070def AtMost(*args):
9071 """Create an at-most Pseudo-Boolean k constraint.
9072
9073 >>> a, b, c = Bools('a b c')
9074 >>> f = AtMost(a, b, c, 2)
9075 """
9076 args = _get_args(args)
9077 if z3_debug():
9078 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9079 ctx = _ctx_from_ast_arg_list(args)
9080 if z3_debug():
9081 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9082 args1 = _coerce_expr_list(args[:-1], ctx)
9083 k = args[-1]
9084 _args, sz = _to_ast_array(args1)
9085 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9086
9087
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 4083 of file z3py.py.

4083def BitVec(name, bv, ctx=None):
4084 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4085 If `ctx=None`, then the global context is used.
4086
4087 >>> x = BitVec('x', 16)
4088 >>> is_bv(x)
4089 True
4090 >>> x.size()
4091 16
4092 >>> x.sort()
4093 BitVec(16)
4094 >>> word = BitVecSort(16)
4095 >>> x2 = BitVec('x', word)
4096 >>> eq(x, x2)
4097 True
4098 """
4099 if isinstance(bv, BitVecSortRef):
4100 ctx = bv.ctx
4101 else:
4102 ctx = _get_ctx(ctx)
4103 bv = BitVecSort(bv, ctx)
4104 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4105
4106

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

4107def BitVecs(names, bv, ctx=None):
4108 """Return a tuple of bit-vector constants of size bv.
4109
4110 >>> x, y, z = BitVecs('x y z', 16)
4111 >>> x.size()
4112 16
4113 >>> x.sort()
4114 BitVec(16)
4115 >>> Sum(x, y, z)
4116 0 + x + y + z
4117 >>> Product(x, y, z)
4118 1*x*y*z
4119 >>> simplify(Product(x, y, z))
4120 x*y*z
4121 """
4122 ctx = _get_ctx(ctx)
4123 if isinstance(names, str):
4124 names = names.split(" ")
4125 return [BitVec(name, bv, ctx) for name in names]
4126
4127

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

4051def BitVecSort(sz, ctx=None):
4052 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4053
4054 >>> Byte = BitVecSort(8)
4055 >>> Word = BitVecSort(16)
4056 >>> Byte
4057 BitVec(8)
4058 >>> x = Const('x', Byte)
4059 >>> eq(x, BitVec('x', 8))
4060 True
4061 """
4062 ctx = _get_ctx(ctx)
4063 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4064
4065
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 4066 of file z3py.py.

4066def BitVecVal(val, bv, ctx=None):
4067 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4068
4069 >>> v = BitVecVal(10, 32)
4070 >>> v
4071 10
4072 >>> print("0x%.8x" % v.as_long())
4073 0x0000000a
4074 """
4075 if is_bv_sort(bv):
4076 ctx = bv.ctx
4077 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4078 else:
4079 ctx = _get_ctx(ctx)
4080 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4081
4082
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 1768 of file z3py.py.

1768def Bool(name, ctx=None):
1769 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1770
1771 >>> p = Bool('p')
1772 >>> q = Bool('q')
1773 >>> And(p, q)
1774 And(p, q)
1775 """
1776 ctx = _get_ctx(ctx)
1777 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1778
1779

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

1780def Bools(names, ctx=None):
1781 """Return a tuple of Boolean constants.
1782
1783 `names` is a single string containing all names separated by blank spaces.
1784 If `ctx=None`, then the global context is used.
1785
1786 >>> p, q, r = Bools('p q r')
1787 >>> And(p, Or(q, r))
1788 And(p, Or(q, r))
1789 """
1790 ctx = _get_ctx(ctx)
1791 if isinstance(names, str):
1792 names = names.split(" ")
1793 return [Bool(name, ctx) for name in names]
1794
1795

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

1731def BoolSort(ctx=None):
1732 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1733
1734 >>> BoolSort()
1735 Bool
1736 >>> p = Const('p', BoolSort())
1737 >>> is_bool(p)
1738 True
1739 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1740 >>> r(0, 1)
1741 r(0, 1)
1742 >>> is_bool(r(0, 1))
1743 True
1744 """
1745 ctx = _get_ctx(ctx)
1746 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1747
1748
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 1749 of file z3py.py.

1749def BoolVal(val, ctx=None):
1750 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1751
1752 >>> BoolVal(True)
1753 True
1754 >>> is_true(BoolVal(True))
1755 True
1756 >>> is_true(True)
1757 False
1758 >>> is_false(BoolVal(False))
1759 True
1760 """
1761 ctx = _get_ctx(ctx)
1762 if val:
1763 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1764 else:
1765 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1766
1767
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 1796 of file z3py.py.

1796def BoolVector(prefix, sz, ctx=None):
1797 """Return a list of Boolean constants of size `sz`.
1798
1799 The constants are named using the given prefix.
1800 If `ctx=None`, then the global context is used.
1801
1802 >>> P = BoolVector('p', 3)
1803 >>> P
1804 [p__0, p__1, p__2]
1805 >>> And(P)
1806 And(p__0, p__1, p__2)
1807 """
1808 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1809
1810

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

4019def BV2Int(a, is_signed=False):
4020 """Return the Z3 expression BV2Int(a).
4021
4022 >>> b = BitVec('b', 3)
4023 >>> BV2Int(b).sort()
4024 Int
4025 >>> x = Int('x')
4026 >>> x > BV2Int(b)
4027 x > BV2Int(b)
4028 >>> x > BV2Int(b, is_signed=False)
4029 x > BV2Int(b)
4030 >>> x > BV2Int(b, is_signed=True)
4031 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4032 >>> solve(x > BV2Int(b), b == 1, x < 3)
4033 [x = 2, b = 1]
4034 """
4035 if z3_debug():
4036 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4037 ctx = a.ctx
4038 # investigate problem with bv2int
4039 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
4040
4041
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 4505 of file z3py.py.

4505def BVAddNoOverflow(a, b, signed):
4506 """A predicate the determines that bit-vector addition does not overflow"""
4507 _check_bv_args(a, b)
4508 a, b = _coerce_exprs(a, b)
4509 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4510
4511
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 4512 of file z3py.py.

4512def BVAddNoUnderflow(a, b):
4513 """A predicate the determines that signed bit-vector addition does not underflow"""
4514 _check_bv_args(a, b)
4515 a, b = _coerce_exprs(a, b)
4516 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4517
4518
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 4547 of file z3py.py.

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

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

4491def BVRedAnd(a):
4492 """Return the reduction-and expression of `a`."""
4493 if z3_debug():
4494 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4495 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4496
4497
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 4498 of file z3py.py.

4498def BVRedOr(a):
4499 """Return the reduction-or expression of `a`."""
4500 if z3_debug():
4501 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4502 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4503
4504
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 4533 of file z3py.py.

4533def BVSDivNoOverflow(a, b):
4534 """A predicate the determines that bit-vector signed division does not overflow"""
4535 _check_bv_args(a, b)
4536 a, b = _coerce_exprs(a, b)
4537 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4538
4539
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 4540 of file z3py.py.

4540def BVSNegNoOverflow(a):
4541 """A predicate the determines that bit-vector unary negation does not overflow"""
4542 if z3_debug():
4543 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4544 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4545
4546
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 4519 of file z3py.py.

4519def BVSubNoOverflow(a, b):
4520 """A predicate the determines that bit-vector subtraction does not overflow"""
4521 _check_bv_args(a, b)
4522 a, b = _coerce_exprs(a, b)
4523 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4524
4525
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 4526 of file z3py.py.

4526def BVSubNoUnderflow(a, b, signed):
4527 """A predicate the determines that bit-vector subtraction does not underflow"""
4528 _check_bv_args(a, b)
4529 a, b = _coerce_exprs(a, b)
4530 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4531
4532
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 3470 of file z3py.py.

3470def Cbrt(a, ctx=None):
3471 """ Return a Z3 expression which represents the cubic root of a.
3472
3473 >>> x = Real('x')
3474 >>> Cbrt(x)
3475 x**(1/3)
3476 """
3477 if not is_expr(a):
3478 ctx = _get_ctx(ctx)
3479 a = RealVal(a, ctx)
3480 return a ** "1/3"
3481

◆ CharFromBv()

CharFromBv ( bv)

Definition at line 10989 of file z3py.py.

10989def CharFromBv(bv):
10990 if not is_expr(bv):
10991 raise Z3Exception("Bit-vector expression needed")
10992 return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
10993
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 11002 of file z3py.py.

11002def CharIsDigit(ch, ctx=None):
11003 ch = _coerce_char(ch, ctx)
11004 return ch.is_digit()
11005

◆ CharSort()

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

Definition at line 10888 of file z3py.py.

10888def CharSort(ctx=None):
10889 """Create a character sort
10890 >>> ch = CharSort()
10891 >>> print(ch)
10892 Char
10893 """
10894 ctx = _get_ctx(ctx)
10895 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
10896
10897
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 10994 of file z3py.py.

10994def CharToBv(ch, ctx=None):
10995 ch = _coerce_char(ch, ctx)
10996 return ch.to_bv()
10997

◆ CharToInt()

CharToInt ( ch,
ctx = None )

Definition at line 10998 of file z3py.py.

10998def CharToInt(ch, ctx=None):
10999 ch = _coerce_char(ch, ctx)
11000 return ch.to_int()
11001

◆ CharVal()

CharVal ( ch,
ctx = None )

Definition at line 10981 of file z3py.py.

10981def CharVal(ch, ctx=None):
10982 ctx = _get_ctx(ctx)
10983 if isinstance(ch, str):
10984 ch = ord(ch)
10985 if not isinstance(ch, int):
10986 raise Z3Exception("character value should be an ordinal")
10987 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
10988
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 11413 of file z3py.py.

11413def Complement(re):
11414 """Create the complement regular expression."""
11415 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11416
11417
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 4128 of file z3py.py.

4128def Concat(*args):
4129 """Create a Z3 bit-vector concatenation expression.
4130
4131 >>> v = BitVecVal(1, 4)
4132 >>> Concat(v, v+1, v)
4133 Concat(Concat(1, 1 + 1), 1)
4134 >>> simplify(Concat(v, v+1, v))
4135 289
4136 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4137 121
4138 """
4139 args = _get_args(args)
4140 sz = len(args)
4141 if z3_debug():
4142 _z3_assert(sz >= 2, "At least two arguments expected.")
4143
4144 ctx = None
4145 for a in args:
4146 if is_expr(a):
4147 ctx = a.ctx
4148 break
4149 if is_seq(args[0]) or isinstance(args[0], str):
4150 args = [_coerce_seq(s, ctx) for s in args]
4151 if z3_debug():
4152 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4153 v = (Ast * sz)()
4154 for i in range(sz):
4155 v[i] = args[i].as_ast()
4156 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4157
4158 if is_re(args[0]):
4159 if z3_debug():
4160 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4161 v = (Ast * sz)()
4162 for i in range(sz):
4163 v[i] = args[i].as_ast()
4164 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4165
4166 if z3_debug():
4167 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4168 r = args[0]
4169 for i in range(sz - 1):
4170 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4171 return r
4172
4173
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 8887 of file z3py.py.

8887def Cond(p, t1, t2, ctx=None):
8888 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8889
8890 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8891 """
8892 p = _to_probe(p, ctx)
8893 t1 = _to_tactic(t1, ctx)
8894 t2 = _to_tactic(t2, ctx)
8895 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8896
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 1455 of file z3py.py.

1455def Const(name, sort):
1456 """Create a constant of the given sort.
1457
1458 >>> Const('x', IntSort())
1459 x
1460 """
1461 if z3_debug():
1462 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1463 ctx = sort.ctx
1464 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1465
1466

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

1467def Consts(names, sort):
1468 """Create several constants of the given sort.
1469
1470 `names` is a string containing the names of all constants to be created.
1471 Blank spaces separate the names of different constants.
1472
1473 >>> x, y, z = Consts('x y z', IntSort())
1474 >>> x + y + z
1475 x + y + z
1476 """
1477 if isinstance(names, str):
1478 names = names.split(" ")
1479 return [Const(name, sort) for name in names]
1480
1481

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

11158def Contains(a, b):
11159 """Check if 'a' contains 'b'
11160 >>> s1 = Contains("abc", "ab")
11161 >>> simplify(s1)
11162 True
11163 >>> s2 = Contains("abc", "bc")
11164 >>> simplify(s2)
11165 True
11166 >>> x, y, z = Strings('x y z')
11167 >>> s3 = Contains(Concat(x,y,z), y)
11168 >>> simplify(s3)
11169 True
11170 """
11171 ctx = _get_ctx2(a, b)
11172 a = _coerce_seq(a, ctx)
11173 b = _coerce_seq(b, ctx)
11174 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11175
11176
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 5204 of file z3py.py.

5204def CreateDatatypes(*ds):
5205 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5206
5207 In the following example we define a Tree-List using two mutually recursive datatypes.
5208
5209 >>> TreeList = Datatype('TreeList')
5210 >>> Tree = Datatype('Tree')
5211 >>> # Tree has two constructors: leaf and node
5212 >>> Tree.declare('leaf', ('val', IntSort()))
5213 >>> # a node contains a list of trees
5214 >>> Tree.declare('node', ('children', TreeList))
5215 >>> TreeList.declare('nil')
5216 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5217 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5218 >>> Tree.val(Tree.leaf(10))
5219 val(leaf(10))
5220 >>> simplify(Tree.val(Tree.leaf(10)))
5221 10
5222 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5223 >>> n1
5224 node(cons(leaf(10), cons(leaf(20), nil)))
5225 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5226 >>> simplify(n2 == n1)
5227 False
5228 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5229 True
5230 """
5231 ds = _get_args(ds)
5232 if z3_debug():
5233 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5234 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5235 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5236 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5237 ctx = ds[0].ctx
5238 num = len(ds)
5239 names = (Symbol * num)()
5240 out = (Sort * num)()
5241 clists = (ConstructorList * num)()
5242 to_delete = []
5243 for i in range(num):
5244 d = ds[i]
5245 names[i] = to_symbol(d.name, ctx)
5246 num_cs = len(d.constructors)
5247 cs = (Constructor * num_cs)()
5248 for j in range(num_cs):
5249 c = d.constructors[j]
5250 cname = to_symbol(c[0], ctx)
5251 rname = to_symbol(c[1], ctx)
5252 fs = c[2]
5253 num_fs = len(fs)
5254 fnames = (Symbol * num_fs)()
5255 sorts = (Sort * num_fs)()
5256 refs = (ctypes.c_uint * num_fs)()
5257 for k in range(num_fs):
5258 fname = fs[k][0]
5259 ftype = fs[k][1]
5260 fnames[k] = to_symbol(fname, ctx)
5261 if isinstance(ftype, Datatype):
5262 if z3_debug():
5263 _z3_assert(
5264 ds.count(ftype) == 1,
5265 "One and only one occurrence of each datatype is expected",
5266 )
5267 sorts[k] = None
5268 refs[k] = ds.index(ftype)
5269 else:
5270 if z3_debug():
5271 _z3_assert(is_sort(ftype), "Z3 sort expected")
5272 sorts[k] = ftype.ast
5273 refs[k] = 0
5274 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5275 to_delete.append(ScopedConstructor(cs[j], ctx))
5276 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5277 to_delete.append(ScopedConstructorList(clists[i], ctx))
5278 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5279 result = []
5280 # Create a field for every constructor, recognizer and accessor
5281 for i in range(num):
5282 dref = DatatypeSortRef(out[i], ctx)
5283 num_cs = dref.num_constructors()
5284 for j in range(num_cs):
5285 cref = dref.constructor(j)
5286 cref_name = cref.name()
5287 cref_arity = cref.arity()
5288 if cref.arity() == 0:
5289 cref = cref()
5290 setattr(dref, cref_name, cref)
5291 rref = dref.recognizer(j)
5292 setattr(dref, "is_" + cref_name, rref)
5293 for k in range(cref_arity):
5294 aref = dref.accessor(j, k)
5295 setattr(dref, aref.name(), aref)
5296 result.append(dref)
5297 return tuple(result)
5298
5299
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 5404 of file z3py.py.

5404def DatatypeSort(name, ctx = None):
5405 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5406 ctx = _get_ctx(ctx)
5407 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5408
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 695 of file z3py.py.

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

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

4825def Default(a):
4826 """ Return a default value for array expression.
4827 >>> b = K(IntSort(), 1)
4828 >>> prove(Default(b) == 1)
4829 proved
4830 """
4831 if z3_debug():
4832 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4833 return a.default()
4834
4835

◆ describe_probes()

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

Definition at line 8808 of file z3py.py.

8808def describe_probes():
8809 """Display a (tabular) description of all available probes in Z3."""
8810 if in_html_mode():
8811 even = True
8812 print('<table border="1" cellpadding="2" cellspacing="0">')
8813 for p in probes():
8814 if even:
8815 print('<tr style="background-color:#CFCFCF">')
8816 even = False
8817 else:
8818 print("<tr>")
8819 even = True
8820 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8821 print("</table>")
8822 else:
8823 for p in probes():
8824 print("%s : %s" % (p, probe_description(p)))
8825
8826

◆ describe_tactics()

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

Definition at line 8602 of file z3py.py.

8602def describe_tactics():
8603 """Display a (tabular) description of all available tactics in Z3."""
8604 if in_html_mode():
8605 even = True
8606 print('<table border="1" cellpadding="2" cellspacing="0">')
8607 for t in tactics():
8608 if even:
8609 print('<tr style="background-color:#CFCFCF">')
8610 even = False
8611 else:
8612 print("<tr>")
8613 even = True
8614 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8615 print("</table>")
8616 else:
8617 for t in tactics():
8618 print("%s : %s" % (t, tactic_description(t)))
8619
8620

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

1137def deserialize(st):
1138 """inverse function to the serialize method on ExprRef.
1139 It is made available to make it easier for users to serialize expressions back and forth between
1140 strings. Solvers can be serialized using the 'sexpr()' method.
1141 """
1142 s = Solver()
1143 s.from_string(st)
1144 if len(s.assertions()) != 1:
1145 raise Z3Exception("single assertion expected")
1146 fml = s.assertions()[0]
1147 if fml.num_args() != 1:
1148 raise Z3Exception("dummy function 'F' expected")
1149 return fml.arg(0)
1150

◆ Diff()

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

Definition at line 11463 of file z3py.py.

11463def Diff(a, b, ctx=None):
11464 """Create the difference regular expression
11465 """
11466 if z3_debug():
11467 _z3_assert(is_expr(a), "expression expected")
11468 _z3_assert(is_expr(b), "expression expected")
11469 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11470
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 5421 of file z3py.py.

5421def DisjointSum(name, sorts, ctx=None):
5422 """Create a named tagged union sort base on a set of underlying sorts
5423 Example:
5424 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5425 """
5426 sum = Datatype(name, ctx)
5427 for i in range(len(sorts)):
5428 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5429 sum = sum.create()
5430 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5431
5432

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

1422def Distinct(*args):
1423 """Create a Z3 distinct expression.
1424
1425 >>> x = Int('x')
1426 >>> y = Int('y')
1427 >>> Distinct(x, y)
1428 x != y
1429 >>> z = Int('z')
1430 >>> Distinct(x, y, z)
1431 Distinct(x, y, z)
1432 >>> simplify(Distinct(x, y, z))
1433 Distinct(x, y, z)
1434 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1435 And(Not(x == y), Not(x == z), Not(y == z))
1436 """
1437 args = _get_args(args)
1438 ctx = _ctx_from_ast_arg_list(args)
1439 if z3_debug():
1440 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1441 args = _coerce_expr_list(args, ctx)
1442 _args, sz = _to_ast_array(args)
1443 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1444
1445
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 11088 of file z3py.py.

11088def Empty(s):
11089 """Create the empty sequence of the given sort
11090 >>> e = Empty(StringSort())
11091 >>> e2 = StringVal("")
11092 >>> print(e.eq(e2))
11093 True
11094 >>> e3 = Empty(SeqSort(IntSort()))
11095 >>> print(e3)
11096 Empty(Seq(Int))
11097 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11098 >>> print(e4)
11099 Empty(ReSort(Seq(Int)))
11100 """
11101 if isinstance(s, SeqSortRef):
11102 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11103 if isinstance(s, ReSortRef):
11104 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11105 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11106
11107
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 4968 of file z3py.py.

4968def EmptySet(s):
4969 """Create the empty set
4970 >>> EmptySet(IntSort())
4971 K(Int, False)
4972 """
4973 ctx = s.ctx
4974 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4975
4976
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 11582 of file z3py.py.

11582def ensure_prop_closures():
11583 global _prop_closures
11584 if _prop_closures is None:
11585 _prop_closures = PropClosures()
11586
11587

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

5433def EnumSort(name, values, ctx=None):
5434 """Return a new enumeration sort named `name` containing the given values.
5435
5436 The result is a pair (sort, list of constants).
5437 Example:
5438 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5439 """
5440 if z3_debug():
5441 _z3_assert(isinstance(name, str), "Name must be a string")
5442 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
5443 _z3_assert(len(values) > 0, "At least one value expected")
5444 ctx = _get_ctx(ctx)
5445 num = len(values)
5446 _val_names = (Symbol * num)()
5447 for i in range(num):
5448 _val_names[i] = to_symbol(values[i], ctx)
5449 _values = (FuncDecl * num)()
5450 _testers = (FuncDecl * num)()
5451 name = to_symbol(name, ctx)
5452 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5453 V = []
5454 for i in range(num):
5455 V.append(FuncDeclRef(_values[i], ctx))
5456 V = [a() for a in V]
5457 return S, V
5458
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 472 of file z3py.py.

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

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

2290def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2291 """Create a Z3 exists formula.
2292
2293 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2294
2295
2296 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2297 >>> x = Int('x')
2298 >>> y = Int('y')
2299 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2300 >>> q
2301 Exists([x, y], f(x, y) >= x)
2302 >>> is_quantifier(q)
2303 True
2304 >>> r = Tactic('nnf')(q).as_expr()
2305 >>> is_quantifier(r)
2306 False
2307 """
2308 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2309
2310

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

4914def Ext(a, b):
4915 """Return extensionality index for one-dimensional arrays.
4916 >> a, b = Consts('a b', SetSort(IntSort()))
4917 >> Ext(a, b)
4918 Ext(a, b)
4919 """
4920 ctx = a.ctx
4921 if z3_debug():
4922 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4923 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4924
4925
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 4174 of file z3py.py.

4174def Extract(high, low, a):
4175 """Create a Z3 bit-vector extraction expression.
4176 Extract is overloaded to also work on sequence extraction.
4177 The functions SubString and SubSeq are redirected to Extract.
4178 For this case, the arguments are reinterpreted as:
4179 high - is a sequence (string)
4180 low - is an offset
4181 a - is the length to be extracted
4182
4183 >>> x = BitVec('x', 8)
4184 >>> Extract(6, 2, x)
4185 Extract(6, 2, x)
4186 >>> Extract(6, 2, x).sort()
4187 BitVec(5)
4188 >>> simplify(Extract(StringVal("abcd"),2,1))
4189 "c"
4190 """
4191 if isinstance(high, str):
4192 high = StringVal(high)
4193 if is_seq(high):
4194 s = high
4195 offset, length = _coerce_exprs(low, a, s.ctx)
4196 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4197 if z3_debug():
4198 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4199 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4200 "First and second arguments must be non negative integers")
4201 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4202 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4203
4204
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 8845 of file z3py.py.

8845def FailIf(p, ctx=None):
8846 """Return a tactic that fails if the probe `p` evaluates to true.
8847 Otherwise, it returns the input goal unmodified.
8848
8849 In the following example, the tactic applies 'simplify' if and only if there are
8850 more than 2 constraints in the goal.
8851
8852 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8853 >>> x, y = Ints('x y')
8854 >>> g = Goal()
8855 >>> g.add(x > 0)
8856 >>> g.add(y > 0)
8857 >>> t(g)
8858 [[x > 0, y > 0]]
8859 >>> g.add(x == y + 1)
8860 >>> t(g)
8861 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8862 """
8863 p = _to_probe(p, ctx)
8864 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8865
8866
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 7783 of file z3py.py.

7783def FiniteDomainSort(name, sz, ctx=None):
7784 """Create a named finite domain sort of a given size sz"""
7785 if not isinstance(name, Symbol):
7786 name = to_symbol(name)
7787 ctx = _get_ctx(ctx)
7788 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7789
7790
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 7853 of file z3py.py.

7853def FiniteDomainVal(val, sort, ctx=None):
7854 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7855
7856 >>> s = FiniteDomainSort('S', 256)
7857 >>> FiniteDomainVal(255, s)
7858 255
7859 >>> FiniteDomainVal('100', s)
7860 100
7861 """
7862 if z3_debug():
7863 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7864 ctx = sort.ctx
7865 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7866
7867

◆ Float128()

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

Definition at line 9573 of file z3py.py.

9573def Float128(ctx=None):
9574 """Floating-point 128-bit (quadruple) sort."""
9575 ctx = _get_ctx(ctx)
9576 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9577
9578
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 9537 of file z3py.py.

9537def Float16(ctx=None):
9538 """Floating-point 16-bit (half) sort."""
9539 ctx = _get_ctx(ctx)
9540 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9541
9542
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 9549 of file z3py.py.

9549def Float32(ctx=None):
9550 """Floating-point 32-bit (single) sort."""
9551 ctx = _get_ctx(ctx)
9552 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9553
9554
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 9561 of file z3py.py.

9561def Float64(ctx=None):
9562 """Floating-point 64-bit (double) sort."""
9563 ctx = _get_ctx(ctx)
9564 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9565
9566
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 9567 of file z3py.py.

9567def FloatDouble(ctx=None):
9568 """Floating-point 64-bit (double) sort."""
9569 ctx = _get_ctx(ctx)
9570 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9571
9572
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 9543 of file z3py.py.

9543def FloatHalf(ctx=None):
9544 """Floating-point 16-bit (half) sort."""
9545 ctx = _get_ctx(ctx)
9546 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9547
9548
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 9579 of file z3py.py.

9579def FloatQuadruple(ctx=None):
9580 """Floating-point 128-bit (quadruple) sort."""
9581 ctx = _get_ctx(ctx)
9582 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9583
9584
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 9555 of file z3py.py.

9555def FloatSingle(ctx=None):
9556 """Floating-point 32-bit (single) sort."""
9557 ctx = _get_ctx(ctx)
9558 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9559
9560
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 2272 of file z3py.py.

2272def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2273 """Create a Z3 forall formula.
2274
2275 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2276
2277 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2278 >>> x = Int('x')
2279 >>> y = Int('y')
2280 >>> ForAll([x, y], f(x, y) >= x)
2281 ForAll([x, y], f(x, y) >= x)
2282 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2283 ForAll([x, y], f(x, y) >= x)
2284 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2285 ForAll([x, y], f(x, y) >= x)
2286 """
2287 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2288
2289

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

10205def FP(name, fpsort, ctx=None):
10206 """Return a floating-point constant named `name`.
10207 `fpsort` is the floating-point sort.
10208 If `ctx=None`, then the global context is used.
10209
10210 >>> x = FP('x', FPSort(8, 24))
10211 >>> is_fp(x)
10212 True
10213 >>> x.ebits()
10214 8
10215 >>> x.sort()
10216 FPSort(8, 24)
10217 >>> word = FPSort(8, 24)
10218 >>> x2 = FP('x', word)
10219 >>> eq(x, x2)
10220 True
10221 """
10222 if isinstance(fpsort, FPSortRef) and ctx is None:
10223 ctx = fpsort.ctx
10224 else:
10225 ctx = _get_ctx(ctx)
10226 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10227
10228

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

10248def fpAbs(a, ctx=None):
10249 """Create a Z3 floating-point absolute value expression.
10250
10251 >>> s = FPSort(8, 24)
10252 >>> rm = RNE()
10253 >>> x = FPVal(1.0, s)
10254 >>> fpAbs(x)
10255 fpAbs(1)
10256 >>> y = FPVal(-20.0, s)
10257 >>> y
10258 -1.25*(2**4)
10259 >>> fpAbs(y)
10260 fpAbs(-1.25*(2**4))
10261 >>> fpAbs(-1.25*(2**4))
10262 fpAbs(-1.25*(2**4))
10263 >>> fpAbs(x).sort()
10264 FPSort(8, 24)
10265 """
10266 ctx = _get_ctx(ctx)
10267 [a] = _coerce_fp_expr_list([a], ctx)
10268 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10269
10270
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 10339 of file z3py.py.

10339def fpAdd(rm, a, b, ctx=None):
10340 """Create a Z3 floating-point addition expression.
10341
10342 >>> s = FPSort(8, 24)
10343 >>> rm = RNE()
10344 >>> x = FP('x', s)
10345 >>> y = FP('y', s)
10346 >>> fpAdd(rm, x, y)
10347 x + y
10348 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10349 fpAdd(RTZ(), x, y)
10350 >>> fpAdd(rm, x, y).sort()
10351 FPSort(8, 24)
10352 """
10353 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10354
10355

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

10661def fpBVToFP(v, sort, ctx=None):
10662 """Create a Z3 floating-point conversion expression that represents the
10663 conversion from a bit-vector term to a floating-point term.
10664
10665 >>> x_bv = BitVecVal(0x3F800000, 32)
10666 >>> x_fp = fpBVToFP(x_bv, Float32())
10667 >>> x_fp
10668 fpToFP(1065353216)
10669 >>> simplify(x_fp)
10670 1
10671 """
10672 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10673 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10674 ctx = _get_ctx(ctx)
10675 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10676
10677
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 10386 of file z3py.py.

10386def fpDiv(rm, a, b, ctx=None):
10387 """Create a Z3 floating-point division expression.
10388
10389 >>> s = FPSort(8, 24)
10390 >>> rm = RNE()
10391 >>> x = FP('x', s)
10392 >>> y = FP('y', s)
10393 >>> fpDiv(rm, x, y)
10394 x / y
10395 >>> fpDiv(rm, x, y).sort()
10396 FPSort(8, 24)
10397 """
10398 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10399
10400

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

10569def fpEQ(a, b, ctx=None):
10570 """Create the Z3 floating-point expression `fpEQ(other, self)`.
10571
10572 >>> x, y = FPs('x y', FPSort(8, 24))
10573 >>> fpEQ(x, y)
10574 fpEQ(x, y)
10575 >>> fpEQ(x, y).sexpr()
10576 '(fp.eq x y)'
10577 """
10578 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10579
10580

◆ fpFMA()

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

Definition at line 10445 of file z3py.py.

10445def fpFMA(rm, a, b, c, ctx=None):
10446 """Create a Z3 floating-point fused multiply-add expression.
10447 """
10448 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10449
10450

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

10593def fpFP(sgn, exp, sig, ctx=None):
10594 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10595
10596 >>> s = FPSort(8, 24)
10597 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10598 >>> print(x)
10599 fpFP(1, 127, 4194304)
10600 >>> xv = FPVal(-1.5, s)
10601 >>> print(xv)
10602 -1.5
10603 >>> slvr = Solver()
10604 >>> slvr.add(fpEQ(x, xv))
10605 >>> slvr.check()
10606 sat
10607 >>> xv = FPVal(+1.5, s)
10608 >>> print(xv)
10609 1.5
10610 >>> slvr = Solver()
10611 >>> slvr.add(fpEQ(x, xv))
10612 >>> slvr.check()
10613 unsat
10614 """
10615 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10616 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10617 ctx = _get_ctx(ctx)
10618 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10619 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10620
10621
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 10678 of file z3py.py.

10678def fpFPToFP(rm, v, sort, ctx=None):
10679 """Create a Z3 floating-point conversion expression that represents the
10680 conversion from a floating-point term to a floating-point term of different precision.
10681
10682 >>> x_sgl = FPVal(1.0, Float32())
10683 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10684 >>> x_dbl
10685 fpToFP(RNE(), 1)
10686 >>> simplify(x_dbl)
10687 1
10688 >>> x_dbl.sort()
10689 FPSort(11, 53)
10690 """
10691 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10692 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10693 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10694 ctx = _get_ctx(ctx)
10695 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10696
10697
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 10557 of file z3py.py.

10557def fpGEQ(a, b, ctx=None):
10558 """Create the Z3 floating-point expression `other >= self`.
10559
10560 >>> x, y = FPs('x y', FPSort(8, 24))
10561 >>> fpGEQ(x, y)
10562 x >= y
10563 >>> (x >= y).sexpr()
10564 '(fp.geq x y)'
10565 """
10566 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10567
10568

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

10545def fpGT(a, b, ctx=None):
10546 """Create the Z3 floating-point expression `other > self`.
10547
10548 >>> x, y = FPs('x y', FPSort(8, 24))
10549 >>> fpGT(x, y)
10550 x > y
10551 >>> (x > y).sexpr()
10552 '(fp.gt x y)'
10553 """
10554 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10555
10556

◆ fpInfinity()

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

Definition at line 10133 of file z3py.py.

10133def fpInfinity(s, negative):
10134 """Create a Z3 floating-point +oo or -oo term."""
10135 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10136 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10137 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10138
10139
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 10475 of file z3py.py.

10475def fpIsInf(a, ctx=None):
10476 """Create a Z3 floating-point isInfinite expression.
10477
10478 >>> s = FPSort(8, 24)
10479 >>> x = FP('x', s)
10480 >>> fpIsInf(x)
10481 fpIsInf(x)
10482 """
10483 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10484
10485

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

10463def fpIsNaN(a, ctx=None):
10464 """Create a Z3 floating-point isNaN expression.
10465
10466 >>> s = FPSort(8, 24)
10467 >>> x = FP('x', s)
10468 >>> y = FP('y', s)
10469 >>> fpIsNaN(x)
10470 fpIsNaN(x)
10471 """
10472 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10473
10474

◆ fpIsNegative()

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

Definition at line 10504 of file z3py.py.

10504def fpIsNegative(a, ctx=None):
10505 """Create a Z3 floating-point isNegative expression.
10506 """
10507 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10508
10509

◆ fpIsNormal()

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

Definition at line 10492 of file z3py.py.

10492def fpIsNormal(a, ctx=None):
10493 """Create a Z3 floating-point isNormal expression.
10494 """
10495 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10496
10497

◆ fpIsPositive()

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

Definition at line 10510 of file z3py.py.

10510def fpIsPositive(a, ctx=None):
10511 """Create a Z3 floating-point isPositive expression.
10512 """
10513 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10514
10515

◆ fpIsSubnormal()

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

Definition at line 10498 of file z3py.py.

10498def fpIsSubnormal(a, ctx=None):
10499 """Create a Z3 floating-point isSubnormal expression.
10500 """
10501 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10502
10503

◆ fpIsZero()

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

Definition at line 10486 of file z3py.py.

10486def fpIsZero(a, ctx=None):
10487 """Create a Z3 floating-point isZero expression.
10488 """
10489 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10490
10491

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

10533def fpLEQ(a, b, ctx=None):
10534 """Create the Z3 floating-point expression `other <= self`.
10535
10536 >>> x, y = FPs('x y', FPSort(8, 24))
10537 >>> fpLEQ(x, y)
10538 x <= y
10539 >>> (x <= y).sexpr()
10540 '(fp.leq x y)'
10541 """
10542 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10543
10544

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

10521def fpLT(a, b, ctx=None):
10522 """Create the Z3 floating-point expression `other < self`.
10523
10524 >>> x, y = FPs('x y', FPSort(8, 24))
10525 >>> fpLT(x, y)
10526 x < y
10527 >>> (x < y).sexpr()
10528 '(fp.lt x y)'
10529 """
10530 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10531
10532

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

10430def fpMax(a, b, ctx=None):
10431 """Create a Z3 floating-point maximum expression.
10432
10433 >>> s = FPSort(8, 24)
10434 >>> rm = RNE()
10435 >>> x = FP('x', s)
10436 >>> y = FP('y', s)
10437 >>> fpMax(x, y)
10438 fpMax(x, y)
10439 >>> fpMax(x, y).sort()
10440 FPSort(8, 24)
10441 """
10442 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10443
10444

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

10415def fpMin(a, b, ctx=None):
10416 """Create a Z3 floating-point minimum expression.
10417
10418 >>> s = FPSort(8, 24)
10419 >>> rm = RNE()
10420 >>> x = FP('x', s)
10421 >>> y = FP('y', s)
10422 >>> fpMin(x, y)
10423 fpMin(x, y)
10424 >>> fpMin(x, y).sort()
10425 FPSort(8, 24)
10426 """
10427 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10428
10429

◆ fpMinusInfinity()

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

Definition at line 10127 of file z3py.py.

10127def fpMinusInfinity(s):
10128 """Create a Z3 floating-point -oo term."""
10129 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10130 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10131
10132

◆ fpMinusZero()

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

Definition at line 10146 of file z3py.py.

10146def fpMinusZero(s):
10147 """Create a Z3 floating-point -0.0 term."""
10148 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10149 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10150
10151
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 10371 of file z3py.py.

10371def fpMul(rm, a, b, ctx=None):
10372 """Create a Z3 floating-point multiplication expression.
10373
10374 >>> s = FPSort(8, 24)
10375 >>> rm = RNE()
10376 >>> x = FP('x', s)
10377 >>> y = FP('y', s)
10378 >>> fpMul(rm, x, y)
10379 x * y
10380 >>> fpMul(rm, x, y).sort()
10381 FPSort(8, 24)
10382 """
10383 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10384
10385

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

10093def fpNaN(s):
10094 """Create a Z3 floating-point NaN term.
10095
10096 >>> s = FPSort(8, 24)
10097 >>> set_fpa_pretty(True)
10098 >>> fpNaN(s)
10099 NaN
10100 >>> pb = get_fpa_pretty()
10101 >>> set_fpa_pretty(False)
10102 >>> fpNaN(s)
10103 fpNaN(FPSort(8, 24))
10104 >>> set_fpa_pretty(pb)
10105 """
10106 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10107 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10108
10109
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 10271 of file z3py.py.

10271def fpNeg(a, ctx=None):
10272 """Create a Z3 floating-point addition expression.
10273
10274 >>> s = FPSort(8, 24)
10275 >>> rm = RNE()
10276 >>> x = FP('x', s)
10277 >>> fpNeg(x)
10278 -x
10279 >>> fpNeg(x).sort()
10280 FPSort(8, 24)
10281 """
10282 ctx = _get_ctx(ctx)
10283 [a] = _coerce_fp_expr_list([a], ctx)
10284 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10285
10286
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 10581 of file z3py.py.

10581def fpNEQ(a, b, ctx=None):
10582 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10583
10584 >>> x, y = FPs('x y', FPSort(8, 24))
10585 >>> fpNEQ(x, y)
10586 Not(fpEQ(x, y))
10587 >>> (x != y).sexpr()
10588 '(distinct x y)'
10589 """
10590 return Not(fpEQ(a, b, ctx))
10591
10592

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

10110def fpPlusInfinity(s):
10111 """Create a Z3 floating-point +oo term.
10112
10113 >>> s = FPSort(8, 24)
10114 >>> pb = get_fpa_pretty()
10115 >>> set_fpa_pretty(True)
10116 >>> fpPlusInfinity(s)
10117 +oo
10118 >>> set_fpa_pretty(False)
10119 >>> fpPlusInfinity(s)
10120 fpPlusInfinity(FPSort(8, 24))
10121 >>> set_fpa_pretty(pb)
10122 """
10123 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10124 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10125
10126

◆ fpPlusZero()

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

Definition at line 10140 of file z3py.py.

10140def fpPlusZero(s):
10141 """Create a Z3 floating-point +0.0 term."""
10142 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10143 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10144
10145

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

10698def fpRealToFP(rm, v, sort, ctx=None):
10699 """Create a Z3 floating-point conversion expression that represents the
10700 conversion from a real term to a floating-point term.
10701
10702 >>> x_r = RealVal(1.5)
10703 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10704 >>> x_fp
10705 fpToFP(RNE(), 3/2)
10706 >>> simplify(x_fp)
10707 1.5
10708 """
10709 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10710 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10711 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10712 ctx = _get_ctx(ctx)
10713 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10714
10715
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 10401 of file z3py.py.

10401def fpRem(a, b, ctx=None):
10402 """Create a Z3 floating-point remainder expression.
10403
10404 >>> s = FPSort(8, 24)
10405 >>> x = FP('x', s)
10406 >>> y = FP('y', s)
10407 >>> fpRem(x, y)
10408 fpRem(x, y)
10409 >>> fpRem(x, y).sort()
10410 FPSort(8, 24)
10411 """
10412 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10413
10414

◆ fpRoundToIntegral()

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

Definition at line 10457 of file z3py.py.

10457def fpRoundToIntegral(rm, a, ctx=None):
10458 """Create a Z3 floating-point roundToIntegral expression.
10459 """
10460 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10461
10462

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

10229def FPs(names, fpsort, ctx=None):
10230 """Return an array of floating-point constants.
10231
10232 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10233 >>> x.sort()
10234 FPSort(8, 24)
10235 >>> x.sbits()
10236 24
10237 >>> x.ebits()
10238 8
10239 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10240 (x + y) * z
10241 """
10242 ctx = _get_ctx(ctx)
10243 if isinstance(names, str):
10244 names = names.split(" ")
10245 return [FP(name, fpsort, ctx) for name in names]
10246
10247

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

10716def fpSignedToFP(rm, v, sort, ctx=None):
10717 """Create a Z3 floating-point conversion expression that represents the
10718 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10719
10720 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10721 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10722 >>> x_fp
10723 fpToFP(RNE(), 4294967291)
10724 >>> simplify(x_fp)
10725 -1.25*(2**2)
10726 """
10727 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10728 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10729 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10730 ctx = _get_ctx(ctx)
10731 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10732
10733
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 10034 of file z3py.py.

10034def FPSort(ebits, sbits, ctx=None):
10035 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10036
10037 >>> Single = FPSort(8, 24)
10038 >>> Double = FPSort(11, 53)
10039 >>> Single
10040 FPSort(8, 24)
10041 >>> x = Const('x', Single)
10042 >>> eq(x, FP('x', FPSort(8, 24)))
10043 True
10044 """
10045 ctx = _get_ctx(ctx)
10046 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
10047
10048
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 10451 of file z3py.py.

10451def fpSqrt(rm, a, ctx=None):
10452 """Create a Z3 floating-point square root expression.
10453 """
10454 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10455
10456

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

10356def fpSub(rm, a, b, ctx=None):
10357 """Create a Z3 floating-point subtraction expression.
10358
10359 >>> s = FPSort(8, 24)
10360 >>> rm = RNE()
10361 >>> x = FP('x', s)
10362 >>> y = FP('y', s)
10363 >>> fpSub(rm, x, y)
10364 x - y
10365 >>> fpSub(rm, x, y).sort()
10366 FPSort(8, 24)
10367 """
10368 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10369
10370

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

10622def fpToFP(a1, a2=None, a3=None, ctx=None):
10623 """Create a Z3 floating-point conversion expression from other term sorts
10624 to floating-point.
10625
10626 From a bit-vector term in IEEE 754-2008 format:
10627 >>> x = FPVal(1.0, Float32())
10628 >>> x_bv = fpToIEEEBV(x)
10629 >>> simplify(fpToFP(x_bv, Float32()))
10630 1
10631
10632 From a floating-point term with different precision:
10633 >>> x = FPVal(1.0, Float32())
10634 >>> x_db = fpToFP(RNE(), x, Float64())
10635 >>> x_db.sort()
10636 FPSort(11, 53)
10637
10638 From a real term:
10639 >>> x_r = RealVal(1.5)
10640 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10641 1.5
10642
10643 From a signed bit-vector term:
10644 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10645 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10646 -1.25*(2**2)
10647 """
10648 ctx = _get_ctx(ctx)
10649 if is_bv(a1) and is_fp_sort(a2):
10650 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10651 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10652 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10653 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10654 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10655 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10656 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10657 else:
10658 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10659
10660

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

10752def fpToFPUnsigned(rm, x, s, ctx=None):
10753 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10754 if z3_debug():
10755 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10756 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10757 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10758 ctx = _get_ctx(ctx)
10759 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10760
10761
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 10826 of file z3py.py.

10826def fpToIEEEBV(x, ctx=None):
10827 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10828
10829 The size of the resulting bit-vector is automatically determined.
10830
10831 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10832 knows only one NaN and it will always produce the same bit-vector representation of
10833 that NaN.
10834
10835 >>> x = FP('x', FPSort(8, 24))
10836 >>> y = fpToIEEEBV(x)
10837 >>> print(is_fp(x))
10838 True
10839 >>> print(is_bv(y))
10840 True
10841 >>> print(is_fp(y))
10842 False
10843 >>> print(is_bv(x))
10844 False
10845 """
10846 if z3_debug():
10847 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10848 ctx = _get_ctx(ctx)
10849 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10850
10851
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 10806 of file z3py.py.

10806def fpToReal(x, ctx=None):
10807 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10808
10809 >>> x = FP('x', FPSort(8, 24))
10810 >>> y = fpToReal(x)
10811 >>> print(is_fp(x))
10812 True
10813 >>> print(is_real(y))
10814 True
10815 >>> print(is_fp(y))
10816 False
10817 >>> print(is_real(x))
10818 False
10819 """
10820 if z3_debug():
10821 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10822 ctx = _get_ctx(ctx)
10823 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10824
10825
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 10762 of file z3py.py.

10762def fpToSBV(rm, x, s, ctx=None):
10763 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10764
10765 >>> x = FP('x', FPSort(8, 24))
10766 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10767 >>> print(is_fp(x))
10768 True
10769 >>> print(is_bv(y))
10770 True
10771 >>> print(is_fp(y))
10772 False
10773 >>> print(is_bv(x))
10774 False
10775 """
10776 if z3_debug():
10777 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10778 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10779 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10780 ctx = _get_ctx(ctx)
10781 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10782
10783
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 10784 of file z3py.py.

10784def fpToUBV(rm, x, s, ctx=None):
10785 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10786
10787 >>> x = FP('x', FPSort(8, 24))
10788 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10789 >>> print(is_fp(x))
10790 True
10791 >>> print(is_bv(y))
10792 True
10793 >>> print(is_fp(y))
10794 False
10795 >>> print(is_bv(x))
10796 False
10797 """
10798 if z3_debug():
10799 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10800 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10801 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10802 ctx = _get_ctx(ctx)
10803 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10804
10805
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 10734 of file z3py.py.

10734def fpUnsignedToFP(rm, v, sort, ctx=None):
10735 """Create a Z3 floating-point conversion expression that represents the
10736 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10737
10738 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10739 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10740 >>> x_fp
10741 fpToFPUnsigned(RNE(), 4294967291)
10742 >>> simplify(x_fp)
10743 1*(2**32)
10744 """
10745 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10746 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10747 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10748 ctx = _get_ctx(ctx)
10749 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10750
10751

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

10159def FPVal(sig, exp=None, fps=None, ctx=None):
10160 """Return a floating-point value of value `val` and sort `fps`.
10161 If `ctx=None`, then the global context is used.
10162
10163 >>> v = FPVal(20.0, FPSort(8, 24))
10164 >>> v
10165 1.25*(2**4)
10166 >>> print("0x%.8x" % v.exponent_as_long(False))
10167 0x00000004
10168 >>> v = FPVal(2.25, FPSort(8, 24))
10169 >>> v
10170 1.125*(2**1)
10171 >>> v = FPVal(-2.25, FPSort(8, 24))
10172 >>> v
10173 -1.125*(2**1)
10174 >>> FPVal(-0.0, FPSort(8, 24))
10175 -0.0
10176 >>> FPVal(0.0, FPSort(8, 24))
10177 +0.0
10178 >>> FPVal(+0.0, FPSort(8, 24))
10179 +0.0
10180 """
10181 ctx = _get_ctx(ctx)
10182 if is_fp_sort(exp):
10183 fps = exp
10184 exp = None
10185 elif fps is None:
10186 fps = _dflt_fps(ctx)
10187 _z3_assert(is_fp_sort(fps), "sort mismatch")
10188 if exp is None:
10189 exp = 0
10190 val = _to_float_str(sig)
10191 if val == "NaN" or val == "nan":
10192 return fpNaN(fps)
10193 elif val == "-0.0":
10194 return fpMinusZero(fps)
10195 elif val == "0.0" or val == "+0.0":
10196 return fpPlusZero(fps)
10197 elif val == "+oo" or val == "+inf" or val == "+Inf":
10198 return fpPlusInfinity(fps)
10199 elif val == "-oo" or val == "-inf" or val == "-Inf":
10200 return fpMinusInfinity(fps)
10201 else:
10202 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10203
10204

◆ fpZero()

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

Definition at line 10152 of file z3py.py.

10152def fpZero(s, negative):
10153 """Create a Z3 floating-point +0.0 or -0.0 term."""
10154 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10155 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10156 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10157
10158

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

1811def FreshBool(prefix="b", ctx=None):
1812 """Return a fresh Boolean constant in the given context using the given prefix.
1813
1814 If `ctx=None`, then the global context is used.
1815
1816 >>> b1 = FreshBool()
1817 >>> b2 = FreshBool()
1818 >>> eq(b1, b2)
1819 False
1820 """
1821 ctx = _get_ctx(ctx)
1822 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1823
1824
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 1482 of file z3py.py.

1482def FreshConst(sort, prefix="c"):
1483 """Create a fresh constant of a specified sort"""
1484 ctx = _get_ctx(sort.ctx)
1485 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1486
1487

◆ FreshFunction()

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

Definition at line 904 of file z3py.py.

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

3333def FreshInt(prefix="x", ctx=None):
3334 """Return a fresh integer constant in the given context using the given prefix.
3335
3336 >>> x = FreshInt()
3337 >>> y = FreshInt()
3338 >>> eq(x, y)
3339 False
3340 >>> x.sort()
3341 Int
3342 """
3343 ctx = _get_ctx(ctx)
3344 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3345
3346

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

3390def FreshReal(prefix="b", ctx=None):
3391 """Return a fresh real constant in the given context using the given prefix.
3392
3393 >>> x = FreshReal()
3394 >>> y = FreshReal()
3395 >>> eq(x, y)
3396 False
3397 >>> x.sort()
3398 Real
3399 """
3400 ctx = _get_ctx(ctx)
3401 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3402
3403

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

11108def Full(s):
11109 """Create the regular expression that accepts the universal language
11110 >>> e = Full(ReSort(SeqSort(IntSort())))
11111 >>> print(e)
11112 Full(ReSort(Seq(Int)))
11113 >>> e1 = Full(ReSort(StringSort()))
11114 >>> print(e1)
11115 Full(ReSort(String))
11116 """
11117 if isinstance(s, ReSortRef):
11118 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11119 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11120
11121
11122
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 4977 of file z3py.py.

4977def FullSet(s):
4978 """Create the full set
4979 >>> FullSet(IntSort())
4980 K(Int, True)
4981 """
4982 ctx = s.ctx
4983 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4984
4985
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 881 of file z3py.py.

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

6745def get_as_array_func(n):
6746 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6747 if z3_debug():
6748 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6749 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6750
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 9456 of file z3py.py.

9456def get_default_fp_sort(ctx=None):
9457 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9458
9459

◆ get_default_rounding_mode()

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

Definition at line 9423 of file z3py.py.

9423def get_default_rounding_mode(ctx=None):
9424 """Retrieves the global default rounding mode."""
9425 global _dflt_rounding_mode
9426 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9427 return RTZ(ctx)
9428 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9429 return RTN(ctx)
9430 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9431 return RTP(ctx)
9432 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9433 return RNE(ctx)
9434 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9435 return RNA(ctx)
9436
9437

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

4722def get_map_func(a):
4723 """Return the function declaration associated with a Z3 map array expression.
4724
4725 >>> f = Function('f', IntSort(), IntSort())
4726 >>> b = Array('b', IntSort(), IntSort())
4727 >>> a = Map(f, b)
4728 >>> eq(f, get_map_func(a))
4729 True
4730 >>> get_map_func(a)
4731 f
4732 >>> get_map_func(a)(0)
4733 f(0)
4734 """
4735 if z3_debug():
4736 _z3_assert(is_map(a), "Z3 array map expression expected.")
4737 return FuncDeclRef(
4739 a.ctx_ref(),
4740 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4741 ),
4742 ctx=a.ctx,
4743 )
4744
4745
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 1353 of file z3py.py.

1353def get_var_index(a):
1354 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1355
1356 >>> x = Int('x')
1357 >>> y = Int('y')
1358 >>> is_var(x)
1359 False
1360 >>> is_const(x)
1361 True
1362 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1363 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1364 >>> q = ForAll([x, y], f(x, y) == x + y)
1365 >>> q.body()
1366 f(Var(1), Var(0)) == Var(1) + Var(0)
1367 >>> b = q.body()
1368 >>> b.arg(0)
1369 f(Var(1), Var(0))
1370 >>> v1 = b.arg(0).arg(0)
1371 >>> v2 = b.arg(0).arg(1)
1372 >>> v1
1373 Var(1)
1374 >>> v2
1375 Var(0)
1376 >>> get_var_index(v1)
1377 1
1378 >>> get_var_index(v2)
1379 0
1380 """
1381 if z3_debug():
1382 _z3_assert(is_var(a), "Z3 bound variable expected")
1383 return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1384
1385
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 8929 of file z3py.py.

8929def help_simplify():
8930 """Return a string describing all options available for Z3 `simplify` procedure."""
8931 print(Z3_simplify_get_help(main_ctx().ref()))
8932
8933
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 1399 of file z3py.py.

1399def If(a, b, c, ctx=None):
1400 """Create a Z3 if-then-else expression.
1401
1402 >>> x = Int('x')
1403 >>> y = Int('y')
1404 >>> max = If(x > y, x, y)
1405 >>> max
1406 If(x > y, x, y)
1407 >>> simplify(max)
1408 If(x <= y, y, x)
1409 """
1410 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1411 return Cond(a, b, c, ctx)
1412 else:
1413 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1414 s = BoolSort(ctx)
1415 a = s.cast(a)
1416 b, c = _coerce_exprs(b, c, ctx)
1417 if z3_debug():
1418 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1419 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1420
1421
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__(), and BoolRef.__mul__().

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

1825def Implies(a, b, ctx=None):
1826 """Create a Z3 implies expression.
1827
1828 >>> p, q = Bools('p q')
1829 >>> Implies(p, q)
1830 Implies(p, q)
1831 """
1832 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1833 s = BoolSort(ctx)
1834 a = s.cast(a)
1835 b = s.cast(b)
1836 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1837
1838
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 11192 of file z3py.py.

11192def IndexOf(s, substr, offset=None):
11193 """Retrieve the index of substring within a string starting at a specified offset.
11194 >>> simplify(IndexOf("abcabc", "bc", 0))
11195 1
11196 >>> simplify(IndexOf("abcabc", "bc", 2))
11197 4
11198 """
11199 if offset is None:
11200 offset = IntVal(0)
11201 ctx = None
11202 if is_expr(offset):
11203 ctx = offset.ctx
11204 ctx = _get_ctx2(s, substr, ctx)
11205 s = _coerce_seq(s, ctx)
11206 substr = _coerce_seq(substr, ctx)
11207 if _is_int(offset):
11208 offset = IntVal(offset, ctx)
11209 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11210
11211
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 11331 of file z3py.py.

11331def InRe(s, re):
11332 """Create regular expression membership test
11333 >>> re = Union(Re("a"),Re("b"))
11334 >>> print (simplify(InRe("a", re)))
11335 True
11336 >>> print (simplify(InRe("b", re)))
11337 True
11338 >>> print (simplify(InRe("c", re)))
11339 False
11340 """
11341 s = _coerce_seq(s, re.ctx)
11342 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11343
11344
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 3294 of file z3py.py.

3294def Int(name, ctx=None):
3295 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3296
3297 >>> x = Int('x')
3298 >>> is_int(x)
3299 True
3300 >>> is_int(x + 1)
3301 True
3302 """
3303 ctx = _get_ctx(ctx)
3304 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3305
3306

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

4042def Int2BV(a, num_bits):
4043 """Return the z3 expression Int2BV(a, num_bits).
4044 It is a bit-vector of width num_bits and represents the
4045 modulo of a by 2^num_bits
4046 """
4047 ctx = a.ctx
4048 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4049
4050
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 11365 of file z3py.py.

11365def Intersect(*args):
11366 """Create intersection of regular expressions.
11367 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11368 """
11369 args = _get_args(args)
11370 sz = len(args)
11371 if z3_debug():
11372 _z3_assert(sz > 0, "At least one argument expected.")
11373 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11374 if sz == 1:
11375 return args[0]
11376 ctx = args[0].ctx
11377 v = (Ast * sz)()
11378 for i in range(sz):
11379 v[i] = args[i].as_ast()
11380 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11381
11382
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 3307 of file z3py.py.

3307def Ints(names, ctx=None):
3308 """Return a tuple of Integer constants.
3309
3310 >>> x, y, z = Ints('x y z')
3311 >>> Sum(x, y, z)
3312 x + y + z
3313 """
3314 ctx = _get_ctx(ctx)
3315 if isinstance(names, str):
3316 names = names.split(" ")
3317 return [Int(name, ctx) for name in names]
3318
3319

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

3188def IntSort(ctx=None):
3189 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3190
3191 >>> IntSort()
3192 Int
3193 >>> x = Const('x', IntSort())
3194 >>> is_int(x)
3195 True
3196 >>> x.sort() == IntSort()
3197 True
3198 >>> x.sort() == BoolSort()
3199 False
3200 """
3201 ctx = _get_ctx(ctx)
3202 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3203
3204
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 11273 of file z3py.py.

11273def IntToStr(s):
11274 """Convert integer expression to string"""
11275 if not is_expr(s):
11276 s = _py2expr(s)
11277 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11278
11279
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 3234 of file z3py.py.

3234def IntVal(val, ctx=None):
3235 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3236
3237 >>> IntVal(1)
3238 1
3239 >>> IntVal("100")
3240 100
3241 """
3242 ctx = _get_ctx(ctx)
3243 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3244
3245

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

3320def IntVector(prefix, sz, ctx=None):
3321 """Return a list of integer constants of size `sz`.
3322
3323 >>> X = IntVector('x', 3)
3324 >>> X
3325 [x__0, x__1, x__2]
3326 >>> Sum(X)
3327 x__0 + x__1 + x__2
3328 """
3329 ctx = _get_ctx(ctx)
3330 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3331
3332

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

2842def is_add(a):
2843 """Return `True` if `a` is an expression of the form b + c.
2844
2845 >>> x, y = Ints('x y')
2846 >>> is_add(x + y)
2847 True
2848 >>> is_add(x - y)
2849 False
2850 """
2851 return is_app_of(a, Z3_OP_ADD)
2852
2853

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

2828def is_algebraic_value(a):
2829 """Return `True` if `a` is an algebraic value of sort Real.
2830
2831 >>> is_algebraic_value(RealVal("3/5"))
2832 False
2833 >>> n = simplify(Sqrt(2))
2834 >>> n
2835 1.4142135623?
2836 >>> is_algebraic_value(n)
2837 True
2838 """
2839 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2840
2841

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

1661def is_and(a):
1662 """Return `True` if `a` is a Z3 and expression.
1663
1664 >>> p, q = Bools('p q')
1665 >>> is_and(And(p, q))
1666 True
1667 >>> is_and(Or(p, q))
1668 False
1669 """
1670 return is_app_of(a, Z3_OP_AND)
1671
1672

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

1283def is_app(a):
1284 """Return `True` if `a` is a Z3 function application.
1285
1286 Note that, constants are function applications with 0 arguments.
1287
1288 >>> a = Int('a')
1289 >>> is_app(a)
1290 True
1291 >>> is_app(a + 1)
1292 True
1293 >>> is_app(IntSort())
1294 False
1295 >>> is_app(1)
1296 False
1297 >>> is_app(IntVal(1))
1298 True
1299 >>> x = Int('x')
1300 >>> is_app(ForAll(x, x >= 0))
1301 False
1302 """
1303 if not isinstance(a, ExprRef):
1304 return False
1305 k = _ast_kind(a.ctx, a)
1306 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1307
1308

Referenced by _mk_quantifier(), ExprRef.arg(), ExprRef.children(), ExprRef.decl(), is_app_of(), is_const(), 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 1386 of file z3py.py.

1386def is_app_of(a, k):
1387 """Return `True` if `a` is an application of the given kind `k`.
1388
1389 >>> x = Int('x')
1390 >>> n = x + 1
1391 >>> is_app_of(n, Z3_OP_ADD)
1392 True
1393 >>> is_app_of(n, Z3_OP_MUL)
1394 False
1395 """
1396 return is_app(a) and a.decl().kind() == k
1397
1398

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

2715def is_arith(a):
2716 """Return `True` if `a` is an arithmetical expression.
2717
2718 >>> x = Int('x')
2719 >>> is_arith(x)
2720 True
2721 >>> is_arith(x + 1)
2722 True
2723 >>> is_arith(1)
2724 False
2725 >>> is_arith(IntVal(1))
2726 True
2727 >>> y = Real('y')
2728 >>> is_arith(y)
2729 True
2730 >>> is_arith(y + 1)
2731 True
2732 """
2733 return isinstance(a, ArithRef)
2734
2735

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

2414def is_arith_sort(s):
2415 """Return `True` if s is an arithmetical sort (type).
2416
2417 >>> is_arith_sort(IntSort())
2418 True
2419 >>> is_arith_sort(RealSort())
2420 True
2421 >>> is_arith_sort(BoolSort())
2422 False
2423 >>> n = Int('x') + 1
2424 >>> is_arith_sort(n.sort())
2425 True
2426 """
2427 return isinstance(s, ArithSortRef)
2428
2429

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

4657def is_array(a):
4658 """Return `True` if `a` is a Z3 array expression.
4659
4660 >>> a = Array('a', IntSort(), IntSort())
4661 >>> is_array(a)
4662 True
4663 >>> is_array(Store(a, 0, 1))
4664 True
4665 >>> is_array(a[0])
4666 False
4667 """
4668 return isinstance(a, ArrayRef)
4669
4670

Referenced by Ext(), and Map().

◆ is_array_sort()

is_array_sort ( a)

Definition at line 4653 of file z3py.py.

4653def is_array_sort(a):
4654 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4655
4656

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

6740def is_as_array(n):
6741 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6742 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6743
6744
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 451 of file z3py.py.

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

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

1611def is_bool(a):
1612 """Return `True` if `a` is a Z3 Boolean expression.
1613
1614 >>> p = Bool('p')
1615 >>> is_bool(p)
1616 True
1617 >>> q = Bool('q')
1618 >>> is_bool(And(p, q))
1619 True
1620 >>> x = Real('x')
1621 >>> is_bool(x)
1622 False
1623 >>> is_bool(x == 0)
1624 True
1625 """
1626 return isinstance(a, BoolRef)
1627
1628

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

3990def is_bv(a):
3991 """Return `True` if `a` is a Z3 bit-vector expression.
3992
3993 >>> b = BitVec('b', 32)
3994 >>> is_bv(b)
3995 True
3996 >>> is_bv(b + 10)
3997 True
3998 >>> is_bv(Int('x'))
3999 False
4000 """
4001 return isinstance(a, BitVecRef)
4002
4003

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

3522def is_bv_sort(s):
3523 """Return True if `s` is a Z3 bit-vector sort.
3524
3525 >>> is_bv_sort(BitVecSort(32))
3526 True
3527 >>> is_bv_sort(IntSort())
3528 False
3529 """
3530 return isinstance(s, BitVecSortRef)
3531
3532

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

4004def is_bv_value(a):
4005 """Return `True` if `a` is a Z3 bit-vector numeral value.
4006
4007 >>> b = BitVec('b', 32)
4008 >>> is_bv_value(b)
4009 False
4010 >>> b = BitVecVal(10, 32)
4011 >>> b
4012 10
4013 >>> is_bv_value(b)
4014 True
4015 """
4016 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4017
4018

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

1309def is_const(a):
1310 """Return `True` if `a` is Z3 constant/variable expression.
1311
1312 >>> a = Int('a')
1313 >>> is_const(a)
1314 True
1315 >>> is_const(a + 1)
1316 False
1317 >>> is_const(1)
1318 False
1319 >>> is_const(IntVal(1))
1320 True
1321 >>> x = Int('x')
1322 >>> is_const(ForAll(x, x >= 0))
1323 False
1324 """
1325 return is_app(a) and a.num_args() == 0
1326
1327

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

4671def is_const_array(a):
4672 """Return `True` if `a` is a Z3 constant array.
4673
4674 >>> a = K(IntSort(), 10)
4675 >>> is_const_array(a)
4676 True
4677 >>> a = Array('a', IntSort(), IntSort())
4678 >>> is_const_array(a)
4679 False
4680 """
4681 return is_app_of(a, Z3_OP_CONST_ARRAY)
4682
4683

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

4713def is_default(a):
4714 """Return `True` if `a` is a Z3 default array expression.
4715 >>> d = Default(K(IntSort(), 10))
4716 >>> is_default(d)
4717 True
4718 """
4719 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4720
4721

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

1719def is_distinct(a):
1720 """Return `True` if `a` is a Z3 distinct expression.
1721
1722 >>> x, y, z = Ints('x y z')
1723 >>> is_distinct(x == y)
1724 False
1725 >>> is_distinct(Distinct(x, y, z))
1726 True
1727 """
1728 return is_app_of(a, Z3_OP_DISTINCT)
1729
1730

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

2878def is_div(a):
2879 """Return `True` if `a` is an expression of the form b / c.
2880
2881 >>> x, y = Reals('x y')
2882 >>> is_div(x / y)
2883 True
2884 >>> is_div(x + y)
2885 False
2886 >>> x, y = Ints('x y')
2887 >>> is_div(x / y)
2888 False
2889 >>> is_idiv(x / y)
2890 True
2891 """
2892 return is_app_of(a, Z3_OP_DIV)
2893
2894

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

1709def is_eq(a):
1710 """Return `True` if `a` is a Z3 equality expression.
1711
1712 >>> x, y = Ints('x y')
1713 >>> is_eq(x == y)
1714 True
1715 """
1716 return is_app_of(a, Z3_OP_EQ)
1717
1718

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

1260def is_expr(a):
1261 """Return `True` if `a` is a Z3 expression.
1262
1263 >>> a = Int('a')
1264 >>> is_expr(a)
1265 True
1266 >>> is_expr(a + 1)
1267 True
1268 >>> is_expr(IntSort())
1269 False
1270 >>> is_expr(1)
1271 False
1272 >>> is_expr(IntVal(1))
1273 True
1274 >>> x = Int('x')
1275 >>> is_expr(ForAll(x, x >= 0))
1276 True
1277 >>> is_expr(FPVal(1.0))
1278 True
1279 """
1280 return isinstance(a, ExprRef)
1281
1282

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

1647def is_false(a):
1648 """Return `True` if `a` is the Z3 false expression.
1649
1650 >>> p = Bool('p')
1651 >>> is_false(p)
1652 False
1653 >>> is_false(False)
1654 False
1655 >>> is_false(BoolVal(False))
1656 True
1657 """
1658 return is_app_of(a, Z3_OP_FALSE)
1659
1660

Referenced by AstRef.__bool__().

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

7814def is_finite_domain(a):
7815 """Return `True` if `a` is a Z3 finite-domain expression.
7816
7817 >>> s = FiniteDomainSort('S', 100)
7818 >>> b = Const('b', s)
7819 >>> is_finite_domain(b)
7820 True
7821 >>> is_finite_domain(Int('x'))
7822 False
7823 """
7824 return isinstance(a, FiniteDomainRef)
7825
7826

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

7791def is_finite_domain_sort(s):
7792 """Return True if `s` is a Z3 finite-domain sort.
7793
7794 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7795 True
7796 >>> is_finite_domain_sort(IntSort())
7797 False
7798 """
7799 return isinstance(s, FiniteDomainSortRef)
7800
7801

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

7868def is_finite_domain_value(a):
7869 """Return `True` if `a` is a Z3 finite-domain value.
7870
7871 >>> s = FiniteDomainSort('S', 100)
7872 >>> b = Const('b', s)
7873 >>> is_finite_domain_value(b)
7874 False
7875 >>> b = FiniteDomainVal(10, s)
7876 >>> b
7877 10
7878 >>> is_finite_domain_value(b)
7879 True
7880 """
7881 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7882
7883

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

10005def is_fp(a):
10006 """Return `True` if `a` is a Z3 floating-point expression.
10007
10008 >>> b = FP('b', FPSort(8, 24))
10009 >>> is_fp(b)
10010 True
10011 >>> is_fp(b + 1.0)
10012 True
10013 >>> is_fp(Int('x'))
10014 False
10015 """
10016 return isinstance(a, FPRef)
10017
10018

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

9589def is_fp_sort(s):
9590 """Return True if `s` is a Z3 floating-point sort.
9591
9592 >>> is_fp_sort(FPSort(8, 24))
9593 True
9594 >>> is_fp_sort(IntSort())
9595 False
9596 """
9597 return isinstance(s, FPSortRef)
9598
9599

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

10019def is_fp_value(a):
10020 """Return `True` if `a` is a Z3 floating-point numeral value.
10021
10022 >>> b = FP('b', FPSort(8, 24))
10023 >>> is_fp_value(b)
10024 False
10025 >>> b = FPVal(1.0, FPSort(8, 24))
10026 >>> b
10027 1
10028 >>> is_fp_value(b)
10029 True
10030 """
10031 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10032
10033

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

9849def is_fprm(a):
9850 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9851
9852 >>> rm = RNE()
9853 >>> is_fprm(rm)
9854 True
9855 >>> rm = 1.0
9856 >>> is_fprm(rm)
9857 False
9858 """
9859 return isinstance(a, FPRMRef)
9860
9861

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

9600def is_fprm_sort(s):
9601 """Return True if `s` is a Z3 floating-point rounding mode sort.
9602
9603 >>> is_fprm_sort(FPSort(8, 24))
9604 False
9605 >>> is_fprm_sort(RNE().sort())
9606 True
9607 """
9608 return isinstance(s, FPRMSortRef)
9609
9610# FP Expressions
9611
9612

◆ is_fprm_value()

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

Definition at line 9862 of file z3py.py.

9862def is_fprm_value(a):
9863 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9864 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9865
9866# FP Numerals
9867
9868

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

868def is_func_decl(a):
869 """Return `True` if `a` is a Z3 function declaration.
870
871 >>> f = Function('f', IntSort(), IntSort())
872 >>> is_func_decl(f)
873 True
874 >>> x = Real('x')
875 >>> is_func_decl(x)
876 False
877 """
878 return isinstance(a, FuncDeclRef)
879
880

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

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

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

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

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

2895def is_idiv(a):
2896 """Return `True` if `a` is an expression of the form b div c.
2897
2898 >>> x, y = Ints('x y')
2899 >>> is_idiv(x / y)
2900 True
2901 >>> is_idiv(x + y)
2902 False
2903 """
2904 return is_app_of(a, Z3_OP_IDIV)
2905
2906

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

1685def is_implies(a):
1686 """Return `True` if `a` is a Z3 implication expression.
1687
1688 >>> p, q = Bools('p q')
1689 >>> is_implies(Implies(p, q))
1690 True
1691 >>> is_implies(And(p, q))
1692 False
1693 """
1694 return is_app_of(a, Z3_OP_IMPLIES)
1695
1696

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

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

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

2782def is_int_value(a):
2783 """Return `True` if `a` is an integer value of sort Int.
2784
2785 >>> is_int_value(IntVal(1))
2786 True
2787 >>> is_int_value(1)
2788 False
2789 >>> is_int_value(Int('x'))
2790 False
2791 >>> n = Int('x') + 1
2792 >>> n
2793 x + 1
2794 >>> n.arg(1)
2795 1
2796 >>> is_int_value(n.arg(1))
2797 True
2798 >>> is_int_value(RealVal("1/3"))
2799 False
2800 >>> is_int_value(RealVal(1))
2801 False
2802 """
2803 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2804
2805

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

2967def is_is_int(a):
2968 """Return `True` if `a` is an expression of the form IsInt(b).
2969
2970 >>> x = Real('x')
2971 >>> is_is_int(IsInt(x))
2972 True
2973 >>> is_is_int(x)
2974 False
2975 """
2976 return is_app_of(a, Z3_OP_IS_INT)
2977
2978

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

4684def is_K(a):
4685 """Return `True` if `a` is a Z3 constant array.
4686
4687 >>> a = K(IntSort(), 10)
4688 >>> is_K(a)
4689 True
4690 >>> a = Array('a', IntSort(), IntSort())
4691 >>> is_K(a)
4692 False
4693 """
4694 return is_app_of(a, Z3_OP_CONST_ARRAY)
4695
4696

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

2919def is_le(a):
2920 """Return `True` if `a` is an expression of the form b <= c.
2921
2922 >>> x, y = Ints('x y')
2923 >>> is_le(x <= y)
2924 True
2925 >>> is_le(x < y)
2926 False
2927 """
2928 return is_app_of(a, Z3_OP_LE)
2929
2930

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

2931def is_lt(a):
2932 """Return `True` if `a` is an expression of the form b < c.
2933
2934 >>> x, y = Ints('x y')
2935 >>> is_lt(x < y)
2936 True
2937 >>> is_lt(x == y)
2938 False
2939 """
2940 return is_app_of(a, Z3_OP_LT)
2941
2942

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

4697def is_map(a):
4698 """Return `True` if `a` is a Z3 map array expression.
4699
4700 >>> f = Function('f', IntSort(), IntSort())
4701 >>> b = Array('b', IntSort(), IntSort())
4702 >>> a = Map(f, b)
4703 >>> a
4704 Map(f, b)
4705 >>> is_map(a)
4706 True
4707 >>> is_map(b)
4708 False
4709 """
4710 return is_app_of(a, Z3_OP_ARRAY_MAP)
4711
4712

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

2907def is_mod(a):
2908 """Return `True` if `a` is an expression of the form b % c.
2909
2910 >>> x, y = Ints('x y')
2911 >>> is_mod(x % y)
2912 True
2913 >>> is_mod(x + y)
2914 False
2915 """
2916 return is_app_of(a, Z3_OP_MOD)
2917
2918

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

2854def is_mul(a):
2855 """Return `True` if `a` is an expression of the form b * c.
2856
2857 >>> x, y = Ints('x y')
2858 >>> is_mul(x * y)
2859 True
2860 >>> is_mul(x - y)
2861 False
2862 """
2863 return is_app_of(a, Z3_OP_MUL)
2864
2865

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

1697def is_not(a):
1698 """Return `True` if `a` is a Z3 not expression.
1699
1700 >>> p = Bool('p')
1701 >>> is_not(p)
1702 False
1703 >>> is_not(Not(p))
1704 True
1705 """
1706 return is_app_of(a, Z3_OP_NOT)
1707
1708

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

1673def is_or(a):
1674 """Return `True` if `a` is a Z3 or expression.
1675
1676 >>> p, q = Bools('p q')
1677 >>> is_or(Or(p, q))
1678 True
1679 >>> is_or(And(p, q))
1680 False
1681 """
1682 return is_app_of(a, Z3_OP_OR)
1683
1684

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

1973def is_pattern(a):
1974 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1975
1976 >>> f = Function('f', IntSort(), IntSort())
1977 >>> x = Int('x')
1978 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1979 >>> q
1980 ForAll(x, f(x) == 0)
1981 >>> q.num_patterns()
1982 1
1983 >>> is_pattern(q.pattern(0))
1984 True
1985 >>> q.pattern(0)
1986 f(Var(0))
1987 """
1988 return isinstance(a, PatternRef)
1989
1990

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

8770def is_probe(p):
8771 """Return `True` if `p` is a Z3 probe.
8772
8773 >>> is_probe(Int('x'))
8774 False
8775 >>> is_probe(Probe('memory'))
8776 True
8777 """
8778 return isinstance(p, Probe)
8779
8780

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

2223def is_quantifier(a):
2224 """Return `True` if `a` is a Z3 quantifier.
2225
2226 >>> f = Function('f', IntSort(), IntSort())
2227 >>> x = Int('x')
2228 >>> q = ForAll(x, f(x) == 0)
2229 >>> is_quantifier(q)
2230 True
2231 >>> is_quantifier(f(x))
2232 False
2233 """
2234 return isinstance(a, QuantifierRef)
2235
2236

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

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

◆ is_re()

is_re ( s)

Definition at line 11327 of file z3py.py.

11327def is_re(s):
11328 return isinstance(s, ReRef)
11329
11330

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

2755def is_real(a):
2756 """Return `True` if `a` is a real expression.
2757
2758 >>> x = Int('x')
2759 >>> is_real(x + 1)
2760 False
2761 >>> y = Real('y')
2762 >>> is_real(y)
2763 True
2764 >>> is_real(y + 1)
2765 True
2766 >>> is_real(1)
2767 False
2768 >>> is_real(RealVal(1))
2769 True
2770 """
2771 return is_arith(a) and a.is_real()
2772
2773

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

4932def is_select(a):
4933 """Return `True` if `a` is a Z3 array select application.
4934
4935 >>> a = Array('a', IntSort(), IntSort())
4936 >>> is_select(a)
4937 False
4938 >>> i = Int('i')
4939 >>> is_select(a[i])
4940 True
4941 """
4942 return is_app_of(a, Z3_OP_SELECT)
4943
4944

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

11027def is_seq(a):
11028 """Return `True` if `a` is a Z3 sequence expression.
11029 >>> print (is_seq(Unit(IntVal(0))))
11030 True
11031 >>> print (is_seq(StringVal("abc")))
11032 True
11033 """
11034 return isinstance(a, SeqRef)
11035
11036

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

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

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

4945def is_store(a):
4946 """Return `True` if `a` is a Z3 array store application.
4947
4948 >>> a = Array('a', IntSort(), IntSort())
4949 >>> is_store(a)
4950 False
4951 >>> is_store(Store(a, 0, 1))
4952 True
4953 """
4954 return is_app_of(a, Z3_OP_STORE)
4955

◆ is_string()

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

Definition at line 11037 of file z3py.py.

11037def is_string(a):
11038 """Return `True` if `a` is a Z3 string expression.
11039 >>> print (is_string(StringVal("ab")))
11040 True
11041 """
11042 return isinstance(a, SeqRef) and a.is_string()
11043
11044

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

11045def is_string_value(a):
11046 """return 'True' if 'a' is a Z3 string constant expression.
11047 >>> print (is_string_value(StringVal("a")))
11048 True
11049 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11050 False
11051 """
11052 return isinstance(a, SeqRef) and a.is_string_value()
11053

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

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

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

2994def is_to_int(a):
2995 """Return `True` if `a` is an expression of the form ToInt(b).
2996
2997 >>> x = Real('x')
2998 >>> n = ToInt(x)
2999 >>> n
3000 ToInt(x)
3001 >>> is_to_int(n)
3002 True
3003 >>> is_to_int(x)
3004 False
3005 """
3006 return is_app_of(a, Z3_OP_TO_INT)
3007
3008

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

2979def is_to_real(a):
2980 """Return `True` if `a` is an expression of the form ToReal(b).
2981
2982 >>> x = Int('x')
2983 >>> n = ToReal(x)
2984 >>> n
2985 ToReal(x)
2986 >>> is_to_real(n)
2987 True
2988 >>> is_to_real(x)
2989 False
2990 """
2991 return is_app_of(a, Z3_OP_TO_REAL)
2992
2993

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

1629def is_true(a):
1630 """Return `True` if `a` is the Z3 true expression.
1631
1632 >>> p = Bool('p')
1633 >>> is_true(p)
1634 False
1635 >>> is_true(simplify(p == p))
1636 True
1637 >>> x = Real('x')
1638 >>> is_true(x == 0)
1639 False
1640 >>> # True is a Python Boolean expression
1641 >>> is_true(True)
1642 False
1643 """
1644 return is_app_of(a, Z3_OP_TRUE)
1645
1646

Referenced by AstRef.__bool__().

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

1328def is_var(a):
1329 """Return `True` if `a` is variable.
1330
1331 Z3 uses de-Bruijn indices for representing bound variables in
1332 quantifiers.
1333
1334 >>> x = Int('x')
1335 >>> is_var(x)
1336 False
1337 >>> is_const(x)
1338 True
1339 >>> f = Function('f', IntSort(), IntSort())
1340 >>> # Z3 replaces x with bound variables when ForAll is executed.
1341 >>> q = ForAll(x, f(x) == x)
1342 >>> b = q.body()
1343 >>> b
1344 f(Var(0)) == Var(0)
1345 >>> b.arg(1)
1346 Var(0)
1347 >>> is_var(b.arg(1))
1348 True
1349 """
1350 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1351
1352

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

3440def IsInt(a):
3441 """ Return the Z3 predicate IsInt(a).
3442
3443 >>> x = Real('x')
3444 >>> IsInt(x + "1/2")
3445 IsInt(x + 1/2)
3446 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3447 [x = 1/2]
3448 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3449 no solution
3450 """
3451 if z3_debug():
3452 _z3_assert(a.is_real(), "Z3 real expression expected.")
3453 ctx = a.ctx
3454 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3455
3456
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 5055 of file z3py.py.

5055def IsMember(e, s):
5056 """ Check if e is a member of set s
5057 >>> a = Const('a', SetSort(IntSort()))
5058 >>> IsMember(1, a)
5059 a[1]
5060 """
5061 ctx = _ctx_from_ast_arg_list([s, e])
5062 e = _py2expr(e, ctx)
5063 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5064
5065
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 5066 of file z3py.py.

5066def IsSubset(a, b):
5067 """ Check if a is a subset of b
5068 >>> a = Const('a', SetSort(IntSort()))
5069 >>> b = Const('b', SetSort(IntSort()))
5070 >>> IsSubset(a, b)
5071 subset(a, b)
5072 """
5073 ctx = _ctx_from_ast_arg_list([a, b])
5074 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5075
5076
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 4892 of file z3py.py.

4892def K(dom, v):
4893 """Return a Z3 constant array expression.
4894
4895 >>> a = K(IntSort(), 10)
4896 >>> a
4897 K(Int, 10)
4898 >>> a.sort()
4899 Array(Int, Int)
4900 >>> i = Int('i')
4901 >>> a[i]
4902 K(Int, 10)[i]
4903 >>> simplify(a[i])
4904 10
4905 """
4906 if z3_debug():
4907 _z3_assert(is_sort(dom), "Z3 sort expected")
4908 ctx = dom.ctx
4909 if not is_expr(v):
4910 v = _py2expr(v, ctx)
4911 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4912
4913
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 2311 of file z3py.py.

2311def Lambda(vs, body):
2312 """Create a Z3 lambda expression.
2313
2314 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2315 >>> mem0 = Array('mem0', IntSort(), IntSort())
2316 >>> lo, hi, e, i = Ints('lo hi e i')
2317 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2318 >>> mem1
2319 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2320 """
2321 ctx = body.ctx
2322 if is_app(vs):
2323 vs = [vs]
2324 num_vars = len(vs)
2325 _vs = (Ast * num_vars)()
2326 for i in range(num_vars):
2327 # TODO: Check if is constant
2328 _vs[i] = vs[i].as_ast()
2329 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2330
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 11212 of file z3py.py.

11212def LastIndexOf(s, substr):
11213 """Retrieve the last index of substring within a string"""
11214 ctx = None
11215 ctx = _get_ctx2(s, substr, ctx)
11216 s = _coerce_seq(s, ctx)
11217 substr = _coerce_seq(substr, ctx)
11218 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11219
11220
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 11221 of file z3py.py.

11221def Length(s):
11222 """Obtain the length of a sequence 's'
11223 >>> l = Length(StringVal("abc"))
11224 >>> simplify(l)
11225 3
11226 """
11227 s = _coerce_seq(s)
11228 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11229
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 11483 of file z3py.py.

11483def LinearOrder(a, index):
11484 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11485
11486
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 11433 of file z3py.py.

11433def Loop(re, lo, hi=0):
11434 """Create the regular expression accepting between a lower and upper bound repetitions
11435 >>> re = Loop(Re("a"), 1, 3)
11436 >>> print(simplify(InRe("aa", re)))
11437 True
11438 >>> print(simplify(InRe("aaaa", re)))
11439 False
11440 >>> print(simplify(InRe("", re)))
11441 False
11442 """
11443 if z3_debug():
11444 _z3_assert(is_expr(re), "expression expected")
11445 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11446
11447
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 4345 of file z3py.py.

4345def LShR(a, b):
4346 """Create the Z3 expression logical right shift.
4347
4348 Use the operator >> for the arithmetical right shift.
4349
4350 >>> x, y = BitVecs('x y', 32)
4351 >>> LShR(x, y)
4352 LShR(x, y)
4353 >>> (x >> y).sexpr()
4354 '(bvashr x y)'
4355 >>> LShR(x, y).sexpr()
4356 '(bvlshr x y)'
4357 >>> BitVecVal(4, 3)
4358 4
4359 >>> BitVecVal(4, 3).as_signed_long()
4360 -4
4361 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4362 -2
4363 >>> simplify(BitVecVal(4, 3) >> 1)
4364 6
4365 >>> simplify(LShR(BitVecVal(4, 3), 1))
4366 2
4367 >>> simplify(BitVecVal(2, 3) >> 1)
4368 1
4369 >>> simplify(LShR(BitVecVal(2, 3), 1))
4370 1
4371 """
4372 _check_bv_args(a, b)
4373 a, b = _coerce_exprs(a, b)
4374 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4375
4376
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 4869 of file z3py.py.

4869def Map(f, *args):
4870 """Return a Z3 map array expression.
4871
4872 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4873 >>> a1 = Array('a1', IntSort(), IntSort())
4874 >>> a2 = Array('a2', IntSort(), IntSort())
4875 >>> b = Map(f, a1, a2)
4876 >>> b
4877 Map(f, a1, a2)
4878 >>> prove(b[0] == f(a1[0], a2[0]))
4879 proved
4880 """
4881 args = _get_args(args)
4882 if z3_debug():
4883 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4884 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4885 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4886 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4887 _args, sz = _to_ast_array(args)
4888 ctx = f.ctx
4889 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4890
4891
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 1874 of file z3py.py.

1874def mk_not(a):
1875 if is_not(a):
1876 return a.arg(0)
1877 else:
1878 return Not(a)
1879
1880

◆ Model()

Model ( ctx = None)

Definition at line 6735 of file z3py.py.

6735def Model(ctx=None):
6736 ctx = _get_ctx(ctx)
6737 return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6738
6739
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 1991 of file z3py.py.

1991def MultiPattern(*args):
1992 """Create a Z3 multi-pattern using the given expressions `*args`
1993
1994 >>> f = Function('f', IntSort(), IntSort())
1995 >>> g = Function('g', IntSort(), IntSort())
1996 >>> x = Int('x')
1997 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1998 >>> q
1999 ForAll(x, f(x) != g(x))
2000 >>> q.num_patterns()
2001 1
2002 >>> is_pattern(q.pattern(0))
2003 True
2004 >>> q.pattern(0)
2005 MultiPattern(f(Var(0)), g(Var(0)))
2006 """
2007 if z3_debug():
2008 _z3_assert(len(args) > 0, "At least one argument expected")
2009 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2010 ctx = args[0].ctx
2011 args, sz = _to_ast_array(args)
2012 return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
2013
2014
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 1855 of file z3py.py.

1855def Not(a, ctx=None):
1856 """Create a Z3 not expression or probe.
1857
1858 >>> p = Bool('p')
1859 >>> Not(Not(p))
1860 Not(Not(p))
1861 >>> simplify(Not(Not(p)))
1862 p
1863 """
1864 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1865 if is_probe(a):
1866 # Not is also used to build probes
1867 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1868 else:
1869 s = BoolSort(ctx)
1870 a = s.cast(a)
1871 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1872
1873
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 11523 of file z3py.py.

11523def on_clause_eh(ctx, p, n, dep, clause):
11524 onc = _my_hacky_class
11525 p = _to_expr_ref(to_Ast(p), onc.ctx)
11526 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11527 deps = [dep[i] for i in range(n)]
11528 onc.on_clause(p, deps, clause)
11529

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

11398def Option(re):
11399 """Create the regular expression that optionally accepts the argument.
11400 >>> re = Option(Re("a"))
11401 >>> print(simplify(InRe("a", re)))
11402 True
11403 >>> print(simplify(InRe("", re)))
11404 True
11405 >>> print(simplify(InRe("aa", re)))
11406 False
11407 """
11408 if z3_debug():
11409 _z3_assert(is_expr(re), "expression expected")
11410 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11411
11412
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 1922 of file z3py.py.

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

8463def OrElse(*ts, **ks):
8464 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8465
8466 >>> x = Int('x')
8467 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8468 >>> # Tactic split-clause fails if there is no clause in the given goal.
8469 >>> t(x == 0)
8470 [[x == 0]]
8471 >>> t(Or(x == 0, x == 1))
8472 [[x == 0], [x == 1]]
8473 """
8474 if z3_debug():
8475 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8476 ctx = ks.get("ctx", None)
8477 num = len(ts)
8478 r = ts[0]
8479 for i in range(num - 1):
8480 r = _or_else(r, ts[i + 1], ctx)
8481 return r
8482
8483

◆ ParAndThen()

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

Definition at line 8519 of file z3py.py.

8519def ParAndThen(t1, t2, ctx=None):
8520 """Alias for ParThen(t1, t2, ctx)."""
8521 return ParThen(t1, t2, ctx)
8522
8523

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

8484def ParOr(*ts, **ks):
8485 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8486
8487 >>> x = Int('x')
8488 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8489 >>> t(x + 1 == 2)
8490 [[x == 1]]
8491 """
8492 if z3_debug():
8493 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8494 ctx = _get_ctx(ks.get("ctx", None))
8495 ts = [_to_tactic(t, ctx) for t in ts]
8496 sz = len(ts)
8497 _args = (TacticObj * sz)()
8498 for i in range(sz):
8499 _args[i] = ts[i].tactic
8500 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8501
8502
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 9399 of file z3py.py.

9399def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9400 """Parse a file in SMT 2.0 format using the given sorts and decls.
9401
9402 This function is similar to parse_smt2_string().
9403 """
9404 ctx = _get_ctx(ctx)
9405 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9406 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9407 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9408
9409
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 9378 of file z3py.py.

9378def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9379 """Parse a string in SMT 2.0 format using the given sorts and decls.
9380
9381 The arguments sorts and decls are Python dictionaries used to initialize
9382 the symbol table used for the SMT 2.0 parser.
9383
9384 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9385 [x > 0, x < 10]
9386 >>> x, y = Ints('x y')
9387 >>> f = Function('f', IntSort(), IntSort())
9388 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9389 [x + f(y) > 0]
9390 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9391 [a > 0]
9392 """
9393 ctx = _get_ctx(ctx)
9394 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9395 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9396 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9397
9398
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 8503 of file z3py.py.

8503def ParThen(t1, t2, ctx=None):
8504 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8505 The subgoals are processed in parallel.
8506
8507 >>> x, y = Ints('x y')
8508 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8509 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8510 [[x == 1, y == 2], [x == 2, y == 3]]
8511 """
8512 t1 = _to_tactic(t1, ctx)
8513 t2 = _to_tactic(t2, ctx)
8514 if z3_debug():
8515 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8516 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8517
8518
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 11479 of file z3py.py.

11479def PartialOrder(a, index):
11480 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11481
11482
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 9155 of file z3py.py.

9155def PbEq(args, k, ctx=None):
9156 """Create a Pseudo-Boolean equality k constraint.
9157
9158 >>> a, b, c = Bools('a b c')
9159 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9160 """
9161 _z3_check_cint_overflow(k, "k")
9162 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9163 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9164
9165
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 9144 of file z3py.py.

9144def PbGe(args, k):
9145 """Create a Pseudo-Boolean inequality k constraint.
9146
9147 >>> a, b, c = Bools('a b c')
9148 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9149 """
9150 _z3_check_cint_overflow(k, "k")
9151 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9152 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9153
9154
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 9133 of file z3py.py.

9133def PbLe(args, k):
9134 """Create a Pseudo-Boolean inequality k constraint.
9135
9136 >>> a, b, c = Bools('a b c')
9137 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9138 """
9139 _z3_check_cint_overflow(k, "k")
9140 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9141 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9142
9143
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 11491 of file z3py.py.

11491def PiecewiseLinearOrder(a, index):
11492 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11493
11494
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 11383 of file z3py.py.

11383def Plus(re):
11384 """Create the regular expression accepting one or more repetitions of argument.
11385 >>> re = Plus(Re("a"))
11386 >>> print(simplify(InRe("aa", re)))
11387 True
11388 >>> print(simplify(InRe("ab", re)))
11389 False
11390 >>> print(simplify(InRe("", re)))
11391 False
11392 """
11393 if z3_debug():
11394 _z3_assert(is_expr(re), "expression expected")
11395 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11396
11397
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 11128 of file z3py.py.

11128def PrefixOf(a, b):
11129 """Check if 'a' is a prefix of 'b'
11130 >>> s1 = PrefixOf("ab", "abc")
11131 >>> simplify(s1)
11132 True
11133 >>> s2 = PrefixOf("bc", "abc")
11134 >>> simplify(s2)
11135 False
11136 """
11137 ctx = _get_ctx2(a, b)
11138 a = _coerce_seq(a, ctx)
11139 b = _coerce_seq(b, ctx)
11140 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11141
11142
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 8799 of file z3py.py.

8799def probe_description(name, ctx=None):
8800 """Return a short description for the probe named `name`.
8801
8802 >>> d = probe_description('memory')
8803 """
8804 ctx = _get_ctx(ctx)
8805 return Z3_probe_get_descr(ctx.ref(), name)
8806
8807
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 8788 of file z3py.py.

8788def probes(ctx=None):
8789 """Return a list of all available probes in Z3.
8790
8791 >>> l = probes()
8792 >>> l.count('memory') == 1
8793 True
8794 """
8795 ctx = _get_ctx(ctx)
8796 return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8797
8798
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 9040 of file z3py.py.

9040def Product(*args):
9041 """Create the product of the Z3 expressions.
9042
9043 >>> a, b, c = Ints('a b c')
9044 >>> Product(a, b, c)
9045 a*b*c
9046 >>> Product([a, b, c])
9047 a*b*c
9048 >>> A = IntVector('a', 5)
9049 >>> Product(A)
9050 a__0*a__1*a__2*a__3*a__4
9051 """
9052 args = _get_args(args)
9053 if len(args) == 0:
9054 return 1
9055 ctx = _ctx_from_ast_arg_list(args)
9056 if ctx is None:
9057 return _reduce(lambda a, b: a * b, args, 1)
9058 args = _coerce_expr_list(args, ctx)
9059 if is_bv(args[0]):
9060 return _reduce(lambda a, b: a * b, args, 1)
9061 else:
9062 _args, sz = _to_ast_array(args)
9063 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
9064
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 11677 of file z3py.py.

11677def PropagateFunction(name, *sig):
11678 """Create a function that gets tracked by user propagator.
11679 Every term headed by this function symbol is tracked.
11680 If a term is fixed and the fixed callback is registered a
11681 callback is invoked that the term headed by this function is fixed.
11682 """
11683 sig = _get_args(sig)
11684 if z3_debug():
11685 _z3_assert(len(sig) > 0, "At least two arguments expected")
11686 arity = len(sig) - 1
11687 rng = sig[arity]
11688 if z3_debug():
11689 _z3_assert(is_sort(rng), "Z3 sort expected")
11690 dom = (Sort * arity)()
11691 for i in range(arity):
11692 if z3_debug():
11693 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11694 dom[i] = sig[i].ast
11695 ctx = rng.ctx
11696 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11697
11698
11699
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 9227 of file z3py.py.

9227def prove(claim, show=False, **keywords):
9228 """Try to prove the given claim.
9229
9230 This is a simple function for creating demonstrations. It tries to prove
9231 `claim` by showing the negation is unsatisfiable.
9232
9233 >>> p, q = Bools('p q')
9234 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9235 proved
9236 """
9237 if z3_debug():
9238 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9239 s = Solver()
9240 s.set(**keywords)
9241 s.add(Not(claim))
9242 if show:
9243 print(s)
9244 r = s.check()
9245 if r == unsat:
9246 print("proved")
9247 elif r == unknown:
9248 print("failed to prove")
9249 print(s.model())
9250 else:
9251 print("counterexample")
9252 print(s.model())
9253
9254

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

3281def Q(a, b, ctx=None):
3282 """Return a Z3 rational a/b.
3283
3284 If `ctx=None`, then the global context is used.
3285
3286 >>> Q(3,5)
3287 3/5
3288 >>> Q(3,5).sort()
3289 Real
3290 """
3291 return simplify(RatVal(a, b, ctx=ctx))
3292
3293

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

11448def Range(lo, hi, ctx=None):
11449 """Create the range regular expression over two sequences of length 1
11450 >>> range = Range("a","z")
11451 >>> print(simplify(InRe("b", range)))
11452 True
11453 >>> print(simplify(InRe("bb", range)))
11454 False
11455 """
11456 lo = _coerce_seq(lo, ctx)
11457 hi = _coerce_seq(hi, ctx)
11458 if z3_debug():
11459 _z3_assert(is_expr(lo), "expression expected")
11460 _z3_assert(is_expr(hi), "expression expected")
11461 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11462
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 3265 of file z3py.py.

3265def RatVal(a, b, ctx=None):
3266 """Return a Z3 rational a/b.
3267
3268 If `ctx=None`, then the global context is used.
3269
3270 >>> RatVal(3,5)
3271 3/5
3272 >>> RatVal(3,5).sort()
3273 Real
3274 """
3275 if z3_debug():
3276 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3277 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3278 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3279
3280

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

11292def Re(s, ctx=None):
11293 """The regular expression that accepts sequence 's'
11294 >>> s1 = Re("ab")
11295 >>> s2 = Re(StringVal("ab"))
11296 >>> s3 = Re(Unit(BoolVal(True)))
11297 """
11298 s = _coerce_seq(s, ctx)
11299 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11300
11301
11302# Regular expressions
11303
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 3347 of file z3py.py.

3347def Real(name, ctx=None):
3348 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3349
3350 >>> x = Real('x')
3351 >>> is_real(x)
3352 True
3353 >>> is_real(x + 1)
3354 True
3355 """
3356 ctx = _get_ctx(ctx)
3357 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3358
3359

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

3360def Reals(names, ctx=None):
3361 """Return a tuple of real constants.
3362
3363 >>> x, y, z = Reals('x y z')
3364 >>> Sum(x, y, z)
3365 x + y + z
3366 >>> Sum(x, y, z).sort()
3367 Real
3368 """
3369 ctx = _get_ctx(ctx)
3370 if isinstance(names, str):
3371 names = names.split(" ")
3372 return [Real(name, ctx) for name in names]
3373
3374

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

3205def RealSort(ctx=None):
3206 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3207
3208 >>> RealSort()
3209 Real
3210 >>> x = Const('x', RealSort())
3211 >>> is_real(x)
3212 True
3213 >>> is_int(x)
3214 False
3215 >>> x.sort() == RealSort()
3216 True
3217 """
3218 ctx = _get_ctx(ctx)
3219 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3220
3221
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 3246 of file z3py.py.

3246def RealVal(val, ctx=None):
3247 """Return a Z3 real value.
3248
3249 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3250 If `ctx=None`, then the global context is used.
3251
3252 >>> RealVal(1)
3253 1
3254 >>> RealVal(1).sort()
3255 Real
3256 >>> RealVal("3/5")
3257 3/5
3258 >>> RealVal("1.5")
3259 3/2
3260 """
3261 ctx = _get_ctx(ctx)
3262 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3263
3264

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

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

1503def RealVar(idx, ctx=None):
1504 """
1505 Create a real free variable. Free variables are used to create quantified formulas.
1506 They are also used to create polynomials.
1507
1508 >>> RealVar(0)
1509 Var(0)
1510 """
1511 return Var(idx, RealSort(ctx))
1512
1513

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

1514def RealVarVector(n, ctx=None):
1515 """
1516 Create a list of Real free variables.
1517 The variables have ids: 0, 1, ..., n-1
1518
1519 >>> x0, x1, x2, x3 = RealVarVector(4)
1520 >>> x2
1521 Var(2)
1522 """
1523 return [RealVar(i, ctx) for i in range(n)]
1524

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

3375def RealVector(prefix, sz, ctx=None):
3376 """Return a list of real constants of size `sz`.
3377
3378 >>> X = RealVector('x', 3)
3379 >>> X
3380 [x__0, x__1, x__2]
3381 >>> Sum(X)
3382 x__0 + x__1 + x__2
3383 >>> Sum(X).sort()
3384 Real
3385 """
3386 ctx = _get_ctx(ctx)
3387 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3388
3389

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

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

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

8552def Repeat(t, max=4294967295, ctx=None):
8553 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8554 or the maximum number of iterations `max` is reached.
8555
8556 >>> x, y = Ints('x y')
8557 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8558 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8559 >>> r = t(c)
8560 >>> for subgoal in r: print(subgoal)
8561 [x == 0, y == 0, x > y]
8562 [x == 0, y == 1, x > y]
8563 [x == 1, y == 0, x > y]
8564 [x == 1, y == 1, x > y]
8565 >>> t = Then(t, Tactic('propagate-values'))
8566 >>> t(c)
8567 [[x == 1, y == 0]]
8568 """
8569 t = _to_tactic(t, ctx)
8570 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8571
8572
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 4467 of file z3py.py.

4467def RepeatBitVec(n, a):
4468 """Return an expression representing `n` copies of `a`.
4469
4470 >>> x = BitVec('x', 8)
4471 >>> n = RepeatBitVec(4, x)
4472 >>> n
4473 RepeatBitVec(4, x)
4474 >>> n.size()
4475 32
4476 >>> v0 = BitVecVal(10, 4)
4477 >>> print("%.x" % v0.as_long())
4478 a
4479 >>> v = simplify(RepeatBitVec(4, v0))
4480 >>> v.size()
4481 16
4482 >>> print("%.x" % v.as_long())
4483 aaaa
4484 """
4485 if z3_debug():
4486 _z3_assert(_is_int(n), "First argument must be an integer")
4487 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4488 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4489
4490
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 11177 of file z3py.py.

11177def Replace(s, src, dst):
11178 """Replace the first occurrence of 'src' by 'dst' in 's'
11179 >>> r = Replace("aaa", "a", "b")
11180 >>> simplify(r)
11181 "baa"
11182 """
11183 ctx = _get_ctx2(dst, s)
11184 if ctx is None and is_expr(src):
11185 ctx = src.ctx
11186 src = _coerce_seq(src, ctx)
11187 dst = _coerce_seq(dst, ctx)
11188 s = _coerce_seq(s, ctx)
11189 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11190
11191
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 11311 of file z3py.py.

11311def ReSort(s):
11312 if is_ast(s):
11313 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11314 if s is None or isinstance(s, Context):
11315 ctx = _get_ctx(s)
11316 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11317 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11318
11319
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 9814 of file z3py.py.

9814def RNA(ctx=None):
9815 ctx = _get_ctx(ctx)
9816 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9817
9818
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 9804 of file z3py.py.

9804def RNE(ctx=None):
9805 ctx = _get_ctx(ctx)
9806 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9807
9808
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 4377 of file z3py.py.

4377def RotateLeft(a, b):
4378 """Return an expression representing `a` rotated to the left `b` times.
4379
4380 >>> a, b = BitVecs('a b', 16)
4381 >>> RotateLeft(a, b)
4382 RotateLeft(a, b)
4383 >>> simplify(RotateLeft(a, 0))
4384 a
4385 >>> simplify(RotateLeft(a, 16))
4386 a
4387 """
4388 _check_bv_args(a, b)
4389 a, b = _coerce_exprs(a, b)
4390 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4391
4392
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 4393 of file z3py.py.

4393def RotateRight(a, b):
4394 """Return an expression representing `a` rotated to the right `b` times.
4395
4396 >>> a, b = BitVecs('a b', 16)
4397 >>> RotateRight(a, b)
4398 RotateRight(a, b)
4399 >>> simplify(RotateRight(a, 0))
4400 a
4401 >>> simplify(RotateRight(a, 16))
4402 a
4403 """
4404 _check_bv_args(a, b)
4405 a, b = _coerce_exprs(a, b)
4406 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4407
4408
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 9809 of file z3py.py.

9809def RoundNearestTiesToAway(ctx=None):
9810 ctx = _get_ctx(ctx)
9811 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9812
9813

◆ RoundNearestTiesToEven()

RoundNearestTiesToEven ( ctx = None)

Definition at line 9799 of file z3py.py.

9799def RoundNearestTiesToEven(ctx=None):
9800 ctx = _get_ctx(ctx)
9801 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9802
9803

◆ RoundTowardNegative()

RoundTowardNegative ( ctx = None)

Definition at line 9829 of file z3py.py.

9829def RoundTowardNegative(ctx=None):
9830 ctx = _get_ctx(ctx)
9831 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9832
9833
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 9819 of file z3py.py.

9819def RoundTowardPositive(ctx=None):
9820 ctx = _get_ctx(ctx)
9821 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9822
9823
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 9839 of file z3py.py.

9839def RoundTowardZero(ctx=None):
9840 ctx = _get_ctx(ctx)
9841 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9842
9843
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 9834 of file z3py.py.

9834def RTN(ctx=None):
9835 ctx = _get_ctx(ctx)
9836 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9837
9838

◆ RTP()

RTP ( ctx = None)

Definition at line 9824 of file z3py.py.

9824def RTP(ctx=None):
9825 ctx = _get_ctx(ctx)
9826 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9827
9828

◆ RTZ()

RTZ ( ctx = None)

Definition at line 9844 of file z3py.py.

9844def RTZ(ctx=None):
9845 ctx = _get_ctx(ctx)
9846 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9847
9848

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

4853def Select(a, *args):
4854 """Return a Z3 select array expression.
4855
4856 >>> a = Array('a', IntSort(), IntSort())
4857 >>> i = Int('i')
4858 >>> Select(a, i)
4859 a[i]
4860 >>> eq(Select(a, i), a[i])
4861 True
4862 """
4863 args = _get_args(args)
4864 if z3_debug():
4865 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4866 return a[args]
4867
4868

◆ SeqFoldLeft()

SeqFoldLeft ( f,
a,
s )

Definition at line 11244 of file z3py.py.

11244def SeqFoldLeft(f, a, s):
11245 ctx = _get_ctx2(f, s)
11246 s = _coerce_seq(s, ctx)
11247 a = _py2expr(a)
11248 return _to_expr_ref(Z3_mk_seq_foldl(s.ctx_ref(), f.as_ast(), a.as_ast(), s.as_ast()), ctx)
11249
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 11250 of file z3py.py.

11250def SeqFoldLeftI(f, i, a, s):
11251 ctx = _get_ctx2(f, s)
11252 s = _coerce_seq(s, ctx)
11253 a = _py2expr(a)
11254 i = _py2epxr(i)
11255 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11256
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 11230 of file z3py.py.

11230def SeqMap(f, s):
11231 """Map function 'f' over sequence 's'"""
11232 ctx = _get_ctx2(f, s)
11233 s = _coerce_seq(s, ctx)
11234 return _to_expr_ref(Z3_mk_seq_map(s.ctx_ref(), f.as_ast(), s.as_ast()), ctx)
11235
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 11236 of file z3py.py.

11236def SeqMapI(f, i, s):
11237 """Map function 'f' over sequence 's' at index 'i'"""
11238 ctx = _get_ctx(f, s)
11239 s = _coerce_seq(s, ctx)
11240 if not is_expr(i):
11241 i = _py2expr(i)
11242 return _to_expr_ref(Z3_mk_seq_mapi(s.ctx_ref(), f.as_ast(), i.as_ast(), s.as_ast()), ctx)
11243
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 10898 of file z3py.py.

10898def SeqSort(s):
10899 """Create a sequence sort over elements provided in the argument
10900 >>> s = SeqSort(IntSort())
10901 >>> s == Unit(IntVal(1)).sort()
10902 True
10903 """
10904 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10905
10906
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 9460 of file z3py.py.

9460def set_default_fp_sort(ebits, sbits, ctx=None):
9461 global _dflt_fpsort_ebits
9462 global _dflt_fpsort_sbits
9463 _dflt_fpsort_ebits = ebits
9464 _dflt_fpsort_sbits = sbits
9465
9466

◆ set_default_rounding_mode()

set_default_rounding_mode ( rm,
ctx = None )

Definition at line 9447 of file z3py.py.

9447def set_default_rounding_mode(rm, ctx=None):
9448 global _dflt_rounding_mode
9449 if is_fprm_value(rm):
9450 _dflt_rounding_mode = rm.decl().kind()
9451 else:
9452 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9453 _dflt_rounding_mode = rm
9454
9455

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

5012def SetAdd(s, e):
5013 """ Add element e to set s
5014 >>> a = Const('a', SetSort(IntSort()))
5015 >>> SetAdd(a, 1)
5016 Store(a, 1, True)
5017 """
5018 ctx = _ctx_from_ast_arg_list([s, e])
5019 e = _py2expr(e, ctx)
5020 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5021
5022
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 5034 of file z3py.py.

5034def SetComplement(s):
5035 """ The complement of set s
5036 >>> a = Const('a', SetSort(IntSort()))
5037 >>> SetComplement(a)
5038 complement(a)
5039 """
5040 ctx = s.ctx
5041 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
5042
5043
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 5023 of file z3py.py.

5023def SetDel(s, e):
5024 """ Remove element e to set s
5025 >>> a = Const('a', SetSort(IntSort()))
5026 >>> SetDel(a, 1)
5027 Store(a, 1, False)
5028 """
5029 ctx = _ctx_from_ast_arg_list([s, e])
5030 e = _py2expr(e, ctx)
5031 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5032
5033
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 5044 of file z3py.py.

5044def SetDifference(a, b):
5045 """ The set difference of a and b
5046 >>> a = Const('a', SetSort(IntSort()))
5047 >>> b = Const('b', SetSort(IntSort()))
5048 >>> SetDifference(a, b)
5049 setminus(a, b)
5050 """
5051 ctx = _ctx_from_ast_arg_list([a, b])
5052 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5053
5054
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 4926 of file z3py.py.

4926def SetHasSize(a, k):
4927 ctx = a.ctx
4928 k = _py2expr(k, ctx)
4929 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4930
4931
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 4999 of file z3py.py.

4999def SetIntersect(*args):
5000 """ Take the union of sets
5001 >>> a = Const('a', SetSort(IntSort()))
5002 >>> b = Const('b', SetSort(IntSort()))
5003 >>> SetIntersect(a, b)
5004 intersection(a, b)
5005 """
5006 args = _get_args(args)
5007 ctx = _ctx_from_ast_arg_list(args)
5008 _args, sz = _to_ast_array(args)
5009 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
5010
5011
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 4963 of file z3py.py.

4963def SetSort(s):
4964 """ Create a set sort over element sort s"""
4965 return ArraySort(s, BoolSort())
4966
4967

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

4986def SetUnion(*args):
4987 """ Take the union of sets
4988 >>> a = Const('a', SetSort(IntSort()))
4989 >>> b = Const('b', SetSort(IntSort()))
4990 >>> SetUnion(a, b)
4991 union(a, b)
4992 """
4993 args = _get_args(args)
4994 ctx = _ctx_from_ast_arg_list(args)
4995 _args, sz = _to_ast_array(args)
4996 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4997
4998
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 4409 of file z3py.py.

4409def SignExt(n, a):
4410 """Return a bit-vector expression with `n` extra sign-bits.
4411
4412 >>> x = BitVec('x', 16)
4413 >>> n = SignExt(8, x)
4414 >>> n.size()
4415 24
4416 >>> n
4417 SignExt(8, x)
4418 >>> n.sort()
4419 BitVec(24)
4420 >>> v0 = BitVecVal(2, 2)
4421 >>> v0
4422 2
4423 >>> v0.size()
4424 2
4425 >>> v = simplify(SignExt(6, v0))
4426 >>> v
4427 254
4428 >>> v.size()
4429 8
4430 >>> print("%.x" % v.as_long())
4431 fe
4432 """
4433 if z3_debug():
4434 _z3_assert(_is_int(n), "First argument must be an integer")
4435 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4436 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4437
4438
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 7486 of file z3py.py.

7486def SimpleSolver(ctx=None, logFile=None):
7487 """Return a simple general purpose solver with limited amount of preprocessing.
7488
7489 >>> s = SimpleSolver()
7490 >>> x = Int('x')
7491 >>> s.add(x > 0)
7492 >>> s.check()
7493 sat
7494 """
7495 ctx = _get_ctx(ctx)
7496 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7497
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 8904 of file z3py.py.

8904def simplify(a, *arguments, **keywords):
8905 """Simplify the expression `a` using the given options.
8906
8907 This function has many options. Use `help_simplify` to obtain the complete list.
8908
8909 >>> x = Int('x')
8910 >>> y = Int('y')
8911 >>> simplify(x + 1 + y + x + 1)
8912 2 + 2*x + y
8913 >>> simplify((x + 1)*(y + 1), som=True)
8914 1 + x + y + x*y
8915 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8916 And(Not(x == y), Not(x == 1), Not(y == 1))
8917 >>> simplify(And(x == 0, y == 1), elim_and=True)
8918 Not(Or(Not(x == 0), Not(y == 1)))
8919 """
8920 if z3_debug():
8921 _z3_assert(is_expr(a), "Z3 expression expected")
8922 if len(arguments) > 0 or len(keywords) > 0:
8923 p = args2params(arguments, keywords, a.ctx)
8924 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8925 else:
8926 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8927
8928
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 8934 of file z3py.py.

8934def simplify_param_descrs():
8935 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8936 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8937
8938
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 9166 of file z3py.py.

9166def solve(*args, **keywords):
9167 """Solve the constraints `*args`.
9168
9169 This is a simple function for creating demonstrations. It creates a solver,
9170 configure it using the options in `keywords`, adds the constraints
9171 in `args`, and invokes check.
9172
9173 >>> a = Int('a')
9174 >>> solve(a > 0, a < 2)
9175 [a = 1]
9176 """
9177 show = keywords.pop("show", False)
9178 s = Solver()
9179 s.set(**keywords)
9180 s.add(*args)
9181 if show:
9182 print(s)
9183 r = s.check()
9184 if r == unsat:
9185 print("no solution")
9186 elif r == unknown:
9187 print("failed to solve")
9188 try:
9189 print(s.model())
9190 except Z3Exception:
9191 return
9192 else:
9193 print(s.model())
9194
9195

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

9196def solve_using(s, *args, **keywords):
9197 """Solve the constraints `*args` using solver `s`.
9198
9199 This is a simple function for creating demonstrations. It is similar to `solve`,
9200 but it uses the given solver `s`.
9201 It configures solver `s` using the options in `keywords`, adds the constraints
9202 in `args`, and invokes check.
9203 """
9204 show = keywords.pop("show", False)
9205 if z3_debug():
9206 _z3_assert(isinstance(s, Solver), "Solver object expected")
9207 s.set(**keywords)
9208 s.add(*args)
9209 if show:
9210 print("Problem:")
9211 print(s)
9212 r = s.check()
9213 if r == unsat:
9214 print("no solution")
9215 elif r == unknown:
9216 print("failed to solve")
9217 try:
9218 print(s.model())
9219 except Z3Exception:
9220 return
9221 else:
9222 if show:
9223 print("Solution:")
9224 print(s.model())
9225
9226

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

7465def SolverFor(logic, ctx=None, logFile=None):
7466 """Create a solver customized for the given logic.
7467
7468 The parameter `logic` is a string. It should be contains
7469 the name of a SMT-LIB logic.
7470 See http://www.smtlib.org/ for the name of all available logics.
7471
7472 >>> s = SolverFor("QF_LIA")
7473 >>> x = Int('x')
7474 >>> s.add(x > 0)
7475 >>> s.add(x < 2)
7476 >>> s.check()
7477 sat
7478 >>> s.model()
7479 [x = 1]
7480 """
7481 ctx = _get_ctx(ctx)
7482 logic = to_symbol(logic)
7483 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7484
7485
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 3457 of file z3py.py.

3457def Sqrt(a, ctx=None):
3458 """ Return a Z3 expression which represents the square root of a.
3459
3460 >>> x = Real('x')
3461 >>> Sqrt(x)
3462 x**(1/2)
3463 """
3464 if not is_expr(a):
3465 ctx = _get_ctx(ctx)
3466 a = RealVal(a, ctx)
3467 return a ** "1/2"
3468
3469

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

4324def SRem(a, b):
4325 """Create the Z3 expression signed remainder.
4326
4327 Use the operator % for signed modulus, and URem() for unsigned remainder.
4328
4329 >>> x = BitVec('x', 32)
4330 >>> y = BitVec('y', 32)
4331 >>> SRem(x, y)
4332 SRem(x, y)
4333 >>> SRem(x, y).sort()
4334 BitVec(32)
4335 >>> (x % y).sexpr()
4336 '(bvsmod x y)'
4337 >>> SRem(x, y).sexpr()
4338 '(bvsrem x y)'
4339 """
4340 _check_bv_args(a, b)
4341 a, b = _coerce_exprs(a, b)
4342 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4343
4344
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 11418 of file z3py.py.

11418def Star(re):
11419 """Create the regular expression accepting zero or more repetitions of argument.
11420 >>> re = Star(Re("a"))
11421 >>> print(simplify(InRe("aa", re)))
11422 True
11423 >>> print(simplify(InRe("ab", re)))
11424 False
11425 >>> print(simplify(InRe("", re)))
11426 True
11427 """
11428 if z3_debug():
11429 _z3_assert(is_expr(re), "expression expected")
11430 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11431
11432
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 4836 of file z3py.py.

4836def Store(a, *args):
4837 """Return a Z3 store array expression.
4838
4839 >>> a = Array('a', IntSort(), IntSort())
4840 >>> i, v = Ints('i v')
4841 >>> s = Store(a, i, v)
4842 >>> s.sort()
4843 Array(Int, Int)
4844 >>> prove(s[i] == v)
4845 proved
4846 >>> j = Int('j')
4847 >>> prove(Implies(i != j, s[j] == a[j]))
4848 proved
4849 """
4850 return Update(a, args)
4851
4852

Referenced by ModelRef.get_interp().

◆ StrFromCode()

StrFromCode ( c)
Convert code to a string

Definition at line 11286 of file z3py.py.

11286def StrFromCode(c):
11287 """Convert code to a string"""
11288 if not is_expr(c):
11289 c = _py2expr(c)
11290 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11291
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 11061 of file z3py.py.

11061def String(name, ctx=None):
11062 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11063
11064 >>> x = String('x')
11065 """
11066 ctx = _get_ctx(ctx)
11067 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
11068
11069

◆ Strings()

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

Definition at line 11070 of file z3py.py.

11070def Strings(names, ctx=None):
11071 """Return a tuple of String constants. """
11072 ctx = _get_ctx(ctx)
11073 if isinstance(names, str):
11074 names = names.split(" ")
11075 return [String(name, ctx) for name in names]
11076
11077

◆ StringSort()

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

Definition at line 10879 of file z3py.py.

10879def StringSort(ctx=None):
10880 """Create a string sort
10881 >>> s = StringSort()
10882 >>> print(s)
10883 String
10884 """
10885 ctx = _get_ctx(ctx)
10886 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10887

◆ StringVal()

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

Definition at line 11054 of file z3py.py.

11054def StringVal(s, ctx=None):
11055 """create a string expression"""
11056 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11057 ctx = _get_ctx(ctx)
11058 return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
11059
11060
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 11280 of file z3py.py.

11280def StrToCode(s):
11281 """Convert a unit length string to integer code"""
11282 if not is_expr(s):
11283 s = _py2expr(s)
11284 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11285
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 11257 of file z3py.py.

11257def StrToInt(s):
11258 """Convert string expression to integer
11259 >>> a = StrToInt("1")
11260 >>> simplify(1 == a)
11261 True
11262 >>> b = StrToInt("2")
11263 >>> simplify(1 == b)
11264 False
11265 >>> c = StrToInt(IntToStr(2))
11266 >>> simplify(1 == c)
11267 False
11268 """
11269 s = _coerce_seq(s)
11270 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11271
11272
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 11083 of file z3py.py.

11083def SubSeq(s, offset, length):
11084 """Extract substring or subsequence starting at offset"""
11085 return Extract(s, offset, length)
11086
11087

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

8939def substitute(t, *m):
8940 """Apply substitution m on t, m is a list of pairs of the form (from, to).
8941 Every occurrence in t of from is replaced with to.
8942
8943 >>> x = Int('x')
8944 >>> y = Int('y')
8945 >>> substitute(x + 1, (x, y + 1))
8946 y + 1 + 1
8947 >>> f = Function('f', IntSort(), IntSort())
8948 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8949 1 + 1
8950 """
8951 if isinstance(m, tuple):
8952 m1 = _get_args(m)
8953 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8954 m = m1
8955 if z3_debug():
8956 _z3_assert(is_expr(t), "Z3 expression expected")
8957 _z3_assert(
8958 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
8959 "Z3 invalid substitution, expression pairs expected.")
8960 _z3_assert(
8961 all([p[0].sort().eq(p[1].sort()) for p in m]),
8962 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
8963 num = len(m)
8964 _from = (Ast * num)()
8965 _to = (Ast * num)()
8966 for i in range(num):
8967 _from[i] = m[i][0].as_ast()
8968 _to[i] = m[i][1].as_ast()
8969 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8970
8971
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 8992 of file z3py.py.

8992def substitute_funs(t, *m):
8993 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
8994 Every occurrence in to of the function from is replaced with the expression to.
8995 The expression to can have free variables, that refer to the arguments of from.
8996 For examples, see
8997 """
8998 if isinstance(m, tuple):
8999 m1 = _get_args(m)
9000 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9001 m = m1
9002 if z3_debug():
9003 _z3_assert(is_expr(t), "Z3 expression expected")
9004 _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.")
9005 num = len(m)
9006 _from = (FuncDecl * num)()
9007 _to = (Ast * num)()
9008 for i in range(num):
9009 _from[i] = m[i][0].as_func_decl()
9010 _to[i] = m[i][1].as_ast()
9011 return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
9012
9013
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 8972 of file z3py.py.

8972def substitute_vars(t, *m):
8973 """Substitute the free variables in t with the expression in m.
8974
8975 >>> v0 = Var(0, IntSort())
8976 >>> v1 = Var(1, IntSort())
8977 >>> x = Int('x')
8978 >>> f = Function('f', IntSort(), IntSort(), IntSort())
8979 >>> # replace v0 with x+1 and v1 with x
8980 >>> substitute_vars(f(v0, v1), x + 1, x)
8981 f(x + 1, x)
8982 """
8983 if z3_debug():
8984 _z3_assert(is_expr(t), "Z3 expression expected")
8985 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8986 num = len(m)
8987 _to = (Ast * num)()
8988 for i in range(num):
8989 _to[i] = m[i].as_ast()
8990 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8991
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 11078 of file z3py.py.

11078def SubString(s, offset, length):
11079 """Extract substring or subsequence starting at offset"""
11080 return Extract(s, offset, length)
11081
11082

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

11143def SuffixOf(a, b):
11144 """Check if 'a' is a suffix of 'b'
11145 >>> s1 = SuffixOf("ab", "abc")
11146 >>> simplify(s1)
11147 False
11148 >>> s2 = SuffixOf("bc", "abc")
11149 >>> simplify(s2)
11150 True
11151 """
11152 ctx = _get_ctx2(a, b)
11153 a = _coerce_seq(a, ctx)
11154 b = _coerce_seq(b, ctx)
11155 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11156
11157
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 9014 of file z3py.py.

9014def Sum(*args):
9015 """Create the sum of the Z3 expressions.
9016
9017 >>> a, b, c = Ints('a b c')
9018 >>> Sum(a, b, c)
9019 a + b + c
9020 >>> Sum([a, b, c])
9021 a + b + c
9022 >>> A = IntVector('a', 5)
9023 >>> Sum(A)
9024 a__0 + a__1 + a__2 + a__3 + a__4
9025 """
9026 args = _get_args(args)
9027 if len(args) == 0:
9028 return 0
9029 ctx = _ctx_from_ast_arg_list(args)
9030 if ctx is None:
9031 return _reduce(lambda a, b: a + b, args, 0)
9032 args = _coerce_expr_list(args, ctx)
9033 if is_bv(args[0]):
9034 return _reduce(lambda a, b: a + b, args, 0)
9035 else:
9036 _args, sz = _to_ast_array(args)
9037 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
9038
9039
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 8593 of file z3py.py.

8593def tactic_description(name, ctx=None):
8594 """Return a short description for the tactic named `name`.
8595
8596 >>> d = tactic_description('simplify')
8597 """
8598 ctx = _get_ctx(ctx)
8599 return Z3_tactic_get_descr(ctx.ref(), name)
8600
8601
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 8582 of file z3py.py.

8582def tactics(ctx=None):
8583 """Return a list of all available tactics in Z3.
8584
8585 >>> l = tactics()
8586 >>> l.count('simplify') == 1
8587 True
8588 """
8589 ctx = _get_ctx(ctx)
8590 return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8591
8592
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 8450 of file z3py.py.

8450def Then(*ts, **ks):
8451 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8452
8453 >>> x, y = Ints('x y')
8454 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8455 >>> t(And(x == 0, y > x + 1))
8456 [[Not(y <= 1)]]
8457 >>> t(And(x == 0, y > x + 1)).as_expr()
8458 Not(y <= 1)
8459 """
8460 return AndThen(*ts, **ks)
8461
8462

◆ to_Ast()

to_Ast ( ptr)

Definition at line 11502 of file z3py.py.

11502def to_Ast(ptr,):
11503 ast = Ast(ptr)
11504 super(ctypes.c_void_p, ast).__init__(ptr)
11505 return ast
11506

◆ to_AstVectorObj()

to_AstVectorObj ( ptr)

Definition at line 11512 of file z3py.py.

11512def to_AstVectorObj(ptr,):
11513 v = AstVectorObj(ptr)
11514 super(ctypes.c_void_p, v).__init__(ptr)
11515 return v
11516
11517# NB. my-hacky-class only works for a single instance of OnClause
11518# it should be replaced with a proper correlation between OnClause
11519# and object references that can be passed over the FFI.
11520# for UserPropagator we use a global dictionary, which isn't great code.
11521

◆ to_ContextObj()

to_ContextObj ( ptr)

Definition at line 11507 of file z3py.py.

11507def to_ContextObj(ptr,):
11508 ctx = ContextObj(ptr)
11509 super(ctypes.c_void_p, ctx).__init__(ptr)
11510 return ctx
11511

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

3422def ToInt(a):
3423 """ Return the Z3 expression ToInt(a).
3424
3425 >>> x = Real('x')
3426 >>> x.sort()
3427 Real
3428 >>> n = ToInt(x)
3429 >>> n
3430 ToInt(x)
3431 >>> n.sort()
3432 Int
3433 """
3434 if z3_debug():
3435 _z3_assert(a.is_real(), "Z3 real expression expected.")
3436 ctx = a.ctx
3437 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3438
3439
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 3404 of file z3py.py.

3404def ToReal(a):
3405 """ Return the Z3 expression ToReal(a).
3406
3407 >>> x = Int('x')
3408 >>> x.sort()
3409 Int
3410 >>> n = ToReal(x)
3411 >>> n
3412 ToReal(x)
3413 >>> n.sort()
3414 Real
3415 """
3416 if z3_debug():
3417 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3418 ctx = a.ctx
3419 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3420
3421
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 11495 of file z3py.py.

11495def TransitiveClosure(f):
11496 """Given a binary relation R, such that the two arguments have the same sort
11497 create the transitive closure relation R+.
11498 The transitive closure R+ is a new relation.
11499 """
11500 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11501
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 11487 of file z3py.py.

11487def TreeOrder(a, index):
11488 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11489
11490
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 8573 of file z3py.py.

8573def TryFor(t, ms, ctx=None):
8574 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8575
8576 If `t` does not terminate in `ms` milliseconds, then it fails.
8577 """
8578 t = _to_tactic(t, ctx)
8579 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8580
8581
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 5409 of file z3py.py.

5409def TupleSort(name, sorts, ctx=None):
5410 """Create a named tuple sort base on a set of underlying sorts
5411 Example:
5412 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5413 """
5414 tuple = Datatype(name, ctx)
5415 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5416 tuple.declare(name, *projects)
5417 tuple = tuple.create()
5418 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5419
5420

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

4282def UDiv(a, b):
4283 """Create the Z3 expression (unsigned) division `self / other`.
4284
4285 Use the operator / for signed division.
4286
4287 >>> x = BitVec('x', 32)
4288 >>> y = BitVec('y', 32)
4289 >>> UDiv(x, y)
4290 UDiv(x, y)
4291 >>> UDiv(x, y).sort()
4292 BitVec(32)
4293 >>> (x / y).sexpr()
4294 '(bvsdiv x y)'
4295 >>> UDiv(x, y).sexpr()
4296 '(bvudiv x y)'
4297 """
4298 _check_bv_args(a, b)
4299 a, b = _coerce_exprs(a, b)
4300 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4301
4302
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 4246 of file z3py.py.

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

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

4210def ULE(a, b):
4211 """Create the Z3 expression (unsigned) `other <= self`.
4212
4213 Use the operator <= for signed less than or equal to.
4214
4215 >>> x, y = BitVecs('x y', 32)
4216 >>> ULE(x, y)
4217 ULE(x, y)
4218 >>> (x <= y).sexpr()
4219 '(bvsle x y)'
4220 >>> ULE(x, y).sexpr()
4221 '(bvule x y)'
4222 """
4223 _check_bv_args(a, b)
4224 a, b = _coerce_exprs(a, b)
4225 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4226
4227
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 4228 of file z3py.py.

4228def ULT(a, b):
4229 """Create the Z3 expression (unsigned) `other < self`.
4230
4231 Use the operator < for signed less than.
4232
4233 >>> x, y = BitVecs('x y', 32)
4234 >>> ULT(x, y)
4235 ULT(x, y)
4236 >>> (x < y).sexpr()
4237 '(bvslt x y)'
4238 >>> ULT(x, y).sexpr()
4239 '(bvult x y)'
4240 """
4241 _check_bv_args(a, b)
4242 a, b = _coerce_exprs(a, b)
4243 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4244
4245
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 11345 of file z3py.py.

11345def Union(*args):
11346 """Create union of regular expressions.
11347 >>> re = Union(Re("a"), Re("b"), Re("c"))
11348 >>> print (simplify(InRe("d", re)))
11349 False
11350 """
11351 args = _get_args(args)
11352 sz = len(args)
11353 if z3_debug():
11354 _z3_assert(sz > 0, "At least one argument expected.")
11355 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11356 if sz == 1:
11357 return args[0]
11358 ctx = args[0].ctx
11359 v = (Ast * sz)()
11360 for i in range(sz):
11361 v[i] = args[i].as_ast()
11362 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11363
11364
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 11123 of file z3py.py.

11123def Unit(a):
11124 """Create a singleton sequence"""
11125 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11126
11127
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 4793 of file z3py.py.

4793def Update(a, *args):
4794 """Return a Z3 store array expression.
4795
4796 >>> a = Array('a', IntSort(), IntSort())
4797 >>> i, v = Ints('i v')
4798 >>> s = Update(a, i, v)
4799 >>> s.sort()
4800 Array(Int, Int)
4801 >>> prove(s[i] == v)
4802 proved
4803 >>> j = Int('j')
4804 >>> prove(Implies(i != j, s[j] == a[j]))
4805 proved
4806 """
4807 if z3_debug():
4808 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4809 args = _get_args(args)
4810 ctx = a.ctx
4811 if len(args) <= 1:
4812 raise Z3Exception("array update requires index and value arguments")
4813 if len(args) == 2:
4814 i = args[0]
4815 v = args[1]
4816 i = a.sort().domain().cast(i)
4817 v = a.sort().range().cast(v)
4818 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4819 v = a.sort().range().cast(args[-1])
4820 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4821 _args, sz = _to_ast_array(idxs)
4822 return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4823
4824
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 4303 of file z3py.py.

4303def URem(a, b):
4304 """Create the Z3 expression (unsigned) remainder `self % other`.
4305
4306 Use the operator % for signed modulus, and SRem() for signed remainder.
4307
4308 >>> x = BitVec('x', 32)
4309 >>> y = BitVec('y', 32)
4310 >>> URem(x, y)
4311 URem(x, y)
4312 >>> URem(x, y).sort()
4313 BitVec(32)
4314 >>> (x % y).sexpr()
4315 '(bvsmod x y)'
4316 >>> URem(x, y).sexpr()
4317 '(bvurem x y)'
4318 """
4319 _check_bv_args(a, b)
4320 a, b = _coerce_exprs(a, b)
4321 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4322
4323
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 11623 of file z3py.py.

11623def user_prop_created(ctx, cb, id):
11624 prop = _prop_closures.get(ctx)
11625 old_cb = prop.cb
11626 prop.cb = cb
11627 id = _to_expr_ref(to_Ast(id), prop.ctx())
11628 prop.created(id)
11629 prop.cb = old_cb
11630
11631

◆ user_prop_decide()

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

Definition at line 11657 of file z3py.py.

11657def user_prop_decide(ctx, cb, t, idx, phase):
11658 prop = _prop_closures.get(ctx)
11659 old_cb = prop.cb
11660 prop.cb = cb
11661 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11662 prop.decide(t, idx, phase)
11663 prop.cb = old_cb
11664
11665

◆ user_prop_diseq()

user_prop_diseq ( ctx,
cb,
x,
y )

Definition at line 11648 of file z3py.py.

11648def user_prop_diseq(ctx, cb, x, y):
11649 prop = _prop_closures.get(ctx)
11650 old_cb = prop.cb
11651 prop.cb = cb
11652 x = _to_expr_ref(to_Ast(x), prop.ctx())
11653 y = _to_expr_ref(to_Ast(y), prop.ctx())
11654 prop.diseq(x, y)
11655 prop.cb = old_cb
11656

◆ user_prop_eq()

user_prop_eq ( ctx,
cb,
x,
y )

Definition at line 11639 of file z3py.py.

11639def user_prop_eq(ctx, cb, x, y):
11640 prop = _prop_closures.get(ctx)
11641 old_cb = prop.cb
11642 prop.cb = cb
11643 x = _to_expr_ref(to_Ast(x), prop.ctx())
11644 y = _to_expr_ref(to_Ast(y), prop.ctx())
11645 prop.eq(x, y)
11646 prop.cb = old_cb
11647

◆ user_prop_final()

user_prop_final ( ctx,
cb )

Definition at line 11632 of file z3py.py.

11632def user_prop_final(ctx, cb):
11633 prop = _prop_closures.get(ctx)
11634 old_cb = prop.cb
11635 prop.cb = cb
11636 prop.final()
11637 prop.cb = old_cb
11638

◆ user_prop_fixed()

user_prop_fixed ( ctx,
cb,
id,
value )

Definition at line 11614 of file z3py.py.

11614def user_prop_fixed(ctx, cb, id, value):
11615 prop = _prop_closures.get(ctx)
11616 old_cb = prop.cb
11617 prop.cb = cb
11618 id = _to_expr_ref(to_Ast(id), prop.ctx())
11619 value = _to_expr_ref(to_Ast(value), prop.ctx())
11620 prop.fixed(id, value)
11621 prop.cb = old_cb
11622

◆ user_prop_fresh()

user_prop_fresh ( ctx,
_new_ctx )

Definition at line 11600 of file z3py.py.

11600def user_prop_fresh(ctx, _new_ctx):
11601 _prop_closures.set_threaded()
11602 prop = _prop_closures.get(ctx)
11603 nctx = Context()
11604 Z3_del_context(nctx.ctx)
11605 new_ctx = to_ContextObj(_new_ctx)
11606 nctx.ctx = new_ctx
11607 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11608 nctx.owner = False
11609 new_prop = prop.fresh(nctx)
11610 _prop_closures.set(new_prop.id, new_prop)
11611 return new_prop.id
11612
11613
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 11594 of file z3py.py.

11594def user_prop_pop(ctx, cb, num_scopes):
11595 prop = _prop_closures.get(ctx)
11596 prop.cb = cb
11597 prop.pop(num_scopes)
11598
11599

◆ user_prop_push()

user_prop_push ( ctx,
cb )

Definition at line 11588 of file z3py.py.

11588def user_prop_push(ctx, cb):
11589 prop = _prop_closures.get(ctx)
11590 prop.cb = cb
11591 prop.push()
11592
11593

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

1488def Var(idx, s):
1489 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1490 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1491 declarations.
1492
1493 >>> Var(0, IntSort())
1494 Var(0)
1495 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1496 False
1497 """
1498 if z3_debug():
1499 _z3_assert(is_sort(s), "Z3 sort expected")
1500 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1501
1502
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 8867 of file z3py.py.

8867def When(p, t, ctx=None):
8868 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8869 Otherwise, it returns the input goal unmodified.
8870
8871 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8872 >>> x, y = Ints('x y')
8873 >>> g = Goal()
8874 >>> g.add(x > 0)
8875 >>> g.add(y > 0)
8876 >>> t(g)
8877 [[x > 0, y > 0]]
8878 >>> g.add(x == y + 1)
8879 >>> t(g)
8880 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8881 """
8882 p = _to_probe(p, ctx)
8883 t = _to_tactic(t, ctx)
8884 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8885
8886
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 8524 of file z3py.py.

8524def With(t, *args, **keys):
8525 """Return a tactic that applies tactic `t` using the given configuration options.
8526
8527 >>> x, y = Ints('x y')
8528 >>> t = With(Tactic('simplify'), som=True)
8529 >>> t((x + 1)*(y + 2) == 0)
8530 [[2*x + y + x*y == -2]]
8531 """
8532 ctx = keys.pop("ctx", None)
8533 t = _to_tactic(t, ctx)
8534 p = args2params(args, keys, t.ctx)
8535 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8536
8537
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 8538 of file z3py.py.

8538def WithParams(t, p):
8539 """Return a tactic that applies tactic `t` using the given configuration options.
8540
8541 >>> x, y = Ints('x y')
8542 >>> p = ParamsRef()
8543 >>> p.set("som", True)
8544 >>> t = WithParams(Tactic('simplify'), p)
8545 >>> t((x + 1)*(y + 2) == 0)
8546 [[2*x + y + x*y == -2]]
8547 """
8548 t = _to_tactic(t, None)
8549 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8550
8551

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

1839def Xor(a, b, ctx=None):
1840 """Create a Z3 Xor expression.
1841
1842 >>> p, q = Bools('p q')
1843 >>> Xor(p, q)
1844 Xor(p, q)
1845 >>> simplify(Xor(p, q))
1846 Not(p == q)
1847 """
1848 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1849 s = BoolSort(ctx)
1850 a = s.cast(a)
1851 b = s.cast(b)
1852 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1853
1854
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 4439 of file z3py.py.

4439def ZeroExt(n, a):
4440 """Return a bit-vector expression with `n` extra zero-bits.
4441
4442 >>> x = BitVec('x', 16)
4443 >>> n = ZeroExt(8, x)
4444 >>> n.size()
4445 24
4446 >>> n
4447 ZeroExt(8, x)
4448 >>> n.sort()
4449 BitVec(24)
4450 >>> v0 = BitVecVal(2, 2)
4451 >>> v0
4452 2
4453 >>> v0.size()
4454 2
4455 >>> v = simplify(ZeroExt(6, v0))
4456 >>> v
4457 2
4458 >>> v.size()
4459 8
4460 """
4461 if z3_debug():
4462 _z3_assert(_is_int(n), "First argument must be an integer")
4463 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4464 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4465
4466
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 9419 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

Definition at line 9420 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 9418 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 11522 of file z3py.py.

◆ _on_clause_eh

_on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 11530 of file z3py.py.

◆ _on_model_eh

_on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 7930 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 7922 of file z3py.py.

◆ _prop_closures

_prop_closures = None
protected

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

◆ _user_prop_created

_user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11670 of file z3py.py.

◆ _user_prop_decide

_user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11674 of file z3py.py.

◆ _user_prop_diseq

_user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11673 of file z3py.py.

◆ _user_prop_eq

_user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11672 of file z3py.py.

◆ _user_prop_final

_user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11671 of file z3py.py.

◆ _user_prop_fixed

_user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11669 of file z3py.py.

◆ _user_prop_fresh

_user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11668 of file z3py.py.

◆ _user_prop_pop

_user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11667 of file z3py.py.

◆ _user_prop_push

_user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11666 of file z3py.py.

◆ sat

Definition at line 6938 of file z3py.py.

◆ unknown

Definition at line 6940 of file z3py.py.

◆ unsat

Definition at line 6939 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.