Z3
 
Loading...
Searching...
No Matches
Data Structures | Functions | Variables
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  FiniteSetRef
 
class  FiniteSetSortRef
 Finite Sets. More...
 
class  Fixedpoint
 Fixedpoint. More...
 
class  FPNumRef
 
class  FPRef
 
class  FPRMRef
 
class  FPRMSortRef
 
class  FPSortRef
 
class  FuncDeclRef
 Function Declarations. More...
 
class  FuncEntry
 
class  FuncInterp
 
class  Goal
 
class  IntNumRef
 
class  ModelRef
 
class  OnClause
 
class  Optimize
 
class  OptimizeObjective
 Optimize. More...
 
class  ParamDescrsRef
 
class  ParamsRef
 Parameter Sets. More...
 
class  ParserContext
 
class  PatternRef
 Patterns. More...
 
class  Probe
 
class  PropClosures
 
class  QuantifierRef
 Quantifiers. More...
 
class  RatNumRef
 
class  ReRef
 
class  ReSortRef
 
class  ScopedConstructor
 
class  ScopedConstructorList
 
class  SeqRef
 
class  SeqSortRef
 Strings, Sequences and Regular expressions. More...
 
class  Simplifier
 
class  Solver
 
class  SortRef
 
class  Statistics
 Statistics. More...
 
class  Tactic
 
class  TypeVarRef
 
class  UserPropagateBase
 
class  Z3PPObject
 ASTs base class. More...
 

Functions

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

Variables

 Z3_DEBUG = __debug__
 
 _main_ctx = None
 
 sat = CheckSatResult(Z3_L_TRUE)
 
 unsat = CheckSatResult(Z3_L_FALSE)
 
 unknown = CheckSatResult(Z3_L_UNDEF)
 
dict _on_models = {}
 
 _on_model_eh = on_model_eh_type(_global_on_model)
 
 _dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN
 Floating-Point Arithmetic.
 
int _dflt_fpsort_ebits = 11
 
int _dflt_fpsort_sbits = 53
 
 _ROUNDING_MODES
 
 _my_hacky_class = None
 
 _on_clause_eh = Z3_on_clause_eh(on_clause_eh)
 
 _prop_closures = None
 
 _user_prop_push = Z3_push_eh(user_prop_push)
 
 _user_prop_pop = Z3_pop_eh(user_prop_pop)
 
 _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
 
 _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
 
 _user_prop_created = Z3_created_eh(user_prop_created)
 
 _user_prop_final = Z3_final_eh(user_prop_final)
 
 _user_prop_eq = Z3_eq_eh(user_prop_eq)
 
 _user_prop_diseq = Z3_eq_eh(user_prop_diseq)
 
 _user_prop_decide = Z3_decide_eh(user_prop_decide)
 
 _user_prop_binding = Z3_on_binding_eh(user_prop_binding)
 

Function Documentation

◆ _and_then()

_and_then (   t1,
  t2,
  ctx = None 
)
protected

Definition at line 9083 of file z3py.py.

9083def _and_then(t1, t2, ctx=None):
9084 t1 = _to_tactic(t1, ctx)
9085 t2 = _to_tactic(t2, ctx)
9086 if z3_debug():
9087 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9088 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
9089
9090
Z3_tactic_and_then
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 4833 of file z3py.py.

4833def _array_select(ar, arg):
4834 if isinstance(arg, tuple):
4835 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4836 _args, sz = _to_ast_array(args)
4837 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4838 arg = ar.sort().domain().cast(arg)
4839 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4840
4841
Z3_mk_select
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_mk_select_n
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 QuantifierRef.__getitem__(), and ArrayRef.__getitem__().

◆ _ast_kind()

int _ast_kind ( Context  ctx,
Any  a 
)
protected

Definition at line 522 of file z3py.py.

522def _ast_kind(ctx : Context, a : Any) -> int:
523 if is_ast(a):
524 a = a.as_ast()
525 return Z3_get_ast_kind(ctx.ref(), a)
526
527
Z3_get_ast_kind
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 4355 of file z3py.py.

4355def _check_bv_args(a, b):
4356 if z3_debug():
4357 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4358
4359

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

◆ _check_fp_args()

_check_fp_args (   a,
  b 
)
protected

Definition at line 11195 of file z3py.py.

11195def _check_fp_args(a, b):
11196 if z3_debug():
11197 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
11198
11199

◆ _check_same_sort()

_check_same_sort (   a,
  b,
  ctx = None 
)
protected

Definition at line 1295 of file z3py.py.

1295def _check_same_sort(a, b, ctx=None):
1296 if not isinstance(a, ExprRef):
1297 return False
1298 if not isinstance(b, ExprRef):
1299 return False
1300 if ctx is None:
1301 ctx = a.ctx
1302
1303 a_sort = Z3_get_sort(ctx.ctx, a.ast)
1304 b_sort = Z3_get_sort(ctx.ctx, b.ast)
1305 return Z3_is_eq_sort(ctx.ctx, a_sort, b_sort)
1306
1307
Z3_is_eq_sort
bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2)
compare sorts.
Z3_get_sort
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.

Referenced by _coerce_exprs().

◆ _coerce_char()

_coerce_char (   ch,
  ctx = None 
)
protected

Definition at line 11638 of file z3py.py.

11638def _coerce_char(ch, ctx=None):
11639 if isinstance(ch, str):
11640 ctx = _get_ctx(ctx)
11641 ch = CharVal(ch, ctx)
11642 if not is_expr(ch):
11643 raise Z3Exception("Character expression expected")
11644 return ch
11645

◆ _coerce_expr_list()

_coerce_expr_list (   alist,
  ctx = None 
)
protected

Definition at line 1339 of file z3py.py.

1339def _coerce_expr_list(alist, ctx=None):
1340 has_expr = False
1341 for a in alist:
1342 if is_expr(a):
1343 has_expr = True
1344 break
1345 if not has_expr:
1346 alist = [_py2expr(a, ctx) for a in alist]
1347 s = _reduce(_coerce_expr_merge, alist, None)
1348 return [s.cast(a) for a in alist]
1349
1350

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

◆ _coerce_expr_merge()

_coerce_expr_merge (   s,
  a 
)
protected

Definition at line 1277 of file z3py.py.

1277def _coerce_expr_merge(s, a):
1278 if is_expr(a):
1279 s1 = a.sort()
1280 if s is None:
1281 return s1
1282 if s1.eq(s):
1283 return s
1284 elif s.subsort(s1):
1285 return s1
1286 elif s1.subsort(s):
1287 return s
1288 else:
1289 if z3_debug():
1290 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1291 _z3_assert(False, "sort mismatch")
1292 else:
1293 return s
1294

Referenced by _coerce_exprs().

◆ _coerce_exprs()

_coerce_exprs (   a,
  b,
  ctx = None 
)
protected

Definition at line 1308 of file z3py.py.

1308def _coerce_exprs(a, b, ctx=None):
1309 if not is_expr(a) and not is_expr(b):
1310 a = _py2expr(a, ctx)
1311 b = _py2expr(b, ctx)
1312 if isinstance(a, str) and isinstance(b, SeqRef):
1313 a = StringVal(a, b.ctx)
1314 if isinstance(b, str) and isinstance(a, SeqRef):
1315 b = StringVal(b, a.ctx)
1316 if isinstance(a, float) and isinstance(b, ArithRef):
1317 a = RealVal(a, b.ctx)
1318 if isinstance(b, float) and isinstance(a, ArithRef):
1319 b = RealVal(b, a.ctx)
1320
1321 if _check_same_sort(a, b, ctx):
1322 return (a, b)
1323
1324 s = None
1325 s = _coerce_expr_merge(s, a)
1326 s = _coerce_expr_merge(s, b)
1327 a = s.cast(a)
1328 b = s.cast(b)
1329 return (a, b)
1330
1331

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

◆ _coerce_fp_expr_list()

_coerce_fp_expr_list (   alist,
  ctx 
)
protected

Definition at line 10144 of file z3py.py.

10144def _coerce_fp_expr_list(alist, ctx):
10145 first_fp_sort = None
10146 for a in alist:
10147 if is_fp(a):
10148 if first_fp_sort is None:
10149 first_fp_sort = a.sort()
10150 elif first_fp_sort == a.sort():
10151 pass # OK, same as before
10152 else:
10153 # we saw at least 2 different float sorts; something will
10154 # throw a sort mismatch later, for now assume None.
10155 first_fp_sort = None
10156 break
10157
10158 r = []
10159 for i in range(len(alist)):
10160 a = alist[i]
10161 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
10162 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
10163 r.append(FPVal(a, None, first_fp_sort, ctx))
10164 else:
10165 r.append(a)
10166 return _coerce_expr_list(r, ctx)
10167
10168
10169# FP Sorts
10170

◆ _coerce_seq()

_coerce_seq (   s,
  ctx = None 
)
protected

Definition at line 11688 of file z3py.py.

11688def _coerce_seq(s, ctx=None):
11689 if isinstance(s, str):
11690 ctx = _get_ctx(ctx)
11691 s = StringVal(s, ctx)
11692 if not is_expr(s):
11693 raise Z3Exception("Non-expression passed as a sequence")
11694 if not is_seq(s):
11695 raise Z3Exception("Non-sequence passed as a sequence")
11696 return s
11697
11698

Referenced by Concat().

◆ _ctx_from_ast_arg_list()

_ctx_from_ast_arg_list (   args,
  default_ctx = None 
)
protected

Definition at line 528 of file z3py.py.

528def _ctx_from_ast_arg_list(args, default_ctx=None):
529 ctx = None
530 for a in args:
531 if is_ast(a) or is_probe(a):
532 if ctx is None:
533 ctx = a.ctx
534 else:
535 if z3_debug():
536 _z3_assert(ctx == a.ctx, "Context mismatch")
537 if ctx is None:
538 ctx = default_ctx
539 return ctx
540
541

Referenced by _ctx_from_ast_args(), And(), Distinct(), FiniteSetDifference(), FiniteSetFilter(), FiniteSetIntersect(), FiniteSetMap(), FiniteSetMember(), FiniteSetRange(), FiniteSetSubset(), FiniteSetUnion(), If(), Implies(), IsMember(), IsSubset(), Not(), Or(), SetAdd(), SetDel(), SetDifference(), SetIntersect(), SetUnion(), and Xor().

◆ _ctx_from_ast_args()

_ctx_from_ast_args ( *  args)
protected

Definition at line 542 of file z3py.py.

542def _ctx_from_ast_args(*args):
543 return _ctx_from_ast_arg_list(args)
544
545

◆ _dflt_fps()

_dflt_fps (   ctx = None)
protected

Definition at line 10140 of file z3py.py.

10140def _dflt_fps(ctx=None):
10141 return get_default_fp_sort(ctx)
10142
10143

◆ _dflt_rm()

_dflt_rm (   ctx = None)
protected

Definition at line 10136 of file z3py.py.

10136def _dflt_rm(ctx=None):
10137 return get_default_rounding_mode(ctx)
10138
10139

◆ _dict2darray()

_dict2darray (   decls,
  ctx 
)
protected

Definition at line 10009 of file z3py.py.

10009def _dict2darray(decls, ctx):
10010 sz = len(decls)
10011 _names = (Symbol * sz)()
10012 _decls = (FuncDecl * sz)()
10013 i = 0
10014 for k in decls:
10015 v = decls[k]
10016 if z3_debug():
10017 _z3_assert(isinstance(k, str), "String expected")
10018 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
10019 _names[i] = to_symbol(k, ctx)
10020 if is_const(v):
10021 _decls[i] = v.decl().ast
10022 else:
10023 _decls[i] = v.ast
10024 i = i + 1
10025 return sz, _names, _decls
10026

◆ _dict2sarray()

_dict2sarray (   sorts,
  ctx 
)
protected

Definition at line 9993 of file z3py.py.

9993def _dict2sarray(sorts, ctx):
9994 sz = len(sorts)
9995 _names = (Symbol * sz)()
9996 _sorts = (Sort * sz)()
9997 i = 0
9998 for k in sorts:
9999 v = sorts[k]
10000 if z3_debug():
10001 _z3_assert(isinstance(k, str), "String expected")
10002 _z3_assert(is_sort(v), "Z3 sort expected")
10003 _names[i] = to_symbol(k, ctx)
10004 _sorts[i] = v.ast
10005 i = i + 1
10006 return sz, _names, _sorts
10007
10008

◆ _get_args()

_get_args (   args)
protected

Definition at line 152 of file z3py.py.

152def _get_args(args):
153 try:
154 if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)):
155 return args[0]
156 elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)):
157 return [arg for arg in args[0]]
158 elif len(args) == 1 and isinstance(args[0], Iterator):
159 return list(args[0])
160 else:
161 return args
162 except TypeError: # len is not necessarily defined when args is not a sequence (use reflection?)
163 return args
164
165# Use this when function takes multiple arguments
166
167

Referenced by FuncDeclRef.__call__(), And(), ArraySort(), Goal.assert_exprs(), Solver.assert_exprs(), Solver.check(), Concat(), CreateDatatypes(), Distinct(), FreshFunction(), Function(), Map(), Or(), RecAddDefinition(), RecFunction(), Select(), SetIntersect(), SetUnion(), and Update().

◆ _get_args_ast_list()

_get_args_ast_list (   args)
protected

Definition at line 168 of file z3py.py.

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

◆ _get_ctx()

Context _get_ctx (   ctx)
protected

Definition at line 287 of file z3py.py.

287def _get_ctx(ctx) -> Context:
288 if ctx is None:
289 return main_ctx()
290 else:
291 return ctx
292
293

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

◆ _get_ctx2()

_get_ctx2 (   a,
  b,
  ctx = None 
)
protected

Definition at line 11699 of file z3py.py.

11699def _get_ctx2(a, b, ctx=None):
11700 if is_expr(a):
11701 return a.ctx
11702 if is_expr(b):
11703 return b.ctx
11704 if ctx is None:
11705 ctx = main_ctx()
11706 return ctx
11707
11708

◆ _global_on_model()

_global_on_model (   ctx)
protected

Definition at line 8569 of file z3py.py.

8569def _global_on_model(ctx):
8570 (fn, mdl) = _on_models[ctx]
8571 fn(mdl)
8572
8573

◆ _has_probe()

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

Definition at line 1980 of file z3py.py.

1980def _has_probe(args):
1981 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1982 for arg in args:
1983 if is_probe(arg):
1984 return True
1985 return False
1986
1987

Referenced by And(), and Or().

◆ _is_algebraic()

_is_algebraic (   ctx,
  a 
)
protected

Definition at line 2888 of file z3py.py.

2888def _is_algebraic(ctx, a):
2889 return Z3_is_algebraic_number(ctx.ref(), a)
2890
2891
Z3_is_algebraic_number
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.

Referenced by _to_expr_ref(), and is_algebraic_value().

◆ _is_int()

_is_int (   v)
protected

Definition at line 76 of file z3py.py.

76 def _is_int(v):
77 return isinstance(v, (int, long))

Referenced by ParamDescrsRef.__getitem__(), ModelRef.__getitem__(), _py2expr(), Extract(), RatVal(), RepeatBitVec(), ParamsRef.set(), SignExt(), to_symbol(), and ZeroExt().

◆ _is_numeral()

_is_numeral (   ctx,
  a 
)
protected

Definition at line 2884 of file z3py.py.

2884def _is_numeral(ctx, a):
2885 return Z3_is_numeral_ast(ctx.ref(), a)
2886
2887
Z3_is_numeral_ast
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 1537 of file z3py.py.

1537def _mk_bin(f, a, b):
1538 args = (Ast * 2)()
1539 if z3_debug():
1540 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1541 args[0] = a.as_ast()
1542 args[1] = b.as_ast()
1543 return f(a.ctx.ref(), 2, args)
1544
1545

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

◆ _mk_fp_bin()

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

Definition at line 10983 of file z3py.py.

10983def _mk_fp_bin(f, rm, a, b, ctx):
10984 ctx = _get_ctx(ctx)
10985 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10986 if z3_debug():
10987 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10988 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10989 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10990
10991

◆ _mk_fp_bin_norm()

_mk_fp_bin_norm (   f,
  a,
  b,
  ctx 
)
protected

Definition at line 10992 of file z3py.py.

10992def _mk_fp_bin_norm(f, a, b, ctx):
10993 ctx = _get_ctx(ctx)
10994 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10995 if z3_debug():
10996 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10997 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10998
10999

◆ _mk_fp_bin_pred()

_mk_fp_bin_pred (   f,
  a,
  b,
  ctx 
)
protected

Definition at line 11000 of file z3py.py.

11000def _mk_fp_bin_pred(f, a, b, ctx):
11001 ctx = _get_ctx(ctx)
11002 [a, b] = _coerce_fp_expr_list([a, b], ctx)
11003 if z3_debug():
11004 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
11005 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
11006
11007

◆ _mk_fp_tern()

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

Definition at line 11008 of file z3py.py.

11008def _mk_fp_tern(f, rm, a, b, c, ctx):
11009 ctx = _get_ctx(ctx)
11010 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
11011 if z3_debug():
11012 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11013 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
11014 c), "Second, third or fourth argument must be a Z3 floating-point expression")
11015 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
11016
11017

◆ _mk_fp_unary()

_mk_fp_unary (   f,
  rm,
  a,
  ctx 
)
protected

Definition at line 10966 of file z3py.py.

10966def _mk_fp_unary(f, rm, a, ctx):
10967 ctx = _get_ctx(ctx)
10968 [a] = _coerce_fp_expr_list([a], ctx)
10969 if z3_debug():
10970 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10971 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10972 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10973
10974

◆ _mk_fp_unary_pred()

_mk_fp_unary_pred (   f,
  a,
  ctx 
)
protected

Definition at line 10975 of file z3py.py.

10975def _mk_fp_unary_pred(f, a, ctx):
10976 ctx = _get_ctx(ctx)
10977 [a] = _coerce_fp_expr_list([a], ctx)
10978 if z3_debug():
10979 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10980 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10981
10982

◆ _mk_quantifier()

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

Definition at line 2336 of file z3py.py.

2336def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2337 if z3_debug():
2338 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2339 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2340 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2341 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2342 if is_app(vs):
2343 ctx = vs.ctx
2344 vs = [vs]
2345 else:
2346 ctx = vs[0].ctx
2347 if not is_expr(body):
2348 body = BoolVal(body, ctx)
2349 num_vars = len(vs)
2350 if num_vars == 0:
2351 return body
2352 _vs = (Ast * num_vars)()
2353 for i in range(num_vars):
2354 # TODO: Check if is constant
2355 _vs[i] = vs[i].as_ast()
2356 patterns = [_to_pattern(p) for p in patterns]
2357 num_pats = len(patterns)
2358 _pats = (Pattern * num_pats)()
2359 for i in range(num_pats):
2360 _pats[i] = patterns[i].ast
2361 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2362 qid = to_symbol(qid, ctx)
2363 skid = to_symbol(skid, ctx)
2364 return QuantifierRef(Z3_mk_quantifier_const_ex(ctx.ref(), is_forall, weight, qid, skid,
2365 num_vars, _vs,
2366 num_pats, _pats,
2367 num_no_pats, _no_pats,
2368 body.as_ast()), ctx)
2369
2370
Z3_mk_quantifier_const_ex
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 9091 of file z3py.py.

9091def _or_else(t1, t2, ctx=None):
9092 t1 = _to_tactic(t1, ctx)
9093 t2 = _to_tactic(t2, ctx)
9094 if z3_debug():
9095 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9096 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
9097
9098
Z3_tactic_or_else
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 9782 of file z3py.py.

9782def _pb_args_coeffs(args, default_ctx=None):
9783 args = _get_args_ast_list(args)
9784 if len(args) == 0:
9785 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9786 args = [_reorder_pb_arg(arg) for arg in args]
9787 args, coeffs = zip(*args)
9788 if z3_debug():
9789 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9790 ctx = _ctx_from_ast_arg_list(args)
9791 if z3_debug():
9792 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9793 args = _coerce_expr_list(args, ctx)
9794 _args, sz = _to_ast_array(args)
9795 _coeffs = (ctypes.c_int * len(coeffs))()
9796 for i in range(len(coeffs)):
9797 _z3_check_cint_overflow(coeffs[i], "coefficient")
9798 _coeffs[i] = coeffs[i]
9799 return ctx, sz, _args, _coeffs, args
9800
9801

◆ _probe_and()

_probe_and (   args,
  ctx 
)
protected

Definition at line 9506 of file z3py.py.

9506def _probe_and(args, ctx):
9507 return _probe_nary(Z3_probe_and, args, ctx)
9508
9509

Referenced by And().

◆ _probe_nary()

_probe_nary (   f,
  args,
  ctx 
)
protected

Definition at line 9496 of file z3py.py.

9496def _probe_nary(f, args, ctx):
9497 if z3_debug():
9498 _z3_assert(len(args) > 0, "At least one argument expected")
9499 num = len(args)
9500 r = _to_probe(args[0], ctx)
9501 for i in range(num - 1):
9502 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
9503 return r
9504
9505

◆ _probe_or()

_probe_or (   args,
  ctx 
)
protected

Definition at line 9510 of file z3py.py.

9510def _probe_or(args, ctx):
9511 return _probe_nary(Z3_probe_or, args, ctx)
9512
9513

Referenced by Or().

◆ _prove_html()

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

Definition at line 9973 of file z3py.py.

9973def _prove_html(claim, show=False, **keywords):
9974 """Version of function `prove` that renders HTML."""
9975 if z3_debug():
9976 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9977 s = Solver()
9978 s.set(**keywords)
9979 s.add(Not(claim))
9980 if show:
9981 print(s)
9982 r = s.check()
9983 if r == unsat:
9984 print("<b>proved</b>")
9985 elif r == unknown:
9986 print("<b>failed to prove</b>")
9987 print(s.model())
9988 else:
9989 print("<b>counterexample</b>")
9990 print(s.model())
9991
9992

◆ _py2expr()

_py2expr (   a,
  ctx = None 
)
protected

Definition at line 3289 of file z3py.py.

3289def _py2expr(a, ctx=None):
3290 if isinstance(a, bool):
3291 return BoolVal(a, ctx)
3292 if _is_int(a):
3293 return IntVal(a, ctx)
3294 if isinstance(a, float):
3295 return RealVal(a, ctx)
3296 if isinstance(a, str):
3297 return StringVal(a, ctx)
3298 if is_expr(a):
3299 return a
3300 if z3_debug():
3301 _z3_assert(False, "Python bool, int, long or float expected")
3302
3303

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

◆ _reduce()

_reduce (   func,
  sequence,
  initial 
)
protected

Definition at line 1332 of file z3py.py.

1332def _reduce(func, sequence, initial):
1333 result = initial
1334 for element in sequence:
1335 result = func(result, element)
1336 return result
1337
1338

Referenced by _coerce_expr_list().

◆ _reorder_pb_arg()

_reorder_pb_arg (   arg)
protected

Definition at line 9775 of file z3py.py.

9775def _reorder_pb_arg(arg):
9776 a, b = arg
9777 if not _is_int(b) and _is_int(a):
9778 return b, a
9779 return arg
9780
9781

◆ _solve_html()

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

Definition at line 9924 of file z3py.py.

9924def _solve_html(*args, **keywords):
9925 """Version of function `solve` that renders HTML output."""
9926 show = keywords.pop("show", False)
9927 s = Solver()
9928 s.set(**keywords)
9929 s.add(*args)
9930 if show:
9931 print("<b>Problem:</b>")
9932 print(s)
9933 r = s.check()
9934 if r == unsat:
9935 print("<b>no solution</b>")
9936 elif r == unknown:
9937 print("<b>failed to solve</b>")
9938 try:
9939 print(s.model())
9940 except Z3Exception:
9941 return
9942 else:
9943 if show:
9944 print("<b>Solution:</b>")
9945 print(s.model())
9946
9947

◆ _solve_using_html()

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

Definition at line 9948 of file z3py.py.

9948def _solve_using_html(s, *args, **keywords):
9949 """Version of function `solve_using` that renders HTML."""
9950 show = keywords.pop("show", False)
9951 if z3_debug():
9952 _z3_assert(isinstance(s, Solver), "Solver object expected")
9953 s.set(**keywords)
9954 s.add(*args)
9955 if show:
9956 print("<b>Problem:</b>")
9957 print(s)
9958 r = s.check()
9959 if r == unsat:
9960 print("<b>no solution</b>")
9961 elif r == unknown:
9962 print("<b>failed to solve</b>")
9963 try:
9964 print(s.model())
9965 except Z3Exception:
9966 return
9967 else:
9968 if show:
9969 print("<b>Solution:</b>")
9970 print(s.model())
9971
9972

◆ _sort()

SortRef _sort ( Context  ctx,
Any  a 
)
protected

Definition at line 728 of file z3py.py.

728def _sort(ctx : Context, a : Any) -> SortRef:
729 return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
730
731

◆ _sort_kind()

_sort_kind (   ctx,
  s 
)
protected

Sorts.

Definition at line 586 of file z3py.py.

586def _sort_kind(ctx, s):
587 return Z3_get_sort_kind(ctx.ref(), s)
588
589
Z3_get_sort_kind
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).

Referenced by _to_sort_ref().

◆ _symbol2py()

_symbol2py (   ctx,
  s 
)
protected 
Convert a Z3 symbol back into a Python object.

Definition at line 140 of file z3py.py.

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

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

◆ _to_ast_array()

_to_ast_array (   args)
protected

Definition at line 554 of file z3py.py.

554def _to_ast_array(args):
555 sz = len(args)
556 _args = (Ast * sz)()
557 for i in range(sz):
558 _args[i] = args[i].as_ast()
559 return _args, sz
560
561

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

◆ _to_ast_ref()

_to_ast_ref (   a,
  ctx 
)
protected

Definition at line 570 of file z3py.py.

570def _to_ast_ref(a, ctx):
571 k = _ast_kind(ctx, a)
572 if k == Z3_SORT_AST:
573 return _to_sort_ref(a, ctx)
574 elif k == Z3_FUNC_DECL_AST:
575 return _to_func_decl_ref(a, ctx)
576 else:
577 return _to_expr_ref(a, ctx)
578
579

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

◆ _to_expr_ref()

_to_expr_ref (   a,
  ctx 
)
protected

Definition at line 1223 of file z3py.py.

1223def _to_expr_ref(a, ctx):
1224 if isinstance(a, Pattern):
1225 return PatternRef(a, ctx)
1226 ctx_ref = ctx.ref()
1227 k = Z3_get_ast_kind(ctx_ref, a)
1228 if k == Z3_QUANTIFIER_AST:
1229 return QuantifierRef(a, ctx)
1230 # Check for finite set sort before checking sort kind
1231 s = Z3_get_sort(ctx_ref, a)
1232 if Z3_is_finite_set_sort(ctx_ref, s):
1233 return FiniteSetRef(a, ctx)
1234 sk = Z3_get_sort_kind(ctx_ref, s)
1235 if sk == Z3_BOOL_SORT:
1236 return BoolRef(a, ctx)
1237 if sk == Z3_INT_SORT:
1238 if k == Z3_NUMERAL_AST:
1239 return IntNumRef(a, ctx)
1240 return ArithRef(a, ctx)
1241 if sk == Z3_REAL_SORT:
1242 if k == Z3_NUMERAL_AST:
1243 return RatNumRef(a, ctx)
1244 if _is_algebraic(ctx, a):
1245 return AlgebraicNumRef(a, ctx)
1246 return ArithRef(a, ctx)
1247 if sk == Z3_BV_SORT:
1248 if k == Z3_NUMERAL_AST:
1249 return BitVecNumRef(a, ctx)
1250 else:
1251 return BitVecRef(a, ctx)
1252 if sk == Z3_ARRAY_SORT:
1253 return ArrayRef(a, ctx)
1254 if sk == Z3_DATATYPE_SORT:
1255 return DatatypeRef(a, ctx)
1256 if sk == Z3_FLOATING_POINT_SORT:
1257 if k == Z3_APP_AST and _is_numeral(ctx, a):
1258 return FPNumRef(a, ctx)
1259 else:
1260 return FPRef(a, ctx)
1261 if sk == Z3_FINITE_DOMAIN_SORT:
1262 if k == Z3_NUMERAL_AST:
1263 return FiniteDomainNumRef(a, ctx)
1264 else:
1265 return FiniteDomainRef(a, ctx)
1266 if sk == Z3_ROUNDING_MODE_SORT:
1267 return FPRMRef(a, ctx)
1268 if sk == Z3_SEQ_SORT:
1269 return SeqRef(a, ctx)
1270 if sk == Z3_CHAR_SORT:
1271 return CharRef(a, ctx)
1272 if sk == Z3_RE_SORT:
1273 return ReRef(a, ctx)
1274 return ExprRef(a, ctx)
1275
1276
Z3_is_finite_set_sort
bool Z3_API Z3_is_finite_set_sort(Z3_context c, Z3_sort s)
Check if a sort is a finite set sort.

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

◆ _to_float_str()

_to_float_str (   val,
  exp = 0 
)
protected

Definition at line 10728 of file z3py.py.

10728def _to_float_str(val, exp=0):
10729 if isinstance(val, float):
10730 if math.isnan(val):
10731 res = "NaN"
10732 elif val == 0.0:
10733 sone = math.copysign(1.0, val)
10734 if sone < 0.0:
10735 return "-0.0"
10736 else:
10737 return "+0.0"
10738 elif val == float("+inf"):
10739 res = "+oo"
10740 elif val == float("-inf"):
10741 res = "-oo"
10742 else:
10743 v = val.as_integer_ratio()
10744 num = v[0]
10745 den = v[1]
10746 rvs = str(num) + "/" + str(den)
10747 res = rvs + "p" + _to_int_str(exp)
10748 elif isinstance(val, bool):
10749 if val:
10750 res = "1.0"
10751 else:
10752 res = "0.0"
10753 elif _is_int(val):
10754 res = str(val)
10755 elif isinstance(val, str):
10756 inx = val.find("*(2**")
10757 if inx == -1:
10758 res = val
10759 elif val[-1] == ")":
10760 res = val[0:inx]
10761 exp = str(int(val[inx + 5:-1]) + int(exp))
10762 else:
10763 _z3_assert(False, "String does not have floating-point numeral form.")
10764 elif z3_debug():
10765 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10766 if exp == 0:
10767 return res
10768 else:
10769 return res + "p" + exp
10770
10771

◆ _to_func_decl_array()

_to_func_decl_array (   args)
protected

Definition at line 546 of file z3py.py.

546def _to_func_decl_array(args):
547 sz = len(args)
548 _args = (FuncDecl * sz)()
549 for i in range(sz):
550 _args[i] = args[i].as_func_decl()
551 return _args, sz
552
553

◆ _to_func_decl_ref()

_to_func_decl_ref (   a,
  ctx 
)
protected

Definition at line 964 of file z3py.py.

964def _to_func_decl_ref(a, ctx):
965 return FuncDeclRef(a, ctx)
966
967

Referenced by _to_ast_ref().

◆ _to_goal()

_to_goal (   a)
protected

Definition at line 9067 of file z3py.py.

9067def _to_goal(a):
9068 if isinstance(a, BoolRef):
9069 goal = Goal(ctx=a.ctx)
9070 goal.add(a)
9071 return goal
9072 else:
9073 return a
9074
9075

◆ _to_int_str()

_to_int_str (   val)
protected

Definition at line 3338 of file z3py.py.

3338def _to_int_str(val):
3339 if isinstance(val, float):
3340 return str(int(val))
3341 elif isinstance(val, bool):
3342 if val:
3343 return "1"
3344 else:
3345 return "0"
3346 else:
3347 return str(val)
3348
3349

Referenced by BitVecVal(), and IntVal().

◆ _to_param_value()

_to_param_value (   val)
protected

Definition at line 178 of file z3py.py.

178def _to_param_value(val):
179 if isinstance(val, bool):
180 return "true" if val else "false"
181 return str(val)
182
183

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

◆ _to_pattern()

_to_pattern (   arg)
protected

Definition at line 2114 of file z3py.py.

2114def _to_pattern(arg):
2115 if is_pattern(arg):
2116 return arg
2117 else:
2118 return MultiPattern(arg)
2119

Referenced by _mk_quantifier().

◆ _to_probe()

_to_probe (   p,
  ctx = None 
)
protected

Definition at line 9450 of file z3py.py.

9450def _to_probe(p, ctx=None):
9451 if is_probe(p):
9452 return p
9453 else:
9454 return Probe(p, ctx)
9455
9456

◆ _to_ref_array()

_to_ref_array (   ref,
  args 
)
protected

Definition at line 562 of file z3py.py.

562def _to_ref_array(ref, args):
563 sz = len(args)
564 _args = (ref * sz)()
565 for i in range(sz):
566 _args[i] = args[i].as_ast()
567 return _args, sz
568
569

◆ _to_sort_ref()

_to_sort_ref (   s,
  ctx 
)
protected

Definition at line 695 of file z3py.py.

695def _to_sort_ref(s, ctx):
696 if z3_debug():
697 _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
698 if Z3_is_finite_set_sort(ctx.ref(), s):
699 return FiniteSetSortRef(s, ctx)
700 k = _sort_kind(ctx, s)
701 if k == Z3_BOOL_SORT:
702 return BoolSortRef(s, ctx)
703 elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
704 return ArithSortRef(s, ctx)
705 elif k == Z3_BV_SORT:
706 return BitVecSortRef(s, ctx)
707 elif k == Z3_ARRAY_SORT:
708 return ArraySortRef(s, ctx)
709 elif k == Z3_DATATYPE_SORT:
710 return DatatypeSortRef(s, ctx)
711 elif k == Z3_FINITE_DOMAIN_SORT:
712 return FiniteDomainSortRef(s, ctx)
713 elif k == Z3_FLOATING_POINT_SORT:
714 return FPSortRef(s, ctx)
715 elif k == Z3_ROUNDING_MODE_SORT:
716 return FPRMSortRef(s, ctx)
717 elif k == Z3_RE_SORT:
718 return ReSortRef(s, ctx)
719 elif k == Z3_SEQ_SORT:
720 return SeqSortRef(s, ctx)
721 elif k == Z3_CHAR_SORT:
722 return CharSortRef(s, ctx)
723 elif k == Z3_TYPE_VAR:
724 return TypeVarRef(s, ctx)
725 return SortRef(s, ctx)
726
727

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

◆ _to_tactic()

_to_tactic (   t,
  ctx = None 
)
protected

Definition at line 9076 of file z3py.py.

9076def _to_tactic(t, ctx=None):
9077 if isinstance(t, Tactic):
9078 return t
9079 else:
9080 return Tactic(t, ctx)
9081
9082

◆ _valid_accessor()

_valid_accessor (   acc)
protected

Datatypes. 

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

Definition at line 5519 of file z3py.py.

5519def _valid_accessor(acc):
5520 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5521 if not isinstance(acc, tuple):
5522 return False
5523 if len(acc) != 2:
5524 return False
5525 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5526
5527

Referenced by Datatype.declare_core().

◆ _z3_assert()

_z3_assert (   cond,
  msg 
)
protected

Definition at line 113 of file z3py.py.

113def _z3_assert(cond, msg):
114 if not cond:
115 raise Z3Exception(msg)
116
117

Referenced by QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), ParamDescrsRef.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _check_bv_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _mk_bin(), _mk_quantifier(), _py2expr(), _to_sort_ref(), _z3_check_cint_overflow(), DatatypeSortRef.accessor(), And(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), RatNumRef.as_long(), AsArray(), Solver.assert_and_track(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), FiniteSetSortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), CreatePolymorphicDatatype(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FreshConst(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), IsInt(), K(), ExprRef.kind(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), QuantifierRef.pattern(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Update(), ExprRef.update(), DatatypeRef.update_field(), ParamsRef.validate(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().

◆ _z3_check_cint_overflow()

_z3_check_cint_overflow (   n,
  name 
)
protected

Definition at line 118 of file z3py.py.

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

◆ Abs()

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

Definition at line 9734 of file z3py.py.

9734def Abs(arg):
9735 """Create the absolute value of an arithmetic expression"""
9736 return If(arg > 0, arg, -arg)
9737
9738

Referenced by ArithRef.__abs__().

◆ AllChar()

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

Definition at line 12187 of file z3py.py.

12187def AllChar(regex_sort, ctx=None):
12188 """Create a regular expression that accepts all single character strings
12189 """
12190 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
12191
12192# Special Relations
12193
12194
Z3_mk_re_allchar
Z3_ast Z3_API Z3_mk_re_allchar(Z3_context c, Z3_sort regex_sort)
Create a regular expression that accepts all singleton sequences of the regular expression sort.

◆ And()

And ( *  args) 
Create a Z3 and-expression or and-probe.

>>> p, q, r = Bools('p q r')
>>> And(p, q, r)
And(p, q, r)
>>> P = BoolVector('p', 5)
>>> And(P)
And(p__0, p__1, p__2, p__3, p__4)

Definition at line 1988 of file z3py.py.

1988def And(*args):
1989 """Create a Z3 and-expression or and-probe.
1990
1991 >>> p, q, r = Bools('p q r')
1992 >>> And(p, q, r)
1993 And(p, q, r)
1994 >>> P = BoolVector('p', 5)
1995 >>> And(P)
1996 And(p__0, p__1, p__2, p__3, p__4)
1997 """
1998 last_arg = None
1999 if len(args) > 0:
2000 last_arg = args[len(args) - 1]
2001 if isinstance(last_arg, Context):
2002 ctx = args[len(args) - 1]
2003 args = args[:len(args) - 1]
2004 elif len(args) == 1 and isinstance(args[0], AstVector):
2005 ctx = args[0].ctx
2006 args = [a for a in args[0]]
2007 else:
2008 ctx = None
2009 args = _get_args(args)
2010 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
2011 if z3_debug():
2012 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
2013 if _has_probe(args):
2014 return _probe_and(args, ctx)
2015 else:
2016 args = _coerce_expr_list(args, ctx)
2017 _args, sz = _to_ast_array(args)
2018 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
2019
2020
Z3_mk_and
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 9099 of file z3py.py.

9099def AndThen(*ts, **ks):
9100 """Return a tactic that applies the tactics in `*ts` in sequence.
9101
9102 >>> x, y = Ints('x y')
9103 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
9104 >>> t(And(x == 0, y > x + 1))
9105 [[Not(y <= 1)]]
9106 >>> t(And(x == 0, y > x + 1)).as_expr()
9107 Not(y <= 1)
9108 """
9109 if z3_debug():
9110 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9111 ctx = ks.get("ctx", None)
9112 num = len(ts)
9113 r = ts[0]
9114 for i in range(num - 1):
9115 r = _and_then(r, ts[i + 1], ctx)
9116 return r
9117
9118

◆ append_log()

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

Definition at line 127 of file z3py.py.

127def append_log(s):
128 """Append user-defined string to interaction log. """
129 Z3_append_log(s)
130
131
Z3_append_log
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.

◆ args2params()

args2params (   arguments,
  keywords,
  ctx = None 
) 
Convert python arguments into a Z3_params object.
A ':' is added to the keywords, and '_' is replaced with '-'

>>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
(params model true relevancy 2 elim_and true)

Definition at line 6078 of file z3py.py.

6078def args2params(arguments, keywords, ctx=None):
6079 """Convert python arguments into a Z3_params object.
6080 A ':' is added to the keywords, and '_' is replaced with '-'
6081
6082 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
6083 (params model true relevancy 2 elim_and true)
6084 """
6085 if z3_debug():
6086 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
6087 prev = None
6088 r = ParamsRef(ctx)
6089 for a in arguments:
6090 if prev is None:
6091 prev = a
6092 else:
6093 r.set(prev, a)
6094 prev = None
6095 for k in keywords:
6096 v = keywords[k]
6097 r.set(k, v)
6098 return r
6099
6100

Referenced by Solver.set().

◆ Array()

Array (   name,
*  sorts 
) 
Return an array constant named `name` with the given domain and range sorts.

>>> a = Array('a', IntSort(), IntSort())
>>> a.sort()
Array(Int, Int)
>>> a[0]
a[0]

Definition at line 4968 of file z3py.py.

4968def Array(name, *sorts):
4969 """Return an array constant named `name` with the given domain and range sorts.
4970
4971 >>> a = Array('a', IntSort(), IntSort())
4972 >>> a.sort()
4973 Array(Int, Int)
4974 >>> a[0]
4975 a[0]
4976 """
4977 s = ArraySort(sorts)
4978 ctx = s.ctx
4979 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4980
4981
Z3_mk_const
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.

◆ ArraySort()

ArraySort ( *  sig) 
Return the Z3 array sort with the given domain and range sorts.

>>> A = ArraySort(IntSort(), BoolSort())
>>> A
Array(Int, Bool)
>>> A.domain()
Int
>>> A.range()
Bool
>>> AA = ArraySort(IntSort(), A)
>>> AA
Array(Int, Array(Int, Bool))

Definition at line 4935 of file z3py.py.

4935def ArraySort(*sig):
4936 """Return the Z3 array sort with the given domain and range sorts.
4937
4938 >>> A = ArraySort(IntSort(), BoolSort())
4939 >>> A
4940 Array(Int, Bool)
4941 >>> A.domain()
4942 Int
4943 >>> A.range()
4944 Bool
4945 >>> AA = ArraySort(IntSort(), A)
4946 >>> AA
4947 Array(Int, Array(Int, Bool))
4948 """
4949 sig = _get_args(sig)
4950 if z3_debug():
4951 _z3_assert(len(sig) > 1, "At least two arguments expected")
4952 arity = len(sig) - 1
4953 r = sig[arity]
4954 d = sig[0]
4955 if z3_debug():
4956 for s in sig:
4957 _z3_assert(is_sort(s), "Z3 sort expected")
4958 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4959 ctx = d.ctx
4960 if len(sig) == 2:
4961 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4962 dom = (Sort * arity)()
4963 for i in range(arity):
4964 dom[i] = sig[i].ast
4965 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4966
4967
Z3_mk_array_sort_n
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_mk_array_sort
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.

Referenced by SortRef.__gt__(), Array(), and SetSort().

◆ AsArray()

AsArray (   f) 
Return a Z3 as-array expression for the given function declaration.

>>> f = Function('f', IntSort(), IntSort())
>>> a = AsArray(f)
>>> a.sort()
Array(Int, Int)
>>> is_as_array(a)
True
>>> get_as_array_func(a) == f
True

Definition at line 5115 of file z3py.py.

5115def AsArray(f):
5116 """Return a Z3 as-array expression for the given function declaration.
5117
5118 >>> f = Function('f', IntSort(), IntSort())
5119 >>> a = AsArray(f)
5120 >>> a.sort()
5121 Array(Int, Int)
5122 >>> is_as_array(a)
5123 True
5124 >>> get_as_array_func(a) == f
5125 True
5126 """
5127 if z3_debug():
5128 _z3_assert(isinstance(f, FuncDeclRef), "function declaration expected")
5129 ctx = f.ctx
5130 return ArrayRef(Z3_mk_as_array(ctx.ref(), f.ast), ctx)
5131
5132
Z3_mk_as_array
Z3_ast Z3_API Z3_mk_as_array(Z3_context c, Z3_func_decl f)
Create array with the same interpretation as a function. The array satisfies the property (f x) = (se...

Referenced by FiniteSetFilter(), and FiniteSetMap().

◆ AtLeast()

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

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

Definition at line 9757 of file z3py.py.

9757def AtLeast(*args):
9758 """Create an at-least Pseudo-Boolean k constraint.
9759
9760 >>> a, b, c = Bools('a b c')
9761 >>> f = AtLeast(a, b, c, 2)
9762 """
9763 args = _get_args(args)
9764 if z3_debug():
9765 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9766 ctx = _ctx_from_ast_arg_list(args)
9767 if z3_debug():
9768 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9769 args1 = _coerce_expr_list(args[:-1], ctx)
9770 k = args[-1]
9771 _args, sz = _to_ast_array(args1)
9772 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9773
9774
Z3_mk_atleast
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 9739 of file z3py.py.

9739def AtMost(*args):
9740 """Create an at-most Pseudo-Boolean k constraint.
9741
9742 >>> a, b, c = Bools('a b c')
9743 >>> f = AtMost(a, b, c, 2)
9744 """
9745 args = _get_args(args)
9746 if z3_debug():
9747 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9748 ctx = _ctx_from_ast_arg_list(args)
9749 if z3_debug():
9750 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9751 args1 = _coerce_expr_list(args[:-1], ctx)
9752 k = args[-1]
9753 _args, sz = _to_ast_array(args1)
9754 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9755
9756
Z3_mk_atmost
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.

◆ BitVec()

BitVec (   name,
  bv,
  ctx = None 
) 
Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
If `ctx=None`, then the global context is used.

>>> x  = BitVec('x', 16)
>>> is_bv(x)
True
>>> x.size()
16
>>> x.sort()
BitVec(16)
>>> word = BitVecSort(16)
>>> x2 = BitVec('x', word)
>>> eq(x, x2)
True

Definition at line 4210 of file z3py.py.

4210def BitVec(name, bv, ctx=None):
4211 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4212 If `ctx=None`, then the global context is used.
4213
4214 >>> x = BitVec('x', 16)
4215 >>> is_bv(x)
4216 True
4217 >>> x.size()
4218 16
4219 >>> x.sort()
4220 BitVec(16)
4221 >>> word = BitVecSort(16)
4222 >>> x2 = BitVec('x', word)
4223 >>> eq(x, x2)
4224 True
4225 """
4226 if isinstance(bv, BitVecSortRef):
4227 ctx = bv.ctx
4228 else:
4229 ctx = _get_ctx(ctx)
4230 bv = BitVecSort(bv, ctx)
4231 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4232
4233

Referenced by BitVecs().

◆ BitVecs()

BitVecs (   names,
  bv,
  ctx = None 
) 
Return a tuple of bit-vector constants of size bv.

>>> x, y, z = BitVecs('x y z', 16)
>>> x.size()
16
>>> x.sort()
BitVec(16)
>>> Sum(x, y, z)
0 + x + y + z
>>> Product(x, y, z)
1*x*y*z
>>> simplify(Product(x, y, z))
x*y*z

Definition at line 4234 of file z3py.py.

4234def BitVecs(names, bv, ctx=None):
4235 """Return a tuple of bit-vector constants of size bv.
4236
4237 >>> x, y, z = BitVecs('x y z', 16)
4238 >>> x.size()
4239 16
4240 >>> x.sort()
4241 BitVec(16)
4242 >>> Sum(x, y, z)
4243 0 + x + y + z
4244 >>> Product(x, y, z)
4245 1*x*y*z
4246 >>> simplify(Product(x, y, z))
4247 x*y*z
4248 """
4249 ctx = _get_ctx(ctx)
4250 if isinstance(names, str):
4251 names = names.split(" ")
4252 return [BitVec(name, bv, ctx) for name in names]
4253
4254

◆ BitVecSort()

BitVecSort (   sz,
  ctx = None 
) 
Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.

>>> Byte = BitVecSort(8)
>>> Word = BitVecSort(16)
>>> Byte
BitVec(8)
>>> x = Const('x', Byte)
>>> eq(x, BitVec('x', 8))
True

Definition at line 4178 of file z3py.py.

4178def BitVecSort(sz, ctx=None):
4179 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4180
4181 >>> Byte = BitVecSort(8)
4182 >>> Word = BitVecSort(16)
4183 >>> Byte
4184 BitVec(8)
4185 >>> x = Const('x', Byte)
4186 >>> eq(x, BitVec('x', 8))
4187 True
4188 """
4189 ctx = _get_ctx(ctx)
4190 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4191
4192
Z3_mk_bv_sort
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.

Referenced by BitVec(), and BitVecVal().

◆ BitVecVal()

BitVecVal (   val,
  bv,
  ctx = None 
) 
Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.

>>> v = BitVecVal(10, 32)
>>> v
10
>>> print("0x%.8x" % v.as_long())
0x0000000a

Definition at line 4193 of file z3py.py.

4193def BitVecVal(val, bv, ctx=None):
4194 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4195
4196 >>> v = BitVecVal(10, 32)
4197 >>> v
4198 10
4199 >>> print("0x%.8x" % v.as_long())
4200 0x0000000a
4201 """
4202 if is_bv_sort(bv):
4203 ctx = bv.ctx
4204 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4205 else:
4206 ctx = _get_ctx(ctx)
4207 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4208
4209
Z3_mk_numeral
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.

◆ Bool()

Bool (   name,
  ctx = None 
) 
Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.

>>> p = Bool('p')
>>> q = Bool('q')
>>> And(p, q)
And(p, q)

Definition at line 1867 of file z3py.py.

1867def Bool(name, ctx=None):
1868 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1869
1870 >>> p = Bool('p')
1871 >>> q = Bool('q')
1872 >>> And(p, q)
1873 And(p, q)
1874 """
1875 ctx = _get_ctx(ctx)
1876 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1877
1878

Referenced by Solver.assert_and_track(), Bools(), and BoolVector().

◆ Bools()

Bools (   names,
  ctx = None 
) 
Return a tuple of Boolean constants.

`names` is a single string containing all names separated by blank spaces.
If `ctx=None`, then the global context is used.

>>> p, q, r = Bools('p q r')
>>> And(p, Or(q, r))
And(p, Or(q, r))

Definition at line 1879 of file z3py.py.

1879def Bools(names, ctx=None):
1880 """Return a tuple of Boolean constants.
1881
1882 `names` is a single string containing all names separated by blank spaces.
1883 If `ctx=None`, then the global context is used.
1884
1885 >>> p, q, r = Bools('p q r')
1886 >>> And(p, Or(q, r))
1887 And(p, Or(q, r))
1888 """
1889 ctx = _get_ctx(ctx)
1890 if isinstance(names, str):
1891 names = names.split(" ")
1892 return [Bool(name, ctx) for name in names]
1893
1894

◆ BoolSort()

BoolSort (   ctx = None) 
Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.

>>> BoolSort()
Bool
>>> p = Const('p', BoolSort())
>>> is_bool(p)
True
>>> r = Function('r', IntSort(), IntSort(), BoolSort())
>>> r(0, 1)
r(0, 1)
>>> is_bool(r(0, 1))
True

Definition at line 1830 of file z3py.py.

1830def BoolSort(ctx=None):
1831 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1832
1833 >>> BoolSort()
1834 Bool
1835 >>> p = Const('p', BoolSort())
1836 >>> is_bool(p)
1837 True
1838 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1839 >>> r(0, 1)
1840 r(0, 1)
1841 >>> is_bool(r(0, 1))
1842 True
1843 """
1844 ctx = _get_ctx(ctx)
1845 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1846
1847
Z3_mk_bool_sort
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 1848 of file z3py.py.

1848def BoolVal(val, ctx=None):
1849 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1850
1851 >>> BoolVal(True)
1852 True
1853 >>> is_true(BoolVal(True))
1854 True
1855 >>> is_true(True)
1856 False
1857 >>> is_false(BoolVal(False))
1858 True
1859 """
1860 ctx = _get_ctx(ctx)
1861 if val:
1862 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1863 else:
1864 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1865
1866
Z3_mk_true
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_mk_false
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 1895 of file z3py.py.

1895def BoolVector(prefix, sz, ctx=None):
1896 """Return a list of Boolean constants of size `sz`.
1897
1898 The constants are named using the given prefix.
1899 If `ctx=None`, then the global context is used.
1900
1901 >>> P = BoolVector('p', 3)
1902 >>> P
1903 [p__0, p__1, p__2]
1904 >>> And(P)
1905 And(p__0, p__1, p__2)
1906 """
1907 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1908
1909

◆ BV2Int()

BV2Int (   a,
  is_signed = False 
) 
Return the Z3 expression BV2Int(a).

>>> b = BitVec('b', 3)
>>> BV2Int(b).sort()
Int
>>> x = Int('x')
>>> x > BV2Int(b)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=False)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=True)
x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
>>> solve(x > BV2Int(b), b == 1, x < 3)
[x = 2, b = 1]

Definition at line 4146 of file z3py.py.

4146def BV2Int(a, is_signed=False):
4147 """Return the Z3 expression BV2Int(a).
4148
4149 >>> b = BitVec('b', 3)
4150 >>> BV2Int(b).sort()
4151 Int
4152 >>> x = Int('x')
4153 >>> x > BV2Int(b)
4154 x > BV2Int(b)
4155 >>> x > BV2Int(b, is_signed=False)
4156 x > BV2Int(b)
4157 >>> x > BV2Int(b, is_signed=True)
4158 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4159 >>> solve(x > BV2Int(b), b == 1, x < 3)
4160 [x = 2, b = 1]
4161 """
4162 if z3_debug():
4163 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4164 ctx = a.ctx
4165 # investigate problem with bv2int
4166 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
4167
4168
Z3_mk_bv2int
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast t1, bool is_signed)
Create an integer from the bit-vector argument t1. If is_signed is false, then the bit-vector t1 is t...

◆ BVAddNoOverflow()

BVAddNoOverflow (   a,
  b,
  signed 
) 
A predicate the determines that bit-vector addition does not overflow

Definition at line 4694 of file z3py.py.

4694def BVAddNoOverflow(a, b, signed):
4695 """A predicate the determines that bit-vector addition does not overflow"""
4696 _check_bv_args(a, b)
4697 a, b = _coerce_exprs(a, b)
4698 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4699
4700
Z3_mk_bvadd_no_overflow
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.

◆ BVAddNoUnderflow()

BVAddNoUnderflow (   a,
  b 
) 
A predicate the determines that signed bit-vector addition does not underflow

Definition at line 4701 of file z3py.py.

4701def BVAddNoUnderflow(a, b):
4702 """A predicate the determines that signed bit-vector addition does not underflow"""
4703 _check_bv_args(a, b)
4704 a, b = _coerce_exprs(a, b)
4705 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4706
4707
Z3_mk_bvadd_no_underflow
Z3_ast Z3_API Z3_mk_bvadd_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed addition of t1 and t2 does not underflow.

◆ BVMulNoOverflow()

BVMulNoOverflow (   a,
  b,
  signed 
) 
A predicate the determines that bit-vector multiplication does not overflow

Definition at line 4736 of file z3py.py.

4736def BVMulNoOverflow(a, b, signed):
4737 """A predicate the determines that bit-vector multiplication does not overflow"""
4738 _check_bv_args(a, b)
4739 a, b = _coerce_exprs(a, b)
4740 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4741
4742
Z3_mk_bvmul_no_overflow
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise multiplication of t1 and t2 does not overflow.

◆ BVMulNoUnderflow()

BVMulNoUnderflow (   a,
  b 
) 
A predicate the determines that bit-vector signed multiplication does not underflow

Definition at line 4743 of file z3py.py.

4743def BVMulNoUnderflow(a, b):
4744 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4745 _check_bv_args(a, b)
4746 a, b = _coerce_exprs(a, b)
4747 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4748
4749
Z3_mk_bvmul_no_underflow
Z3_ast Z3_API Z3_mk_bvmul_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed multiplication of t1 and t2 does not underflo...

◆ BvNand()

BvNand (   a,
  b 
) 
Return the bitwise NAND of `a` and `b`.

>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvNand(x, y)
bvnand(x, y)

Definition at line 4655 of file z3py.py.

4655def BvNand(a, b):
4656 """Return the bitwise NAND of `a` and `b`.
4657
4658 >>> x = BitVec('x', 8)
4659 >>> y = BitVec('y', 8)
4660 >>> BvNand(x, y)
4661 bvnand(x, y)
4662 """
4663 _check_bv_args(a, b)
4664 a, b = _coerce_exprs(a, b)
4665 return BitVecRef(Z3_mk_bvnand(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4666
4667
Z3_mk_bvnand
Z3_ast Z3_API Z3_mk_bvnand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nand.

◆ BvNor()

BvNor (   a,
  b 
) 
Return the bitwise NOR of `a` and `b`.

>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvNor(x, y)
bvnor(x, y)

Definition at line 4668 of file z3py.py.

4668def BvNor(a, b):
4669 """Return the bitwise NOR of `a` and `b`.
4670
4671 >>> x = BitVec('x', 8)
4672 >>> y = BitVec('y', 8)
4673 >>> BvNor(x, y)
4674 bvnor(x, y)
4675 """
4676 _check_bv_args(a, b)
4677 a, b = _coerce_exprs(a, b)
4678 return BitVecRef(Z3_mk_bvnor(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4679
4680
Z3_mk_bvnor
Z3_ast Z3_API Z3_mk_bvnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nor.

◆ BVRedAnd()

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

Definition at line 4641 of file z3py.py.

4641def BVRedAnd(a):
4642 """Return the reduction-and expression of `a`."""
4643 if z3_debug():
4644 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4645 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4646
4647
Z3_mk_bvredand
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.

◆ BVRedOr()

BVRedOr (   a) 
Return the reduction-or expression of `a`.

Definition at line 4648 of file z3py.py.

4648def BVRedOr(a):
4649 """Return the reduction-or expression of `a`."""
4650 if z3_debug():
4651 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4652 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4653
4654
Z3_mk_bvredor
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.

◆ BVSDivNoOverflow()

BVSDivNoOverflow (   a,
  b 
) 
A predicate the determines that bit-vector signed division does not overflow

Definition at line 4722 of file z3py.py.

4722def BVSDivNoOverflow(a, b):
4723 """A predicate the determines that bit-vector signed division does not overflow"""
4724 _check_bv_args(a, b)
4725 a, b = _coerce_exprs(a, b)
4726 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4727
4728
Z3_mk_bvsdiv_no_overflow
Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed division of t1 and t2 does not overflow.

◆ BVSNegNoOverflow()

BVSNegNoOverflow (   a) 
A predicate the determines that bit-vector unary negation does not overflow

Definition at line 4729 of file z3py.py.

4729def BVSNegNoOverflow(a):
4730 """A predicate the determines that bit-vector unary negation does not overflow"""
4731 if z3_debug():
4732 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4733 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4734
4735
Z3_mk_bvneg_no_overflow
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.

◆ BVSubNoOverflow()

BVSubNoOverflow (   a,
  b 
) 
A predicate the determines that bit-vector subtraction does not overflow

Definition at line 4708 of file z3py.py.

4708def BVSubNoOverflow(a, b):
4709 """A predicate the determines that bit-vector subtraction does not overflow"""
4710 _check_bv_args(a, b)
4711 a, b = _coerce_exprs(a, b)
4712 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4713
4714
Z3_mk_bvsub_no_overflow
Z3_ast Z3_API Z3_mk_bvsub_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed subtraction of t1 and t2 does not overflow.

◆ BVSubNoUnderflow()

BVSubNoUnderflow (   a,
  b,
  signed 
) 
A predicate the determines that bit-vector subtraction does not underflow

Definition at line 4715 of file z3py.py.

4715def BVSubNoUnderflow(a, b, signed):
4716 """A predicate the determines that bit-vector subtraction does not underflow"""
4717 _check_bv_args(a, b)
4718 a, b = _coerce_exprs(a, b)
4719 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4720
4721
Z3_mk_bvsub_no_underflow
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.

◆ BvXnor()

BvXnor (   a,
  b 
) 
Return the bitwise XNOR of `a` and `b`.

>>> x = BitVec('x', 8)
>>> y = BitVec('y', 8)
>>> BvXnor(x, y)
bvxnor(x, y)

Definition at line 4681 of file z3py.py.

4681def BvXnor(a, b):
4682 """Return the bitwise XNOR of `a` and `b`.
4683
4684 >>> x = BitVec('x', 8)
4685 >>> y = BitVec('y', 8)
4686 >>> BvXnor(x, y)
4687 bvxnor(x, y)
4688 """
4689 _check_bv_args(a, b)
4690 a, b = _coerce_exprs(a, b)
4691 return BitVecRef(Z3_mk_bvxnor(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4692
4693
Z3_mk_bvxnor
Z3_ast Z3_API Z3_mk_bvxnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise xnor.

◆ Cbrt()

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

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

Definition at line 3592 of file z3py.py.

3592def Cbrt(a, ctx=None):
3593 """ Return a Z3 expression which represents the cubic root of a.
3594
3595 >>> x = Real('x')
3596 >>> Cbrt(x)
3597 x**(1/3)
3598 """
3599 if not is_expr(a):
3600 ctx = _get_ctx(ctx)
3601 a = RealVal(a, ctx)
3602 return a ** "1/3"
3603

◆ CharFromBv()

CharFromBv (   bv)

Definition at line 11671 of file z3py.py.

11671def CharFromBv(bv):
11672 if not is_expr(bv):
11673 raise Z3Exception("Bit-vector expression needed")
11674 return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
11675
Z3_mk_char_from_bv
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 11684 of file z3py.py.

11684def CharIsDigit(ch, ctx=None):
11685 ch = _coerce_char(ch, ctx)
11686 return ch.is_digit()
11687

◆ CharSort()

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

Definition at line 11567 of file z3py.py.

11567def CharSort(ctx=None):
11568 """Create a character sort
11569 >>> ch = CharSort()
11570 >>> print(ch)
11571 Char
11572 """
11573 ctx = _get_ctx(ctx)
11574 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
11575
11576
Z3_mk_char_sort
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 11676 of file z3py.py.

11676def CharToBv(ch, ctx=None):
11677 ch = _coerce_char(ch, ctx)
11678 return ch.to_bv()
11679

◆ CharToInt()

CharToInt (   ch,
  ctx = None 
)

Definition at line 11680 of file z3py.py.

11680def CharToInt(ch, ctx=None):
11681 ch = _coerce_char(ch, ctx)
11682 return ch.to_int()
11683

◆ CharVal()

CharVal (   ch,
  ctx = None 
)

Definition at line 11663 of file z3py.py.

11663def CharVal(ch, ctx=None):
11664 ctx = _get_ctx(ctx)
11665 if isinstance(ch, str):
11666 ch = ord(ch)
11667 if not isinstance(ch, int):
11668 raise Z3Exception("character value should be an ordinal")
11669 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
11670
Z3_mk_char
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 12129 of file z3py.py.

12129def Complement(re):
12130 """Create the complement regular expression."""
12131 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
12132
12133
Z3_mk_re_complement
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 4255 of file z3py.py.

4255def Concat(*args):
4256 """Create a Z3 bit-vector concatenation expression.
4257
4258 >>> v = BitVecVal(1, 4)
4259 >>> Concat(v, v+1, v)
4260 Concat(Concat(1, 1 + 1), 1)
4261 >>> simplify(Concat(v, v+1, v))
4262 289
4263 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4264 121
4265 """
4266 args = _get_args(args)
4267 sz = len(args)
4268 if z3_debug():
4269 _z3_assert(sz >= 2, "At least two arguments expected.")
4270
4271 ctx = None
4272 for a in args:
4273 if is_expr(a):
4274 ctx = a.ctx
4275 break
4276 if is_seq(args[0]) or isinstance(args[0], str):
4277 args = [_coerce_seq(s, ctx) for s in args]
4278 if z3_debug():
4279 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4280 v = (Ast * sz)()
4281 for i in range(sz):
4282 v[i] = args[i].as_ast()
4283 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4284
4285 if is_re(args[0]):
4286 if z3_debug():
4287 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4288 v = (Ast * sz)()
4289 for i in range(sz):
4290 v[i] = args[i].as_ast()
4291 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4292
4293 if z3_debug():
4294 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4295 r = args[0]
4296 for i in range(sz - 1):
4297 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4298 return r
4299
4300
Z3_mk_seq_concat
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_mk_re_concat
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_mk_concat
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 9556 of file z3py.py.

9556def Cond(p, t1, t2, ctx=None):
9557 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
9558
9559 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
9560 """
9561 p = _to_probe(p, ctx)
9562 t1 = _to_tactic(t1, ctx)
9563 t2 = _to_tactic(t2, ctx)
9564 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
9565
Z3_tactic_cond
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...

Referenced by If().

◆ Const()

Const (   name,
  sort 
) 
Create a constant of the given sort.

>>> Const('x', IntSort())
x

Definition at line 1546 of file z3py.py.

1546def Const(name, sort):
1547 """Create a constant of the given sort.
1548
1549 >>> Const('x', IntSort())
1550 x
1551 """
1552 if z3_debug():
1553 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1554 ctx = sort.ctx
1555 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1556
1557

Referenced by Consts().

◆ Consts()

Consts (   names,
  sort 
) 
Create several constants of the given sort.

`names` is a string containing the names of all constants to be created.
Blank spaces separate the names of different constants.

>>> x, y, z = Consts('x y z', IntSort())
>>> x + y + z
x + y + z

Definition at line 1558 of file z3py.py.

1558def Consts(names, sort):
1559 """Create several constants of the given sort.
1560
1561 `names` is a string containing the names of all constants to be created.
1562 Blank spaces separate the names of different constants.
1563
1564 >>> x, y, z = Consts('x y z', IntSort())
1565 >>> x + y + z
1566 x + y + z
1567 """
1568 if isinstance(names, str):
1569 names = names.split(" ")
1570 return [Const(name, sort) for name in names]
1571
1572

◆ Contains()

Contains (   a,
  b 
) 
Check if 'a' contains 'b'
>>> s1 = Contains("abc", "ab")
>>> simplify(s1)
True
>>> s2 = Contains("abc", "bc")
>>> simplify(s2)
True
>>> x, y, z = Strings('x y z')
>>> s3 = Contains(Concat(x,y,z), y)
>>> simplify(s3)
True

Definition at line 11858 of file z3py.py.

11858def Contains(a, b):
11859 """Check if 'a' contains 'b'
11860 >>> s1 = Contains("abc", "ab")
11861 >>> simplify(s1)
11862 True
11863 >>> s2 = Contains("abc", "bc")
11864 >>> simplify(s2)
11865 True
11866 >>> x, y, z = Strings('x y z')
11867 >>> s3 = Contains(Concat(x,y,z), y)
11868 >>> simplify(s3)
11869 True
11870 """
11871 ctx = _get_ctx2(a, b)
11872 a = _coerce_seq(a, ctx)
11873 b = _coerce_seq(b, ctx)
11874 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11875
11876
Z3_mk_seq_contains
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.

◆ CreateDatatypes()

CreateDatatypes ( *  ds) 
Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.

In the following example we define a Tree-List using two mutually recursive datatypes.

>>> TreeList = Datatype('TreeList')
>>> Tree     = Datatype('Tree')
>>> # Tree has two constructors: leaf and node
>>> Tree.declare('leaf', ('val', IntSort()))
>>> # a node contains a list of trees
>>> Tree.declare('node', ('children', TreeList))
>>> TreeList.declare('nil')
>>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
>>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
>>> Tree.val(Tree.leaf(10))
val(leaf(10))
>>> simplify(Tree.val(Tree.leaf(10)))
10
>>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
>>> n1
node(cons(leaf(10), cons(leaf(20), nil)))
>>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
>>> simplify(n2 == n1)
False
>>> simplify(TreeList.car(Tree.children(n2)) == n1)
True

Definition at line 5654 of file z3py.py.

5654def CreateDatatypes(*ds):
5655 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5656
5657 In the following example we define a Tree-List using two mutually recursive datatypes.
5658
5659 >>> TreeList = Datatype('TreeList')
5660 >>> Tree = Datatype('Tree')
5661 >>> # Tree has two constructors: leaf and node
5662 >>> Tree.declare('leaf', ('val', IntSort()))
5663 >>> # a node contains a list of trees
5664 >>> Tree.declare('node', ('children', TreeList))
5665 >>> TreeList.declare('nil')
5666 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5667 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5668 >>> Tree.val(Tree.leaf(10))
5669 val(leaf(10))
5670 >>> simplify(Tree.val(Tree.leaf(10)))
5671 10
5672 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5673 >>> n1
5674 node(cons(leaf(10), cons(leaf(20), nil)))
5675 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5676 >>> simplify(n2 == n1)
5677 False
5678 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5679 True
5680 """
5681 ds = _get_args(ds)
5682 if z3_debug():
5683 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5684 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5685 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5686 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5687 ctx = ds[0].ctx
5688 num = len(ds)
5689 names = (Symbol * num)()
5690 out = (Sort * num)()
5691 clists = (ConstructorList * num)()
5692 to_delete = []
5693 for i in range(num):
5694 d = ds[i]
5695 names[i] = to_symbol(d.name, ctx)
5696 num_cs = len(d.constructors)
5697 cs = (Constructor * num_cs)()
5698 for j in range(num_cs):
5699 c = d.constructors[j]
5700 cname = to_symbol(c[0], ctx)
5701 rname = to_symbol(c[1], ctx)
5702 fs = c[2]
5703 num_fs = len(fs)
5704 fnames = (Symbol * num_fs)()
5705 sorts = (Sort * num_fs)()
5706 refs = (ctypes.c_uint * num_fs)()
5707 for k in range(num_fs):
5708 fname = fs[k][0]
5709 ftype = fs[k][1]
5710 fnames[k] = to_symbol(fname, ctx)
5711 if isinstance(ftype, Datatype):
5712 if z3_debug():
5713 _z3_assert(
5714 ds.count(ftype) == 1,
5715 "One and only one occurrence of each datatype is expected",
5716 )
5717 sorts[k] = None
5718 refs[k] = ds.index(ftype)
5719 else:
5720 if z3_debug():
5721 _z3_assert(is_sort(ftype), "Z3 sort expected")
5722 sorts[k] = ftype.ast
5723 refs[k] = 0
5724 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5725 to_delete.append(ScopedConstructor(cs[j], ctx))
5726 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5727 to_delete.append(ScopedConstructorList(clists[i], ctx))
5728 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5729 result = []
5730 # Create a field for every constructor, recognizer and accessor
5731 for i in range(num):
5732 dref = DatatypeSortRef(out[i], ctx)
5733 num_cs = dref.num_constructors()
5734 for j in range(num_cs):
5735 cref = dref.constructor(j)
5736 cref_name = cref.name()
5737 cref_arity = cref.arity()
5738 if cref.arity() == 0:
5739 cref = cref()
5740 setattr(dref, cref_name, cref)
5741 rref = dref.recognizer(j)
5742 setattr(dref, "is_" + cref_name, rref)
5743 for k in range(cref_arity):
5744 aref = dref.accessor(j, k)
5745 setattr(dref, aref.name(), aref)
5746 result.append(dref)
5747 return tuple(result)
5748
5749
Z3_mk_datatypes
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_mk_constructor_list
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
Z3_mk_constructor
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort const sorts[], unsigned sort_refs[])
Create a constructor.

Referenced by Datatype.create().

◆ CreatePolymorphicDatatype()

CreatePolymorphicDatatype (   d,
  type_params 
) 
Create a single polymorphic Z3 datatype with explicit type parameters.

`d` is a `Datatype` helper object whose constructors have been declared.
`type_params` is a list of type variables created with `DeclareTypeVar`.
Constructor field sorts may reference these type variables, and self-recursive
fields may reference `d` directly.

>>> A = DeclareTypeVar('A')
>>> Pair = Datatype('Pair')
>>> Pair.declare('pair', ('fst', A), ('snd', A))
>>> Pair = CreatePolymorphicDatatype(Pair, [A])

Definition at line 5750 of file z3py.py.

5750def CreatePolymorphicDatatype(d, type_params):
5751 """Create a single polymorphic Z3 datatype with explicit type parameters.
5752
5753 `d` is a `Datatype` helper object whose constructors have been declared.
5754 `type_params` is a list of type variables created with `DeclareTypeVar`.
5755 Constructor field sorts may reference these type variables, and self-recursive
5756 fields may reference `d` directly.
5757
5758 >>> A = DeclareTypeVar('A')
5759 >>> Pair = Datatype('Pair')
5760 >>> Pair.declare('pair', ('fst', A), ('snd', A))
5761 >>> Pair = CreatePolymorphicDatatype(Pair, [A])
5762 """
5763 if z3_debug():
5764 _z3_assert(isinstance(d, Datatype), "Datatype expected")
5765 _z3_assert(d.constructors != [], "Non-empty Datatype expected")
5766 ctx = d.ctx
5767 name = to_symbol(d.name, ctx)
5768 num_params = len(type_params)
5769 params_arr = (Sort * num_params)()
5770 for i, p in enumerate(type_params):
5771 if z3_debug():
5772 _z3_assert(is_sort(p), "Z3 sort expected for type parameter")
5773 params_arr[i] = p.ast
5774 num_cs = len(d.constructors)
5775 cs = (Constructor * num_cs)()
5776 to_delete = []
5777 for j in range(num_cs):
5778 c = d.constructors[j]
5779 cname = to_symbol(c[0], ctx)
5780 rname = to_symbol(c[1], ctx)
5781 fs = c[2]
5782 num_fs = len(fs)
5783 fnames = (Symbol * num_fs)()
5784 sorts = (Sort * num_fs)()
5785 refs = (ctypes.c_uint * num_fs)()
5786 for k in range(num_fs):
5787 fname = fs[k][0]
5788 ftype = fs[k][1]
5789 fnames[k] = to_symbol(fname, ctx)
5790 if isinstance(ftype, Datatype):
5791 if z3_debug():
5792 _z3_assert(ftype is d, "Only self-recursive references are supported in polymorphic datatypes. Use CreateDatatypes for mutually recursive datatypes.")
5793 sorts[k] = None
5794 refs[k] = 0
5795 else:
5796 if z3_debug():
5797 _z3_assert(is_sort(ftype), "Z3 sort expected")
5798 sorts[k] = ftype.ast
5799 refs[k] = 0
5800 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5801 to_delete.append(ScopedConstructor(cs[j], ctx))
5802 out = Z3_mk_polymorphic_datatype(ctx.ref(), name, num_params, params_arr, num_cs, cs)
5803 dref = DatatypeSortRef(out, ctx)
5804 num_cs_actual = dref.num_constructors()
5805 for j in range(num_cs_actual):
5806 cref = dref.constructor(j)
5807 cref_name = cref.name()
5808 cref_arity = cref.arity()
5809 if cref_arity == 0:
5810 cref = cref()
5811 setattr(dref, cref_name, cref)
5812 rref = dref.recognizer(j)
5813 setattr(dref, "is_" + cref_name, rref)
5814 for k in range(cref_arity):
5815 aref = dref.accessor(j, k)
5816 setattr(dref, aref.name(), aref)
5817 return dref
5818
5819
Z3_mk_polymorphic_datatype
Z3_sort Z3_API Z3_mk_polymorphic_datatype(Z3_context c, Z3_symbol name, unsigned num_parameters, Z3_sort parameters[], unsigned num_constructors, Z3_constructor constructors[])
Create a parametric datatype with explicit type parameters.

Referenced by Datatype.create_polymorphic().

◆ DatatypeSort()

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

Args:
    name: name of the datatype sort
    params: optional list/tuple of sort parameters for parametric datatypes
    ctx: Z3 context (optional)

Example:
    >>> # Non-parametric datatype
    >>> TreeRef = DatatypeSort('Tree')
    >>> # Parametric datatype with one parameter
    >>> ListIntRef = DatatypeSort('List', [IntSort()])
    >>> # Parametric datatype with multiple parameters
    >>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])

Definition at line 5950 of file z3py.py.

5950def DatatypeSort(name, params=None, ctx=None):
5951 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype.
5952
5953 Args:
5954 name: name of the datatype sort
5955 params: optional list/tuple of sort parameters for parametric datatypes
5956 ctx: Z3 context (optional)
5957
5958 Example:
5959 >>> # Non-parametric datatype
5960 >>> TreeRef = DatatypeSort('Tree')
5961 >>> # Parametric datatype with one parameter
5962 >>> ListIntRef = DatatypeSort('List', [IntSort()])
5963 >>> # Parametric datatype with multiple parameters
5964 >>> PairRef = DatatypeSort('Pair', [IntSort(), BoolSort()])
5965 """
5966 ctx = _get_ctx(ctx)
5967 if params is None or len(params) == 0:
5968 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), 0, (Sort * 0)()), ctx)
5969 else:
5970 _params = (Sort * len(params))()
5971 for i in range(len(params)):
5972 _params[i] = params[i].ast
5973 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx), len(params), _params), ctx)
5974
Z3_mk_datatype_sort
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name, unsigned num_params, Z3_sort const params[])
create a forward reference to a recursive datatype being declared. The forward reference can be used ...

◆ DeclareSort()

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

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

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

Definition at line 732 of file z3py.py.

732def DeclareSort(name, ctx= None) -> SortRef:
733 """Create a new uninterpreted sort named `name`.
734
735 If `ctx=None`, then the new sort is declared in the global Z3Py context.
736
737 >>> A = DeclareSort('A')
738 >>> a = Const('a', A)
739 >>> b = Const('b', A)
740 >>> a.sort() == A
741 True
742 >>> b.sort() == A
743 True
744 >>> a == b
745 a == b
746 """
747 ctx = _get_ctx(ctx)
748 return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
749
Z3_mk_uninterpreted_sort
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).

◆ DeclareTypeVar()

DeclareTypeVar (   name,
  ctx = None 
) 
Create a new type variable named `name`.

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

Definition at line 760 of file z3py.py.

760def DeclareTypeVar(name, ctx=None):
761 """Create a new type variable named `name`.
762
763 If `ctx=None`, then the new sort is declared in the global Z3Py context.
764
765 """
766 ctx = _get_ctx(ctx)
767 return TypeVarRef(Z3_mk_type_variable(ctx.ref(), to_symbol(name, ctx)), ctx)
768
769
Z3_mk_type_variable
Z3_sort Z3_API Z3_mk_type_variable(Z3_context c, Z3_symbol s)
Create a type variable.

◆ Default()

Default (   a) 
 Return a default value for array expression.
>>> b = K(IntSort(), 1)
>>> prove(Default(b) == 1)
proved

Definition at line 5014 of file z3py.py.

5014def Default(a):
5015 """ Return a default value for array expression.
5016 >>> b = K(IntSort(), 1)
5017 >>> prove(Default(b) == 1)
5018 proved
5019 """
5020 if z3_debug():
5021 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
5022 return a.default()
5023
5024

◆ describe_probes()

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

Definition at line 9477 of file z3py.py.

9477def describe_probes():
9478 """Display a (tabular) description of all available probes in Z3."""
9479 if in_html_mode():
9480 even = True
9481 print('<table border="1" cellpadding="2" cellspacing="0">')
9482 for p in probes():
9483 if even:
9484 print('<tr style="background-color:#CFCFCF">')
9485 even = False
9486 else:
9487 print("<tr>")
9488 even = True
9489 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
9490 print("</table>")
9491 else:
9492 for p in probes():
9493 print("%s : %s" % (p, probe_description(p)))
9494
9495

◆ describe_tactics()

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

Definition at line 9271 of file z3py.py.

9271def describe_tactics():
9272 """Display a (tabular) description of all available tactics in Z3."""
9273 if in_html_mode():
9274 even = True
9275 print('<table border="1" cellpadding="2" cellspacing="0">')
9276 for t in tactics():
9277 if even:
9278 print('<tr style="background-color:#CFCFCF">')
9279 even = False
9280 else:
9281 print("<tr>")
9282 even = True
9283 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
9284 print("</table>")
9285 else:
9286 for t in tactics():
9287 print("%s : %s" % (t, tactic_description(t)))
9288
9289

◆ deserialize()

deserialize (   st) 
inverse function to the serialize method on ExprRef.
It is made available to make it easier for users to serialize expressions back and forth between
strings. Solvers can be serialized using the 'sexpr()' method.

Definition at line 1209 of file z3py.py.

1209def deserialize(st):
1210 """inverse function to the serialize method on ExprRef.
1211 It is made available to make it easier for users to serialize expressions back and forth between
1212 strings. Solvers can be serialized using the 'sexpr()' method.
1213 """
1214 s = Solver()
1215 s.from_string(st)
1216 if len(s.assertions()) != 1:
1217 raise Z3Exception("single assertion expected")
1218 fml = s.assertions()[0]
1219 if fml.num_args() != 1:
1220 raise Z3Exception("dummy function 'F' expected")
1221 return fml.arg(0)
1222

◆ Diff()

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

Definition at line 12179 of file z3py.py.

12179def Diff(a, b, ctx=None):
12180 """Create the difference regular expression
12181 """
12182 if z3_debug():
12183 _z3_assert(is_expr(a), "expression expected")
12184 _z3_assert(is_expr(b), "expression expected")
12185 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
12186
Z3_mk_re_diff
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.

◆ disable_trace()

disable_trace (   msg)

Definition at line 87 of file z3py.py.

87def disable_trace(msg):
88 Z3_disable_trace(msg)
89
90
Z3_disable_trace
void Z3_API Z3_disable_trace(Z3_string tag)
Disable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.

◆ DisjointSum()

DisjointSum (   name,
  sorts,
  ctx = None 
) 
Create a named tagged union sort base on a set of underlying sorts
Example:
    >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])

Definition at line 5987 of file z3py.py.

5987def DisjointSum(name, sorts, ctx=None):
5988 """Create a named tagged union sort base on a set of underlying sorts
5989 Example:
5990 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5991 """
5992 sum = Datatype(name, ctx)
5993 for i in range(len(sorts)):
5994 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5995 sum = sum.create()
5996 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5997
5998

◆ Distinct()

Distinct ( *  args) 
Create a Z3 distinct expression.

>>> x = Int('x')
>>> y = Int('y')
>>> Distinct(x, y)
x != y
>>> z = Int('z')
>>> Distinct(x, y, z)
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z))
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z), blast_distinct=True)
And(Not(x == y), Not(x == z), Not(y == z))

Definition at line 1513 of file z3py.py.

1513def Distinct(*args):
1514 """Create a Z3 distinct expression.
1515
1516 >>> x = Int('x')
1517 >>> y = Int('y')
1518 >>> Distinct(x, y)
1519 x != y
1520 >>> z = Int('z')
1521 >>> Distinct(x, y, z)
1522 Distinct(x, y, z)
1523 >>> simplify(Distinct(x, y, z))
1524 Distinct(x, y, z)
1525 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1526 And(Not(x == y), Not(x == z), Not(y == z))
1527 """
1528 args = _get_args(args)
1529 ctx = _ctx_from_ast_arg_list(args)
1530 if z3_debug():
1531 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1532 args = _coerce_expr_list(args, ctx)
1533 _args, sz = _to_ast_array(args)
1534 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1535
1536
Z3_mk_distinct
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 11788 of file z3py.py.

11788def Empty(s):
11789 """Create the empty sequence of the given sort
11790 >>> e = Empty(StringSort())
11791 >>> e2 = StringVal("")
11792 >>> print(e.eq(e2))
11793 True
11794 >>> e3 = Empty(SeqSort(IntSort()))
11795 >>> print(e3)
11796 Empty(Seq(Int))
11797 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11798 >>> print(e4)
11799 Empty(ReSort(Seq(Int)))
11800 """
11801 if isinstance(s, SeqSortRef):
11802 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11803 if isinstance(s, ReSortRef):
11804 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11805 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11806
11807
Z3_mk_seq_empty
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_mk_re_empty
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 5169 of file z3py.py.

5169def EmptySet(s):
5170 """Create the empty set
5171 >>> EmptySet(IntSort())
5172 K(Int, False)
5173 """
5174 ctx = s.ctx
5175 if is_finite_set_sort(s):
5176 return FiniteSetEmpty(s)
5177 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
5178
5179
Z3_mk_empty_set
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.

◆ enable_trace()

enable_trace (   msg)

Definition at line 83 of file z3py.py.

83def enable_trace(msg):
84 Z3_enable_trace(msg)
85
86
Z3_enable_trace
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 12298 of file z3py.py.

12298def ensure_prop_closures():
12299 global _prop_closures
12300 if _prop_closures is None:
12301 _prop_closures = PropClosures()
12302
12303

◆ EnumSort()

EnumSort (   name,
  values,
  ctx = None 
) 
Return a new enumeration sort named `name` containing the given values.

The result is a pair (sort, list of constants).
Example:
    >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])

Definition at line 5999 of file z3py.py.

5999def EnumSort(name, values, ctx=None):
6000 """Return a new enumeration sort named `name` containing the given values.
6001
6002 The result is a pair (sort, list of constants).
6003 Example:
6004 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
6005 """
6006 if z3_debug():
6007 _z3_assert(isinstance(name, str), "Name must be a string")
6008 _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
6009 _z3_assert(len(values) > 0, "At least one value expected")
6010 ctx = _get_ctx(ctx)
6011 num = len(values)
6012 _val_names = (Symbol * num)()
6013 for i in range(num):
6014 _val_names[i] = to_symbol(values[i], ctx)
6015 _values = (FuncDecl * num)()
6016 _testers = (FuncDecl * num)()
6017 name = to_symbol(name, ctx)
6018 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
6019 V = []
6020 for i in range(num):
6021 V.append(FuncDeclRef(_values[i], ctx))
6022 V = [a() for a in V]
6023 return S, V
6024
Z3_mk_enumeration_sort
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.

◆ eq()

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

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

Definition at line 503 of file z3py.py.

503def eq(a : AstRef, b : AstRef) -> bool:
504 """Return `True` if `a` and `b` are structurally identical AST nodes.
505
506 >>> x = Int('x')
507 >>> y = Int('y')
508 >>> eq(x, y)
509 False
510 >>> eq(x + 1, x + 1)
511 True
512 >>> eq(x + 1, 1 + x)
513 False
514 >>> eq(simplify(x + 1), simplify(1 + x))
515 True
516 """
517 if z3_debug():
518 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
519 return a.eq(b)
520
521

◆ Exists()

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

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


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

Definition at line 2389 of file z3py.py.

2389def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2390 """Create a Z3 exists formula.
2391
2392 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2393
2394
2395 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2396 >>> x = Int('x')
2397 >>> y = Int('y')
2398 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2399 >>> q
2400 Exists([x, y], f(x, y) >= x)
2401 >>> is_quantifier(q)
2402 True
2403 >>> r = Tactic('nnf')(q).as_expr()
2404 >>> is_quantifier(r)
2405 False
2406 """
2407 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2408
2409

◆ Ext()

Ext (   a,
  b 
) 
Return extensionality index for one-dimensional arrays.
>> a, b = Consts('a b', SetSort(IntSort()))
>> Ext(a, b)
Ext(a, b)

Definition at line 5103 of file z3py.py.

5103def Ext(a, b):
5104 """Return extensionality index for one-dimensional arrays.
5105 >> a, b = Consts('a b', SetSort(IntSort()))
5106 >> Ext(a, b)
5107 Ext(a, b)
5108 """
5109 ctx = a.ctx
5110 if z3_debug():
5111 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
5112 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5113
5114
Z3_mk_array_ext
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...

◆ Extract()

Extract (   high,
  low,
  a 
) 
Create a Z3 bit-vector extraction expression or sequence extraction expression.

Extract is overloaded to work with both bit-vectors and sequences:

**Bit-vector extraction**: Extract(high, low, bitvector)
    Extracts bits from position `high` down to position `low` (both inclusive).
    - high: int - the highest bit position to extract (0-indexed from right)
    - low: int - the lowest bit position to extract (0-indexed from right)  
    - bitvector: BitVecRef - the bit-vector to extract from
    Returns a new bit-vector containing bits [high:low]

**Sequence extraction**: Extract(sequence, offset, length)
    Extracts a subsequence starting at the given offset with the specified length.
    The functions SubString and SubSeq are redirected to this form of Extract.
    - sequence: SeqRef or str - the sequence to extract from
    - offset: int - the starting position (0-indexed)
    - length: int - the number of elements to extract
    Returns a new sequence containing the extracted subsequence

>>> # Bit-vector extraction examples
>>> x = BitVec('x', 8)
>>> Extract(6, 2, x)  # Extract bits 6 down to 2 (5 bits total)
Extract(6, 2, x)
>>> Extract(6, 2, x).sort()  # Result is a 5-bit vector
BitVec(5)
>>> Extract(7, 0, x)  # Extract all 8 bits
Extract(7, 0, x)
>>> Extract(3, 3, x)  # Extract single bit at position 3
Extract(3, 3, x)

>>> # Sequence extraction examples  
>>> s = StringVal("hello")
>>> Extract(s, 1, 3)  # Extract 3 characters starting at position 1
str.substr("hello", 1, 3)
>>> simplify(Extract(StringVal("abcd"), 2, 1))  # Extract 1 character at position 2
"c"
>>> simplify(Extract(StringVal("abcd"), 0, 2))  # Extract first 2 characters  
"ab"

Definition at line 4301 of file z3py.py.

4301def Extract(high, low, a):
4302 """Create a Z3 bit-vector extraction expression or sequence extraction expression.
4303
4304 Extract is overloaded to work with both bit-vectors and sequences:
4305
4306 **Bit-vector extraction**: Extract(high, low, bitvector)
4307 Extracts bits from position `high` down to position `low` (both inclusive).
4308 - high: int - the highest bit position to extract (0-indexed from right)
4309 - low: int - the lowest bit position to extract (0-indexed from right)
4310 - bitvector: BitVecRef - the bit-vector to extract from
4311 Returns a new bit-vector containing bits [high:low]
4312
4313 **Sequence extraction**: Extract(sequence, offset, length)
4314 Extracts a subsequence starting at the given offset with the specified length.
4315 The functions SubString and SubSeq are redirected to this form of Extract.
4316 - sequence: SeqRef or str - the sequence to extract from
4317 - offset: int - the starting position (0-indexed)
4318 - length: int - the number of elements to extract
4319 Returns a new sequence containing the extracted subsequence
4320
4321 >>> # Bit-vector extraction examples
4322 >>> x = BitVec('x', 8)
4323 >>> Extract(6, 2, x) # Extract bits 6 down to 2 (5 bits total)
4324 Extract(6, 2, x)
4325 >>> Extract(6, 2, x).sort() # Result is a 5-bit vector
4326 BitVec(5)
4327 >>> Extract(7, 0, x) # Extract all 8 bits
4328 Extract(7, 0, x)
4329 >>> Extract(3, 3, x) # Extract single bit at position 3
4330 Extract(3, 3, x)
4331
4332 >>> # Sequence extraction examples
4333 >>> s = StringVal("hello")
4334 >>> Extract(s, 1, 3) # Extract 3 characters starting at position 1
4335 str.substr("hello", 1, 3)
4336 >>> simplify(Extract(StringVal("abcd"), 2, 1)) # Extract 1 character at position 2
4337 "c"
4338 >>> simplify(Extract(StringVal("abcd"), 0, 2)) # Extract first 2 characters
4339 "ab"
4340 """
4341 if isinstance(high, str):
4342 high = StringVal(high)
4343 if is_seq(high):
4344 s = high
4345 offset, length = _coerce_exprs(low, a, s.ctx)
4346 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4347 if z3_debug():
4348 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4349 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4350 "First and second arguments must be non negative integers")
4351 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4352 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4353
4354
Z3_mk_extract
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_mk_seq_extract
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 9514 of file z3py.py.

9514def FailIf(p, ctx=None):
9515 """Return a tactic that fails if the probe `p` evaluates to true.
9516 Otherwise, it returns the input goal unmodified.
9517
9518 In the following example, the tactic applies 'simplify' if and only if there are
9519 more than 2 constraints in the goal.
9520
9521 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
9522 >>> x, y = Ints('x y')
9523 >>> g = Goal()
9524 >>> g.add(x > 0)
9525 >>> g.add(y > 0)
9526 >>> t(g)
9527 [[x > 0, y > 0]]
9528 >>> g.add(x == y + 1)
9529 >>> t(g)
9530 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9531 """
9532 p = _to_probe(p, ctx)
9533 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
9534
9535
Z3_tactic_fail_if
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.

◆ FiniteDomainSort()

FiniteDomainSort (   name,
  sz,
  ctx = None 
) 
Create a named finite domain sort of a given size sz

Definition at line 8427 of file z3py.py.

8427def FiniteDomainSort(name, sz, ctx=None):
8428 """Create a named finite domain sort of a given size sz"""
8429 if not isinstance(name, Symbol):
8430 name = to_symbol(name)
8431 ctx = _get_ctx(ctx)
8432 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
8433
8434
Z3_mk_finite_domain_sort
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.

◆ FiniteDomainVal()

FiniteDomainVal (   val,
  sort,
  ctx = None 
) 
Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.

>>> s = FiniteDomainSort('S', 256)
>>> FiniteDomainVal(255, s)
255
>>> FiniteDomainVal('100', s)
100

Definition at line 8497 of file z3py.py.

8497def FiniteDomainVal(val, sort, ctx=None):
8498 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
8499
8500 >>> s = FiniteDomainSort('S', 256)
8501 >>> FiniteDomainVal(255, s)
8502 255
8503 >>> FiniteDomainVal('100', s)
8504 100
8505 """
8506 if z3_debug():
8507 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
8508 ctx = sort.ctx
8509 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
8510
8511

◆ FiniteSetDifference()

FiniteSetDifference (   s1,
  s2 
) 
Create the set difference of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetDifference(a, b)
set.difference(a, b)

Definition at line 5434 of file z3py.py.

5434def FiniteSetDifference(s1, s2):
5435 """Create the set difference of two finite sets.
5436 >>> a = Const('a', FiniteSetSort(IntSort()))
5437 >>> b = Const('b', FiniteSetSort(IntSort()))
5438 >>> FiniteSetDifference(a, b)
5439 set.difference(a, b)
5440 """
5441 ctx = _ctx_from_ast_arg_list([s1, s2])
5442 return FiniteSetRef(Z3_mk_finite_set_difference(ctx.ref(), s1.as_ast(), s2.as_ast()), ctx)
5443
5444
Z3_mk_finite_set_difference
Z3_ast Z3_API Z3_mk_finite_set_difference(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the set difference of two finite sets.

Referenced by FiniteSetRef.__sub__(), and SetDifference().

◆ FiniteSetEmpty()

FiniteSetEmpty (   set_sort) 
Create an empty finite set of the given sort.
>>> s = FiniteSetSort(IntSort())
>>> FiniteSetEmpty(s)
set.empty

Definition at line 5393 of file z3py.py.

5393def FiniteSetEmpty(set_sort):
5394 """Create an empty finite set of the given sort.
5395 >>> s = FiniteSetSort(IntSort())
5396 >>> FiniteSetEmpty(s)
5397 set.empty
5398 """
5399 ctx = set_sort.ctx
5400 return FiniteSetRef(Z3_mk_finite_set_empty(ctx.ref(), set_sort.ast), ctx)
5401
5402
Z3_mk_finite_set_empty
Z3_ast Z3_API Z3_mk_finite_set_empty(Z3_context c, Z3_sort set_sort)
Create an empty finite set of the given sort.

Referenced by FiniteSetSortRef.cast(), and EmptySet().

◆ FiniteSetFilter()

FiniteSetFilter (   f,
  set 
) 
Filter a finite set using predicate f.
>>> f = Array('f', IntSort(), BoolSort())
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetFilter(f, a)
set.filter(f, a)

Definition at line 5491 of file z3py.py.

5491def FiniteSetFilter(f, set):
5492 """Filter a finite set using predicate f.
5493 >>> f = Array('f', IntSort(), BoolSort())
5494 >>> a = Const('a', FiniteSetSort(IntSort()))
5495 >>> FiniteSetFilter(f, a)
5496 set.filter(f, a)
5497 """
5498 if isinstance(f, FuncDeclRef):
5499 f = AsArray(f)
5500 ctx = _ctx_from_ast_arg_list([f, set])
5501 return FiniteSetRef(Z3_mk_finite_set_filter(ctx.ref(), f.as_ast(), set.as_ast()), ctx)
5502
5503
Z3_mk_finite_set_filter
Z3_ast Z3_API Z3_mk_finite_set_filter(Z3_context c, Z3_ast f, Z3_ast set)
Filter a finite set using a predicate.

◆ FiniteSetIntersect()

FiniteSetIntersect (   s1,
  s2 
) 
Create the intersection of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetIntersect(a, b)
set.intersect(a, b)

Definition at line 5423 of file z3py.py.

5423def FiniteSetIntersect(s1, s2):
5424 """Create the intersection of two finite sets.
5425 >>> a = Const('a', FiniteSetSort(IntSort()))
5426 >>> b = Const('b', FiniteSetSort(IntSort()))
5427 >>> FiniteSetIntersect(a, b)
5428 set.intersect(a, b)
5429 """
5430 ctx = _ctx_from_ast_arg_list([s1, s2])
5431 return FiniteSetRef(Z3_mk_finite_set_intersect(ctx.ref(), s1.as_ast(), s2.as_ast()), ctx)
5432
5433
Z3_mk_finite_set_intersect
Z3_ast Z3_API Z3_mk_finite_set_intersect(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the intersection of two finite sets.

Referenced by FiniteSetRef.__and__().

◆ FiniteSetMap()

FiniteSetMap (   f,
  set 
) 
Apply function f to all elements of the finite set.
>>> f = Array('f', IntSort(), IntSort())
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetMap(f, a)
set.map(f, a)

Definition at line 5478 of file z3py.py.

5478def FiniteSetMap(f, set):
5479 """Apply function f to all elements of the finite set.
5480 >>> f = Array('f', IntSort(), IntSort())
5481 >>> a = Const('a', FiniteSetSort(IntSort()))
5482 >>> FiniteSetMap(f, a)
5483 set.map(f, a)
5484 """
5485 if isinstance(f, FuncDeclRef):
5486 f = AsArray(f)
5487 ctx = _ctx_from_ast_arg_list([f, set])
5488 return FiniteSetRef(Z3_mk_finite_set_map(ctx.ref(), f.as_ast(), set.as_ast()), ctx)
5489
5490
Z3_mk_finite_set_map
Z3_ast Z3_API Z3_mk_finite_set_map(Z3_context c, Z3_ast f, Z3_ast set)
Apply a function to all elements of a finite set.

◆ FiniteSetMember()

FiniteSetMember (   elem,
  set 
) 
Check if elem is a member of the finite set.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetMember(IntVal(1), a)
set.in(1, a)

Definition at line 5445 of file z3py.py.

5445def FiniteSetMember(elem, set):
5446 """Check if elem is a member of the finite set.
5447 >>> a = Const('a', FiniteSetSort(IntSort()))
5448 >>> FiniteSetMember(IntVal(1), a)
5449 set.in(1, a)
5450 """
5451 ctx = _ctx_from_ast_arg_list([elem, set])
5452 return BoolRef(Z3_mk_finite_set_member(ctx.ref(), elem.as_ast(), set.as_ast()), ctx)
5453
Z3_mk_finite_set_member
Z3_ast Z3_API Z3_mk_finite_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check if an element is a member of a finite set.

Referenced by In().

◆ FiniteSetRange()

FiniteSetRange (   low,
  high 
) 
Create a finite set of integers in the range [low, high).
>>> FiniteSetRange(IntVal(0), IntVal(5))
set.range(0, 5)

Definition at line 5504 of file z3py.py.

5504def FiniteSetRange(low, high):
5505 """Create a finite set of integers in the range [low, high).
5506 >>> FiniteSetRange(IntVal(0), IntVal(5))
5507 set.range(0, 5)
5508 """
5509 ctx = _ctx_from_ast_arg_list([low, high])
5510 return FiniteSetRef(Z3_mk_finite_set_range(ctx.ref(), low.as_ast(), high.as_ast()), ctx)
5511
5512
Z3_mk_finite_set_range
Z3_ast Z3_API Z3_mk_finite_set_range(Z3_context c, Z3_ast low, Z3_ast high)
Create a finite set of integers in the range [low, high].

◆ FiniteSetSize()

FiniteSetSize (   set) 
Get the size (cardinality) of a finite set.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> FiniteSetSize(a)
set.size(a)

Definition at line 5457 of file z3py.py.

5457def FiniteSetSize(set):
5458 """Get the size (cardinality) of a finite set.
5459 >>> a = Const('a', FiniteSetSort(IntSort()))
5460 >>> FiniteSetSize(a)
5461 set.size(a)
5462 """
5463 ctx = set.ctx
5464 return ArithRef(Z3_mk_finite_set_size(ctx.ref(), set.as_ast()), ctx)
5465
5466
Z3_mk_finite_set_size
Z3_ast Z3_API Z3_mk_finite_set_size(Z3_context c, Z3_ast set)
Get the size (cardinality) of a finite set.

◆ FiniteSetSort()

FiniteSetSort (   elem_sort) 
Create a finite set sort over element sort elem_sort.
>>> s = FiniteSetSort(IntSort())
>>> s
FiniteSet(Int)

Definition at line 5384 of file z3py.py.

5384def FiniteSetSort(elem_sort):
5385 """Create a finite set sort over element sort elem_sort.
5386 >>> s = FiniteSetSort(IntSort())
5387 >>> s
5388 FiniteSet(Int)
5389 """
5390 return FiniteSetSortRef(Z3_mk_finite_set_sort(elem_sort.ctx_ref(), elem_sort.ast), elem_sort.ctx)
5391
5392
Z3_mk_finite_set_sort
Z3_sort Z3_API Z3_mk_finite_set_sort(Z3_context c, Z3_sort elem_sort)
Create a finite set sort.

◆ FiniteSetSubset()

FiniteSetSubset (   s1,
  s2 
) 
Check if s1 is a subset of s2.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetSubset(a, b)
set.subset(a, b)

Definition at line 5467 of file z3py.py.

5467def FiniteSetSubset(s1, s2):
5468 """Check if s1 is a subset of s2.
5469 >>> a = Const('a', FiniteSetSort(IntSort()))
5470 >>> b = Const('b', FiniteSetSort(IntSort()))
5471 >>> FiniteSetSubset(a, b)
5472 set.subset(a, b)
5473 """
5474 ctx = _ctx_from_ast_arg_list([s1, s2])
5475 return BoolRef(Z3_mk_finite_set_subset(ctx.ref(), s1.as_ast(), s2.as_ast()), ctx)
5476
5477
Z3_mk_finite_set_subset
Z3_ast Z3_API Z3_mk_finite_set_subset(Z3_context c, Z3_ast s1, Z3_ast s2)
Check if one finite set is a subset of another.

◆ FiniteSetUnion()

FiniteSetUnion (   s1,
  s2 
) 
Create the union of two finite sets.
>>> a = Const('a', FiniteSetSort(IntSort()))
>>> b = Const('b', FiniteSetSort(IntSort()))
>>> FiniteSetUnion(a, b)
set.union(a, b)

Definition at line 5412 of file z3py.py.

5412def FiniteSetUnion(s1, s2):
5413 """Create the union of two finite sets.
5414 >>> a = Const('a', FiniteSetSort(IntSort()))
5415 >>> b = Const('b', FiniteSetSort(IntSort()))
5416 >>> FiniteSetUnion(a, b)
5417 set.union(a, b)
5418 """
5419 ctx = _ctx_from_ast_arg_list([s1, s2])
5420 return FiniteSetRef(Z3_mk_finite_set_union(ctx.ref(), s1.as_ast(), s2.as_ast()), ctx)
5421
5422
Z3_mk_finite_set_union
Z3_ast Z3_API Z3_mk_finite_set_union(Z3_context c, Z3_ast s1, Z3_ast s2)
Create the union of two finite sets.

Referenced by FiniteSetRef.__or__(), and FiniteSetSortRef.cast().

◆ Float128()

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

Definition at line 10242 of file z3py.py.

10242def Float128(ctx=None):
10243 """Floating-point 128-bit (quadruple) sort."""
10244 ctx = _get_ctx(ctx)
10245 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
10246
10247
Z3_mk_fpa_sort_128
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 10206 of file z3py.py.

10206def Float16(ctx=None):
10207 """Floating-point 16-bit (half) sort."""
10208 ctx = _get_ctx(ctx)
10209 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
10210
10211
Z3_mk_fpa_sort_16
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 10218 of file z3py.py.

10218def Float32(ctx=None):
10219 """Floating-point 32-bit (single) sort."""
10220 ctx = _get_ctx(ctx)
10221 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
10222
10223
Z3_mk_fpa_sort_32
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 10230 of file z3py.py.

10230def Float64(ctx=None):
10231 """Floating-point 64-bit (double) sort."""
10232 ctx = _get_ctx(ctx)
10233 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
10234
10235
Z3_mk_fpa_sort_64
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 10236 of file z3py.py.

10236def FloatDouble(ctx=None):
10237 """Floating-point 64-bit (double) sort."""
10238 ctx = _get_ctx(ctx)
10239 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
10240
10241
Z3_mk_fpa_sort_double
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 10212 of file z3py.py.

10212def FloatHalf(ctx=None):
10213 """Floating-point 16-bit (half) sort."""
10214 ctx = _get_ctx(ctx)
10215 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
10216
10217
Z3_mk_fpa_sort_half
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 10248 of file z3py.py.

10248def FloatQuadruple(ctx=None):
10249 """Floating-point 128-bit (quadruple) sort."""
10250 ctx = _get_ctx(ctx)
10251 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
10252
10253
Z3_mk_fpa_sort_quadruple
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 10224 of file z3py.py.

10224def FloatSingle(ctx=None):
10225 """Floating-point 32-bit (single) sort."""
10226 ctx = _get_ctx(ctx)
10227 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
10228
10229
Z3_mk_fpa_sort_single
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

◆ ForAll()

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

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

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> x = Int('x')
>>> y = Int('y')
>>> ForAll([x, y], f(x, y) >= x)
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, weight=10)
ForAll([x, y], f(x, y) >= x)

Definition at line 2371 of file z3py.py.

2371def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2372 """Create a Z3 forall formula.
2373
2374 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2375
2376 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2377 >>> x = Int('x')
2378 >>> y = Int('y')
2379 >>> ForAll([x, y], f(x, y) >= x)
2380 ForAll([x, y], f(x, y) >= x)
2381 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2382 ForAll([x, y], f(x, y) >= x)
2383 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2384 ForAll([x, y], f(x, y) >= x)
2385 """
2386 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2387
2388

◆ FP()

FP (   name,
  fpsort,
  ctx = None 
) 
Return a floating-point constant named `name`.
`fpsort` is the floating-point sort.
If `ctx=None`, then the global context is used.

>>> x  = FP('x', FPSort(8, 24))
>>> is_fp(x)
True
>>> x.ebits()
8
>>> x.sort()
FPSort(8, 24)
>>> word = FPSort(8, 24)
>>> x2 = FP('x', word)
>>> eq(x, x2)
True

Definition at line 10884 of file z3py.py.

10884def FP(name, fpsort, ctx=None):
10885 """Return a floating-point constant named `name`.
10886 `fpsort` is the floating-point sort.
10887 If `ctx=None`, then the global context is used.
10888
10889 >>> x = FP('x', FPSort(8, 24))
10890 >>> is_fp(x)
10891 True
10892 >>> x.ebits()
10893 8
10894 >>> x.sort()
10895 FPSort(8, 24)
10896 >>> word = FPSort(8, 24)
10897 >>> x2 = FP('x', word)
10898 >>> eq(x, x2)
10899 True
10900 """
10901 if isinstance(fpsort, FPSortRef) and ctx is None:
10902 ctx = fpsort.ctx
10903 else:
10904 ctx = _get_ctx(ctx)
10905 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10906
10907

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

10927def fpAbs(a, ctx=None):
10928 """Create a Z3 floating-point absolute value expression.
10929
10930 >>> s = FPSort(8, 24)
10931 >>> rm = RNE()
10932 >>> x = FPVal(1.0, s)
10933 >>> fpAbs(x)
10934 fpAbs(1)
10935 >>> y = FPVal(-20.0, s)
10936 >>> y
10937 -1.25*(2**4)
10938 >>> fpAbs(y)
10939 fpAbs(-1.25*(2**4))
10940 >>> fpAbs(-1.25*(2**4))
10941 fpAbs(-1.25*(2**4))
10942 >>> fpAbs(x).sort()
10943 FPSort(8, 24)
10944 """
10945 ctx = _get_ctx(ctx)
10946 [a] = _coerce_fp_expr_list([a], ctx)
10947 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10948
10949
Z3_mk_fpa_abs
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 11018 of file z3py.py.

11018def fpAdd(rm, a, b, ctx=None):
11019 """Create a Z3 floating-point addition expression.
11020
11021 >>> s = FPSort(8, 24)
11022 >>> rm = RNE()
11023 >>> x = FP('x', s)
11024 >>> y = FP('y', s)
11025 >>> fpAdd(rm, x, y)
11026 x + y
11027 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
11028 fpAdd(RTZ(), x, y)
11029 >>> fpAdd(rm, x, y).sort()
11030 FPSort(8, 24)
11031 """
11032 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
11033
11034

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

11340def fpBVToFP(v, sort, ctx=None):
11341 """Create a Z3 floating-point conversion expression that represents the
11342 conversion from a bit-vector term to a floating-point term.
11343
11344 >>> x_bv = BitVecVal(0x3F800000, 32)
11345 >>> x_fp = fpBVToFP(x_bv, Float32())
11346 >>> x_fp
11347 fpToFP(1065353216)
11348 >>> simplify(x_fp)
11349 1
11350 """
11351 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
11352 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
11353 ctx = _get_ctx(ctx)
11354 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
11355
11356
Z3_mk_fpa_to_fp_bv
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 11065 of file z3py.py.

11065def fpDiv(rm, a, b, ctx=None):
11066 """Create a Z3 floating-point division expression.
11067
11068 >>> s = FPSort(8, 24)
11069 >>> rm = RNE()
11070 >>> x = FP('x', s)
11071 >>> y = FP('y', s)
11072 >>> fpDiv(rm, x, y)
11073 x / y
11074 >>> fpDiv(rm, x, y).sort()
11075 FPSort(8, 24)
11076 """
11077 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
11078
11079

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

11248def fpEQ(a, b, ctx=None):
11249 """Create the Z3 floating-point expression `fpEQ(other, self)`.
11250
11251 >>> x, y = FPs('x y', FPSort(8, 24))
11252 >>> fpEQ(x, y)
11253 fpEQ(x, y)
11254 >>> fpEQ(x, y).sexpr()
11255 '(fp.eq x y)'
11256 """
11257 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
11258
11259

◆ fpFMA()

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

Definition at line 11124 of file z3py.py.

11124def fpFMA(rm, a, b, c, ctx=None):
11125 """Create a Z3 floating-point fused multiply-add expression.
11126 """
11127 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
11128
11129

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

11272def fpFP(sgn, exp, sig, ctx=None):
11273 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
11274
11275 >>> s = FPSort(8, 24)
11276 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
11277 >>> print(x)
11278 fpFP(1, 127, 4194304)
11279 >>> xv = FPVal(-1.5, s)
11280 >>> print(xv)
11281 -1.5
11282 >>> slvr = Solver()
11283 >>> slvr.add(fpEQ(x, xv))
11284 >>> slvr.check()
11285 sat
11286 >>> xv = FPVal(+1.5, s)
11287 >>> print(xv)
11288 1.5
11289 >>> slvr = Solver()
11290 >>> slvr.add(fpEQ(x, xv))
11291 >>> slvr.check()
11292 unsat
11293 """
11294 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
11295 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
11296 ctx = _get_ctx(ctx)
11297 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
11298 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
11299
11300
Z3_mk_fpa_fp
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 11357 of file z3py.py.

11357def fpFPToFP(rm, v, sort, ctx=None):
11358 """Create a Z3 floating-point conversion expression that represents the
11359 conversion from a floating-point term to a floating-point term of different precision.
11360
11361 >>> x_sgl = FPVal(1.0, Float32())
11362 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
11363 >>> x_dbl
11364 fpToFP(RNE(), 1)
11365 >>> simplify(x_dbl)
11366 1
11367 >>> x_dbl.sort()
11368 FPSort(11, 53)
11369 """
11370 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11371 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
11372 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11373 ctx = _get_ctx(ctx)
11374 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
11375
11376
Z3_mk_fpa_to_fp_float
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 11236 of file z3py.py.

11236def fpGEQ(a, b, ctx=None):
11237 """Create the Z3 floating-point expression `other >= self`.
11238
11239 >>> x, y = FPs('x y', FPSort(8, 24))
11240 >>> fpGEQ(x, y)
11241 x >= y
11242 >>> (x >= y).sexpr()
11243 '(fp.geq x y)'
11244 """
11245 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
11246
11247

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

11224def fpGT(a, b, ctx=None):
11225 """Create the Z3 floating-point expression `other > self`.
11226
11227 >>> x, y = FPs('x y', FPSort(8, 24))
11228 >>> fpGT(x, y)
11229 x > y
11230 >>> (x > y).sexpr()
11231 '(fp.gt x y)'
11232 """
11233 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
11234
11235

◆ fpInfinity()

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

Definition at line 10812 of file z3py.py.

10812def fpInfinity(s, negative):
10813 """Create a Z3 floating-point +oo or -oo term."""
10814 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10815 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10816 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10817
10818
Z3_mk_fpa_inf
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 11154 of file z3py.py.

11154def fpIsInf(a, ctx=None):
11155 """Create a Z3 floating-point isInfinite expression.
11156
11157 >>> s = FPSort(8, 24)
11158 >>> x = FP('x', s)
11159 >>> fpIsInf(x)
11160 fpIsInf(x)
11161 """
11162 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
11163
11164

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

11142def fpIsNaN(a, ctx=None):
11143 """Create a Z3 floating-point isNaN expression.
11144
11145 >>> s = FPSort(8, 24)
11146 >>> x = FP('x', s)
11147 >>> y = FP('y', s)
11148 >>> fpIsNaN(x)
11149 fpIsNaN(x)
11150 """
11151 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
11152
11153

◆ fpIsNegative()

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

Definition at line 11183 of file z3py.py.

11183def fpIsNegative(a, ctx=None):
11184 """Create a Z3 floating-point isNegative expression.
11185 """
11186 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
11187
11188

◆ fpIsNormal()

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

Definition at line 11171 of file z3py.py.

11171def fpIsNormal(a, ctx=None):
11172 """Create a Z3 floating-point isNormal expression.
11173 """
11174 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
11175
11176

◆ fpIsPositive()

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

Definition at line 11189 of file z3py.py.

11189def fpIsPositive(a, ctx=None):
11190 """Create a Z3 floating-point isPositive expression.
11191 """
11192 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
11193
11194

◆ fpIsSubnormal()

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

Definition at line 11177 of file z3py.py.

11177def fpIsSubnormal(a, ctx=None):
11178 """Create a Z3 floating-point isSubnormal expression.
11179 """
11180 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
11181
11182

◆ fpIsZero()

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

Definition at line 11165 of file z3py.py.

11165def fpIsZero(a, ctx=None):
11166 """Create a Z3 floating-point isZero expression.
11167 """
11168 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
11169
11170

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

11212def fpLEQ(a, b, ctx=None):
11213 """Create the Z3 floating-point expression `other <= self`.
11214
11215 >>> x, y = FPs('x y', FPSort(8, 24))
11216 >>> fpLEQ(x, y)
11217 x <= y
11218 >>> (x <= y).sexpr()
11219 '(fp.leq x y)'
11220 """
11221 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
11222
11223

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

11200def fpLT(a, b, ctx=None):
11201 """Create the Z3 floating-point expression `other < self`.
11202
11203 >>> x, y = FPs('x y', FPSort(8, 24))
11204 >>> fpLT(x, y)
11205 x < y
11206 >>> (x < y).sexpr()
11207 '(fp.lt x y)'
11208 """
11209 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
11210
11211

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

11109def fpMax(a, b, ctx=None):
11110 """Create a Z3 floating-point maximum expression.
11111
11112 >>> s = FPSort(8, 24)
11113 >>> rm = RNE()
11114 >>> x = FP('x', s)
11115 >>> y = FP('y', s)
11116 >>> fpMax(x, y)
11117 fpMax(x, y)
11118 >>> fpMax(x, y).sort()
11119 FPSort(8, 24)
11120 """
11121 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
11122
11123

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

11094def fpMin(a, b, ctx=None):
11095 """Create a Z3 floating-point minimum expression.
11096
11097 >>> s = FPSort(8, 24)
11098 >>> rm = RNE()
11099 >>> x = FP('x', s)
11100 >>> y = FP('y', s)
11101 >>> fpMin(x, y)
11102 fpMin(x, y)
11103 >>> fpMin(x, y).sort()
11104 FPSort(8, 24)
11105 """
11106 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
11107
11108

◆ fpMinusInfinity()

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

Definition at line 10806 of file z3py.py.

10806def fpMinusInfinity(s):
10807 """Create a Z3 floating-point -oo term."""
10808 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10809 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10810
10811

◆ fpMinusZero()

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

Definition at line 10825 of file z3py.py.

10825def fpMinusZero(s):
10826 """Create a Z3 floating-point -0.0 term."""
10827 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10828 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10829
10830
Z3_mk_fpa_zero
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 11050 of file z3py.py.

11050def fpMul(rm, a, b, ctx=None):
11051 """Create a Z3 floating-point multiplication expression.
11052
11053 >>> s = FPSort(8, 24)
11054 >>> rm = RNE()
11055 >>> x = FP('x', s)
11056 >>> y = FP('y', s)
11057 >>> fpMul(rm, x, y)
11058 x * y
11059 >>> fpMul(rm, x, y).sort()
11060 FPSort(8, 24)
11061 """
11062 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
11063
11064

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

10772def fpNaN(s):
10773 """Create a Z3 floating-point NaN term.
10774
10775 >>> s = FPSort(8, 24)
10776 >>> set_fpa_pretty(True)
10777 >>> fpNaN(s)
10778 NaN
10779 >>> pb = get_fpa_pretty()
10780 >>> set_fpa_pretty(False)
10781 >>> fpNaN(s)
10782 fpNaN(FPSort(8, 24))
10783 >>> set_fpa_pretty(pb)
10784 """
10785 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10786 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10787
10788
Z3_mk_fpa_nan
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 10950 of file z3py.py.

10950def fpNeg(a, ctx=None):
10951 """Create a Z3 floating-point addition expression.
10952
10953 >>> s = FPSort(8, 24)
10954 >>> rm = RNE()
10955 >>> x = FP('x', s)
10956 >>> fpNeg(x)
10957 -x
10958 >>> fpNeg(x).sort()
10959 FPSort(8, 24)
10960 """
10961 ctx = _get_ctx(ctx)
10962 [a] = _coerce_fp_expr_list([a], ctx)
10963 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10964
10965
Z3_mk_fpa_neg
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 11260 of file z3py.py.

11260def fpNEQ(a, b, ctx=None):
11261 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
11262
11263 >>> x, y = FPs('x y', FPSort(8, 24))
11264 >>> fpNEQ(x, y)
11265 Not(fpEQ(x, y))
11266 >>> (x != y).sexpr()
11267 '(distinct x y)'
11268 """
11269 return Not(fpEQ(a, b, ctx))
11270
11271

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

10789def fpPlusInfinity(s):
10790 """Create a Z3 floating-point +oo term.
10791
10792 >>> s = FPSort(8, 24)
10793 >>> pb = get_fpa_pretty()
10794 >>> set_fpa_pretty(True)
10795 >>> fpPlusInfinity(s)
10796 +oo
10797 >>> set_fpa_pretty(False)
10798 >>> fpPlusInfinity(s)
10799 fpPlusInfinity(FPSort(8, 24))
10800 >>> set_fpa_pretty(pb)
10801 """
10802 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10803 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10804
10805

◆ fpPlusZero()

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

Definition at line 10819 of file z3py.py.

10819def fpPlusZero(s):
10820 """Create a Z3 floating-point +0.0 term."""
10821 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10822 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10823
10824

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

11377def fpRealToFP(rm, v, sort, ctx=None):
11378 """Create a Z3 floating-point conversion expression that represents the
11379 conversion from a real term to a floating-point term.
11380
11381 >>> x_r = RealVal(1.5)
11382 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
11383 >>> x_fp
11384 fpToFP(RNE(), 3/2)
11385 >>> simplify(x_fp)
11386 1.5
11387 """
11388 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11389 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
11390 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11391 ctx = _get_ctx(ctx)
11392 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
11393
11394
Z3_mk_fpa_to_fp_real
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 11080 of file z3py.py.

11080def fpRem(a, b, ctx=None):
11081 """Create a Z3 floating-point remainder expression.
11082
11083 >>> s = FPSort(8, 24)
11084 >>> x = FP('x', s)
11085 >>> y = FP('y', s)
11086 >>> fpRem(x, y)
11087 fpRem(x, y)
11088 >>> fpRem(x, y).sort()
11089 FPSort(8, 24)
11090 """
11091 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
11092
11093

◆ fpRoundToIntegral()

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

Definition at line 11136 of file z3py.py.

11136def fpRoundToIntegral(rm, a, ctx=None):
11137 """Create a Z3 floating-point roundToIntegral expression.
11138 """
11139 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
11140
11141

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

10908def FPs(names, fpsort, ctx=None):
10909 """Return an array of floating-point constants.
10910
10911 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10912 >>> x.sort()
10913 FPSort(8, 24)
10914 >>> x.sbits()
10915 24
10916 >>> x.ebits()
10917 8
10918 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10919 (x + y) * z
10920 """
10921 ctx = _get_ctx(ctx)
10922 if isinstance(names, str):
10923 names = names.split(" ")
10924 return [FP(name, fpsort, ctx) for name in names]
10925
10926

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

11395def fpSignedToFP(rm, v, sort, ctx=None):
11396 """Create a Z3 floating-point conversion expression that represents the
11397 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
11398
11399 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11400 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
11401 >>> x_fp
11402 fpToFP(RNE(), 4294967291)
11403 >>> simplify(x_fp)
11404 -1.25*(2**2)
11405 """
11406 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11407 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
11408 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11409 ctx = _get_ctx(ctx)
11410 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
11411
11412
Z3_mk_fpa_to_fp_signed
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 10713 of file z3py.py.

10713def FPSort(ebits, sbits, ctx=None):
10714 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10715
10716 >>> Single = FPSort(8, 24)
10717 >>> Double = FPSort(11, 53)
10718 >>> Single
10719 FPSort(8, 24)
10720 >>> x = Const('x', Single)
10721 >>> eq(x, FP('x', FPSort(8, 24)))
10722 True
10723 """
10724 ctx = _get_ctx(ctx)
10725 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
10726
10727
Z3_mk_fpa_sort
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 11130 of file z3py.py.

11130def fpSqrt(rm, a, ctx=None):
11131 """Create a Z3 floating-point square root expression.
11132 """
11133 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
11134
11135

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

11035def fpSub(rm, a, b, ctx=None):
11036 """Create a Z3 floating-point subtraction expression.
11037
11038 >>> s = FPSort(8, 24)
11039 >>> rm = RNE()
11040 >>> x = FP('x', s)
11041 >>> y = FP('y', s)
11042 >>> fpSub(rm, x, y)
11043 x - y
11044 >>> fpSub(rm, x, y).sort()
11045 FPSort(8, 24)
11046 """
11047 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
11048
11049

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

11301def fpToFP(a1, a2=None, a3=None, ctx=None):
11302 """Create a Z3 floating-point conversion expression from other term sorts
11303 to floating-point.
11304
11305 From a bit-vector term in IEEE 754-2008 format:
11306 >>> x = FPVal(1.0, Float32())
11307 >>> x_bv = fpToIEEEBV(x)
11308 >>> simplify(fpToFP(x_bv, Float32()))
11309 1
11310
11311 From a floating-point term with different precision:
11312 >>> x = FPVal(1.0, Float32())
11313 >>> x_db = fpToFP(RNE(), x, Float64())
11314 >>> x_db.sort()
11315 FPSort(11, 53)
11316
11317 From a real term:
11318 >>> x_r = RealVal(1.5)
11319 >>> simplify(fpToFP(RNE(), x_r, Float32()))
11320 1.5
11321
11322 From a signed bit-vector term:
11323 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11324 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
11325 -1.25*(2**2)
11326 """
11327 ctx = _get_ctx(ctx)
11328 if is_bv(a1) and is_fp_sort(a2):
11329 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
11330 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
11331 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
11332 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
11333 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
11334 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
11335 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
11336 else:
11337 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
11338
11339

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

11431def fpToFPUnsigned(rm, x, s, ctx=None):
11432 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
11433 if z3_debug():
11434 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11435 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
11436 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
11437 ctx = _get_ctx(ctx)
11438 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
11439
11440
Z3_mk_fpa_to_fp_unsigned
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 11505 of file z3py.py.

11505def fpToIEEEBV(x, ctx=None):
11506 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
11507
11508 The size of the resulting bit-vector is automatically determined.
11509
11510 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
11511 knows only one NaN and it will always produce the same bit-vector representation of
11512 that NaN.
11513
11514 >>> x = FP('x', FPSort(8, 24))
11515 >>> y = fpToIEEEBV(x)
11516 >>> print(is_fp(x))
11517 True
11518 >>> print(is_bv(y))
11519 True
11520 >>> print(is_fp(y))
11521 False
11522 >>> print(is_bv(x))
11523 False
11524 """
11525 if z3_debug():
11526 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
11527 ctx = _get_ctx(ctx)
11528 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
11529
11530
Z3_mk_fpa_to_ieee_bv
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 11485 of file z3py.py.

11485def fpToReal(x, ctx=None):
11486 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
11487
11488 >>> x = FP('x', FPSort(8, 24))
11489 >>> y = fpToReal(x)
11490 >>> print(is_fp(x))
11491 True
11492 >>> print(is_real(y))
11493 True
11494 >>> print(is_fp(y))
11495 False
11496 >>> print(is_real(x))
11497 False
11498 """
11499 if z3_debug():
11500 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
11501 ctx = _get_ctx(ctx)
11502 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
11503
11504
Z3_mk_fpa_to_real
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 11441 of file z3py.py.

11441def fpToSBV(rm, x, s, ctx=None):
11442 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
11443
11444 >>> x = FP('x', FPSort(8, 24))
11445 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
11446 >>> print(is_fp(x))
11447 True
11448 >>> print(is_bv(y))
11449 True
11450 >>> print(is_fp(y))
11451 False
11452 >>> print(is_bv(x))
11453 False
11454 """
11455 if z3_debug():
11456 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11457 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
11458 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
11459 ctx = _get_ctx(ctx)
11460 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
11461
11462
Z3_mk_fpa_to_sbv
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 11463 of file z3py.py.

11463def fpToUBV(rm, x, s, ctx=None):
11464 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
11465
11466 >>> x = FP('x', FPSort(8, 24))
11467 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
11468 >>> print(is_fp(x))
11469 True
11470 >>> print(is_bv(y))
11471 True
11472 >>> print(is_fp(y))
11473 False
11474 >>> print(is_bv(x))
11475 False
11476 """
11477 if z3_debug():
11478 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
11479 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
11480 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
11481 ctx = _get_ctx(ctx)
11482 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
11483
11484
Z3_mk_fpa_to_ubv
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 11413 of file z3py.py.

11413def fpUnsignedToFP(rm, v, sort, ctx=None):
11414 """Create a Z3 floating-point conversion expression that represents the
11415 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
11416
11417 >>> x_signed = BitVecVal(-5, BitVecSort(32))
11418 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
11419 >>> x_fp
11420 fpToFPUnsigned(RNE(), 4294967291)
11421 >>> simplify(x_fp)
11422 1*(2**32)
11423 """
11424 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
11425 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
11426 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
11427 ctx = _get_ctx(ctx)
11428 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
11429
11430

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

10838def FPVal(sig, exp=None, fps=None, ctx=None):
10839 """Return a floating-point value of value `val` and sort `fps`.
10840 If `ctx=None`, then the global context is used.
10841
10842 >>> v = FPVal(20.0, FPSort(8, 24))
10843 >>> v
10844 1.25*(2**4)
10845 >>> print("0x%.8x" % v.exponent_as_long(False))
10846 0x00000004
10847 >>> v = FPVal(2.25, FPSort(8, 24))
10848 >>> v
10849 1.125*(2**1)
10850 >>> v = FPVal(-2.25, FPSort(8, 24))
10851 >>> v
10852 -1.125*(2**1)
10853 >>> FPVal(-0.0, FPSort(8, 24))
10854 -0.0
10855 >>> FPVal(0.0, FPSort(8, 24))
10856 +0.0
10857 >>> FPVal(+0.0, FPSort(8, 24))
10858 +0.0
10859 """
10860 ctx = _get_ctx(ctx)
10861 if is_fp_sort(exp):
10862 fps = exp
10863 exp = None
10864 elif fps is None:
10865 fps = _dflt_fps(ctx)
10866 _z3_assert(is_fp_sort(fps), "sort mismatch")
10867 if exp is None:
10868 exp = 0
10869 val = _to_float_str(sig)
10870 if val == "NaN" or val == "nan":
10871 return fpNaN(fps)
10872 elif val == "-0.0":
10873 return fpMinusZero(fps)
10874 elif val == "0.0" or val == "+0.0":
10875 return fpPlusZero(fps)
10876 elif val == "+oo" or val == "+inf" or val == "+Inf":
10877 return fpPlusInfinity(fps)
10878 elif val == "-oo" or val == "-inf" or val == "-Inf":
10879 return fpMinusInfinity(fps)
10880 else:
10881 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10882
10883

◆ fpZero()

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

Definition at line 10831 of file z3py.py.

10831def fpZero(s, negative):
10832 """Create a Z3 floating-point +0.0 or -0.0 term."""
10833 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10834 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10835 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10836
10837

◆ FreshBool()

FreshBool (   prefix = "b",
  ctx = None 
) 
Return a fresh Boolean constant in the given context using the given prefix.

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

>>> b1 = FreshBool()
>>> b2 = FreshBool()
>>> eq(b1, b2)
False

Definition at line 1910 of file z3py.py.

1910def FreshBool(prefix="b", ctx=None):
1911 """Return a fresh Boolean constant in the given context using the given prefix.
1912
1913 If `ctx=None`, then the global context is used.
1914
1915 >>> b1 = FreshBool()
1916 >>> b2 = FreshBool()
1917 >>> eq(b1, b2)
1918 False
1919 """
1920 ctx = _get_ctx(ctx)
1921 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1922
1923
Z3_mk_fresh_const
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.

◆ FreshConst()

FreshConst (   sort,
  prefix = "c" 
) 
Create a fresh constant of a specified sort

Definition at line 1573 of file z3py.py.

1573def FreshConst(sort, prefix="c"):
1574 """Create a fresh constant of a specified sort"""
1575 if z3_debug():
1576 _z3_assert(is_sort(sort), f"Z3 sort expected, got {type(sort)}")
1577 ctx = _get_ctx(sort.ctx)
1578 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1579
1580

◆ FreshFunction()

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

Definition at line 945 of file z3py.py.

945def FreshFunction(*sig):
946 """Create a new fresh Z3 uninterpreted function with the given sorts.
947 """
948 sig = _get_args(sig)
949 if z3_debug():
950 _z3_assert(len(sig) > 0, "At least two arguments expected")
951 arity = len(sig) - 1
952 rng = sig[arity]
953 if z3_debug():
954 _z3_assert(is_sort(rng), "Z3 sort expected")
955 dom = (z3.Sort * arity)()
956 for i in range(arity):
957 if z3_debug():
958 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
959 dom[i] = sig[i].ast
960 ctx = rng.ctx
961 return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), "f", arity, dom, rng.ast), ctx)
962
963
Z3_mk_fresh_func_decl
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.

◆ FreshInt()

FreshInt (   prefix = "x",
  ctx = None 
) 
Return a fresh integer constant in the given context using the given prefix.

>>> x = FreshInt()
>>> y = FreshInt()
>>> eq(x, y)
False
>>> x.sort()
Int

Definition at line 3453 of file z3py.py.

3453def FreshInt(prefix="x", ctx=None):
3454 """Return a fresh integer constant in the given context using the given prefix.
3455
3456 >>> x = FreshInt()
3457 >>> y = FreshInt()
3458 >>> eq(x, y)
3459 False
3460 >>> x.sort()
3461 Int
3462 """
3463 ctx = _get_ctx(ctx)
3464 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3465
3466

◆ FreshReal()

FreshReal (   prefix = "b",
  ctx = None 
) 
Return a fresh real constant in the given context using the given prefix.

>>> x = FreshReal()
>>> y = FreshReal()
>>> eq(x, y)
False
>>> x.sort()
Real

Definition at line 3510 of file z3py.py.

3510def FreshReal(prefix="b", ctx=None):
3511 """Return a fresh real constant in the given context using the given prefix.
3512
3513 >>> x = FreshReal()
3514 >>> y = FreshReal()
3515 >>> eq(x, y)
3516 False
3517 >>> x.sort()
3518 Real
3519 """
3520 ctx = _get_ctx(ctx)
3521 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3522
3523

◆ Full()

Full (   s) 
Create the regular expression that accepts the universal language
>>> e = Full(ReSort(SeqSort(IntSort())))
>>> print(e)
Full(ReSort(Seq(Int)))
>>> e1 = Full(ReSort(StringSort()))
>>> print(e1)
Full(ReSort(String))

Definition at line 11808 of file z3py.py.

11808def Full(s):
11809 """Create the regular expression that accepts the universal language
11810 >>> e = Full(ReSort(SeqSort(IntSort())))
11811 >>> print(e)
11812 Full(ReSort(Seq(Int)))
11813 >>> e1 = Full(ReSort(StringSort()))
11814 >>> print(e1)
11815 Full(ReSort(String))
11816 """
11817 if isinstance(s, ReSortRef):
11818 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11819 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11820
11821
11822
Z3_mk_re_full
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 5180 of file z3py.py.

5180def FullSet(s):
5181 """Create the full set
5182 >>> FullSet(IntSort())
5183 K(Int, True)
5184 """
5185 ctx = s.ctx
5186 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
5187
5188
Z3_mk_full_set
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 922 of file z3py.py.

922def Function(name, *sig):
923 """Create a new Z3 uninterpreted function with the given sorts.
924
925 >>> f = Function('f', IntSort(), IntSort())
926 >>> f(f(0))
927 f(f(0))
928 """
929 sig = _get_args(sig)
930 if z3_debug():
931 _z3_assert(len(sig) > 0, "At least two arguments expected")
932 arity = len(sig) - 1
933 rng = sig[arity]
934 if z3_debug():
935 _z3_assert(is_sort(rng), "Z3 sort expected")
936 dom = (Sort * arity)()
937 for i in range(arity):
938 if z3_debug():
939 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
940 dom[i] = sig[i].ast
941 ctx = rng.ctx
942 return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
943
944
Z3_mk_func_decl
Z3_func_decl Z3_API Z3_mk_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a constant or function.

◆ get_as_array_func()

get_as_array_func (   n) 
Return the function declaration f associated with a Z3 expression of the form (_ as-array f).

Definition at line 7344 of file z3py.py.

7344def get_as_array_func(n):
7345 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
7346 if z3_debug():
7347 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
7348 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
7349
Z3_get_as_array_func_decl
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a)
Return the function declaration f associated with a (_ as_array f) node.

Referenced by ModelRef.get_interp().

◆ get_ctx()

Context get_ctx (   ctx)

Definition at line 294 of file z3py.py.

294def get_ctx(ctx) -> Context:
295 return _get_ctx(ctx)
296
297

◆ get_default_fp_sort()

get_default_fp_sort (   ctx = None)

Definition at line 10125 of file z3py.py.

10125def get_default_fp_sort(ctx=None):
10126 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
10127
10128

◆ get_default_rounding_mode()

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

Definition at line 10092 of file z3py.py.

10092def get_default_rounding_mode(ctx=None):
10093 """Retrieves the global default rounding mode."""
10094 global _dflt_rounding_mode
10095 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
10096 return RTZ(ctx)
10097 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
10098 return RTN(ctx)
10099 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
10100 return RTP(ctx)
10101 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
10102 return RNE(ctx)
10103 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
10104 return RNA(ctx)
10105
10106

◆ get_full_version()

get_full_version ( )

Definition at line 109 of file z3py.py.

109def get_full_version():
110 return Z3_get_full_version()
111
112
Z3_get_full_version
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 4911 of file z3py.py.

4911def get_map_func(a):
4912 """Return the function declaration associated with a Z3 map array expression.
4913
4914 >>> f = Function('f', IntSort(), IntSort())
4915 >>> b = Array('b', IntSort(), IntSort())
4916 >>> a = Map(f, b)
4917 >>> eq(f, get_map_func(a))
4918 True
4919 >>> get_map_func(a)
4920 f
4921 >>> get_map_func(a)(0)
4922 f(0)
4923 """
4924 if z3_debug():
4925 _z3_assert(is_map(a), "Z3 array map expression expected.")
4926 return FuncDeclRef(
4927 Z3_to_func_decl(
4928 a.ctx_ref(),
4929 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4930 ),
4931 ctx=a.ctx,
4932 )
4933
4934
Z3_to_func_decl
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_get_decl_ast_parameter
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.

◆ get_param()

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

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

Definition at line 334 of file z3py.py.

334def get_param(name):
335 """Return the value of a Z3 global (or module) parameter
336
337 >>> get_param('nlsat.reorder')
338 'true'
339 """
340 ptr = (ctypes.c_char_p * 1)()
341 if Z3_global_param_get(str(name), ptr):
342 r = z3core._to_pystr(ptr[0])
343 return r
344 raise Z3Exception("failed to retrieve value for '%s'" % name)
345
Z3_global_param_get
bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.

◆ get_var_index()

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

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

Definition at line 1444 of file z3py.py.

1444def get_var_index(a):
1445 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1446
1447 >>> x = Int('x')
1448 >>> y = Int('y')
1449 >>> is_var(x)
1450 False
1451 >>> is_const(x)
1452 True
1453 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1454 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1455 >>> q = ForAll([x, y], f(x, y) == x + y)
1456 >>> q.body()
1457 f(Var(1), Var(0)) == Var(1) + Var(0)
1458 >>> b = q.body()
1459 >>> b.arg(0)
1460 f(Var(1), Var(0))
1461 >>> v1 = b.arg(0).arg(0)
1462 >>> v2 = b.arg(0).arg(1)
1463 >>> v1
1464 Var(1)
1465 >>> v2
1466 Var(0)
1467 >>> get_var_index(v1)
1468 1
1469 >>> get_var_index(v2)
1470 0
1471 """
1472 if z3_debug():
1473 _z3_assert(is_var(a), "Z3 bound variable expected")
1474 return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1475
1476
Z3_get_index_value
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.

◆ get_version()

get_version ( )

Definition at line 100 of file z3py.py.

100def get_version():
101 major = ctypes.c_uint(0)
102 minor = ctypes.c_uint(0)
103 build = ctypes.c_uint(0)
104 rev = ctypes.c_uint(0)
105 Z3_get_version(major, minor, build, rev)
106 return (major.value, minor.value, build.value, rev.value)
107
108
Z3_get_version
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.

◆ get_version_string()

get_version_string ( )

Definition at line 91 of file z3py.py.

91def get_version_string():
92 major = ctypes.c_uint(0)
93 minor = ctypes.c_uint(0)
94 build = ctypes.c_uint(0)
95 rev = ctypes.c_uint(0)
96 Z3_get_version(major, minor, build, rev)
97 return "%s.%s.%s" % (major.value, minor.value, build.value)
98
99

◆ help_simplify()

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

Definition at line 9598 of file z3py.py.

9598def help_simplify():
9599 """Return a string describing all options available for Z3 `simplify` procedure."""
9600 print(Z3_simplify_get_help(main_ctx().ref()))
9601
9602
Z3_simplify_get_help
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.

◆ If()

If (   a,
  b,
  c,
  ctx = None 
) 
Create a Z3 if-then-else expression.

>>> x = Int('x')
>>> y = Int('y')
>>> max = If(x > y, x, y)
>>> max
If(x > y, x, y)
>>> simplify(max)
If(x <= y, y, x)

Definition at line 1490 of file z3py.py.

1490def If(a, b, c, ctx=None):
1491 """Create a Z3 if-then-else expression.
1492
1493 >>> x = Int('x')
1494 >>> y = Int('y')
1495 >>> max = If(x > y, x, y)
1496 >>> max
1497 If(x > y, x, y)
1498 >>> simplify(max)
1499 If(x <= y, y, x)
1500 """
1501 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1502 return Cond(a, b, c, ctx)
1503 else:
1504 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1505 s = BoolSort(ctx)
1506 a = s.cast(a)
1507 b, c = _coerce_exprs(b, c, ctx)
1508 if z3_debug():
1509 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1510 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1511
1512
Z3_mk_ite
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__(), BoolRef.__mul__(), ArithRef.__mul__(), and ToReal().

◆ Implies()

Implies (   a,
  b,
  ctx = None 
) 
Create a Z3 implies expression.

>>> p, q = Bools('p q')
>>> Implies(p, q)
Implies(p, q)

Definition at line 1924 of file z3py.py.

1924def Implies(a, b, ctx=None):
1925 """Create a Z3 implies expression.
1926
1927 >>> p, q = Bools('p q')
1928 >>> Implies(p, q)
1929 Implies(p, q)
1930 """
1931 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1932 s = BoolSort(ctx)
1933 a = s.cast(a)
1934 b = s.cast(b)
1935 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1936
1937
Z3_mk_implies
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.

◆ In()

In (   elem,
  set 
)

Definition at line 5454 of file z3py.py.

5454def In(elem, set):
5455 return FiniteSetMember(elem, set)
5456

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

11892def IndexOf(s, substr, offset=None):
11893 """Retrieve the index of substring within a string starting at a specified offset.
11894 >>> simplify(IndexOf("abcabc", "bc", 0))
11895 1
11896 >>> simplify(IndexOf("abcabc", "bc", 2))
11897 4
11898 """
11899 if offset is None:
11900 offset = IntVal(0)
11901 ctx = None
11902 if is_expr(offset):
11903 ctx = offset.ctx
11904 ctx = _get_ctx2(s, substr, ctx)
11905 s = _coerce_seq(s, ctx)
11906 substr = _coerce_seq(substr, ctx)
11907 if _is_int(offset):
11908 offset = IntVal(offset, ctx)
11909 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11910
11911
Z3_mk_seq_index
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 12031 of file z3py.py.

12031def InRe(s, re):
12032 """Create regular expression membership test
12033 >>> re = Union(Re("a"),Re("b"))
12034 >>> print (simplify(InRe("a", re)))
12035 True
12036 >>> print (simplify(InRe("b", re)))
12037 True
12038 >>> print (simplify(InRe("c", re)))
12039 False
12040 """
12041 s = _coerce_seq(s, re.ctx)
12042 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
12043
12044
Z3_mk_seq_in_re
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.

◆ Int()

Int (   name,
  ctx = None 
) 
Return an integer constant named `name`. If `ctx=None`, then the global context is used.

>>> x = Int('x')
>>> is_int(x)
True
>>> is_int(x + 1)
True

Definition at line 3414 of file z3py.py.

3414def Int(name, ctx=None):
3415 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3416
3417 >>> x = Int('x')
3418 >>> is_int(x)
3419 True
3420 >>> is_int(x + 1)
3421 True
3422 """
3423 ctx = _get_ctx(ctx)
3424 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3425
3426

Referenced by Ints(), and IntVector().

◆ Int2BV()

Int2BV (   a,
  num_bits 
) 
Return the z3 expression Int2BV(a, num_bits).
It is a bit-vector of width num_bits and represents the
modulo of a by 2^num_bits

Definition at line 4169 of file z3py.py.

4169def Int2BV(a, num_bits):
4170 """Return the z3 expression Int2BV(a, num_bits).
4171 It is a bit-vector of width num_bits and represents the
4172 modulo of a by 2^num_bits
4173 """
4174 ctx = a.ctx
4175 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4176
4177
Z3_mk_int2bv
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 12073 of file z3py.py.

12073def Intersect(*args):
12074 """Create intersection of regular expressions.
12075 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
12076 """
12077 args = _get_args(args)
12078 sz = len(args)
12079 if z3_debug():
12080 _z3_assert(sz > 0, "At least one argument expected.")
12081 arg0 = args[0]
12082 if is_finite_set(arg0):
12083 for a in args[1:]:
12084 if not is_finite_set(a):
12085 raise Z3Exception("All arguments must be regular expressions or finite sets.")
12086 arg0 = arg0 & a
12087 return arg0
12088 if z3_debug():
12089 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
12090 if sz == 1:
12091 return args[0]
12092 ctx = args[0].ctx
12093 v = (Ast * sz)()
12094 for i in range(sz):
12095 v[i] = args[i].as_ast()
12096 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
12097
12098
Z3_mk_re_intersect
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.

◆ Ints()

Ints (   names,
  ctx = None 
) 
Return a tuple of Integer constants.

>>> x, y, z = Ints('x y z')
>>> Sum(x, y, z)
x + y + z

Definition at line 3427 of file z3py.py.

3427def Ints(names, ctx=None):
3428 """Return a tuple of Integer constants.
3429
3430 >>> x, y, z = Ints('x y z')
3431 >>> Sum(x, y, z)
3432 x + y + z
3433 """
3434 ctx = _get_ctx(ctx)
3435 if isinstance(names, str):
3436 names = names.split(" ")
3437 return [Int(name, ctx) for name in names]
3438
3439

◆ IntSort()

IntSort (   ctx = None) 
Return the integer sort in the given context. If `ctx=None`, then the global context is used.

>>> IntSort()
Int
>>> x = Const('x', IntSort())
>>> is_int(x)
True
>>> x.sort() == IntSort()
True
>>> x.sort() == BoolSort()
False

Definition at line 3304 of file z3py.py.

3304def IntSort(ctx=None):
3305 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3306
3307 >>> IntSort()
3308 Int
3309 >>> x = Const('x', IntSort())
3310 >>> is_int(x)
3311 True
3312 >>> x.sort() == IntSort()
3313 True
3314 >>> x.sort() == BoolSort()
3315 False
3316 """
3317 ctx = _get_ctx(ctx)
3318 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3319
3320
Z3_mk_int_sort
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 11973 of file z3py.py.

11973def IntToStr(s):
11974 """Convert integer expression to string"""
11975 if not is_expr(s):
11976 s = _py2expr(s)
11977 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11978
11979
Z3_mk_int_to_str
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 3350 of file z3py.py.

3350def IntVal(val, ctx=None):
3351 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3352
3353 >>> IntVal(1)
3354 1
3355 >>> IntVal("100")
3356 100
3357 """
3358 ctx = _get_ctx(ctx)
3359 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3360
3361

Referenced by BoolRef.__mul__(), and _py2expr().

◆ IntVector()

IntVector (   prefix,
  sz,
  ctx = None 
) 
Return a list of integer constants of size `sz`.

>>> X = IntVector('x', 3)
>>> X
[x__0, x__1, x__2]
>>> Sum(X)
x__0 + x__1 + x__2

Definition at line 3440 of file z3py.py.

3440def IntVector(prefix, sz, ctx=None):
3441 """Return a list of integer constants of size `sz`.
3442
3443 >>> X = IntVector('x', 3)
3444 >>> X
3445 [x__0, x__1, x__2]
3446 >>> Sum(X)
3447 x__0 + x__1 + x__2
3448 """
3449 ctx = _get_ctx(ctx)
3450 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3451
3452

◆ is_add()

bool is_add ( Any  a) 
Return `True` if `a` is an expression of the form b + c.

>>> x, y = Ints('x y')
>>> is_add(x + y)
True
>>> is_add(x - y)
False

Definition at line 2952 of file z3py.py.

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

◆ is_algebraic_value()

is_algebraic_value (   a) 
Return `True` if `a` is an algebraic value of sort Real.

>>> is_algebraic_value(RealVal("3/5"))
False
>>> n = simplify(Sqrt(2))
>>> n
1.4142135623?
>>> is_algebraic_value(n)
True

Definition at line 2938 of file z3py.py.

2938def is_algebraic_value(a):
2939 """Return `True` if `a` is an algebraic value of sort Real.
2940
2941 >>> is_algebraic_value(RealVal("3/5"))
2942 False
2943 >>> n = simplify(Sqrt(2))
2944 >>> n
2945 1.4142135623?
2946 >>> is_algebraic_value(n)
2947 True
2948 """
2949 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2950
2951

◆ is_and()

bool is_and ( Any  a) 
Return `True` if `a` is a Z3 and expression.

>>> p, q = Bools('p q')
>>> is_and(And(p, q))
True
>>> is_and(Or(p, q))
False

Definition at line 1760 of file z3py.py.

1760def is_and(a : Any) -> bool:
1761 """Return `True` if `a` is a Z3 and expression.
1762
1763 >>> p, q = Bools('p q')
1764 >>> is_and(And(p, q))
1765 True
1766 >>> is_and(Or(p, q))
1767 False
1768 """
1769 return is_app_of(a, Z3_OP_AND)
1770
1771

◆ is_app()

is_app (   a) 
Return `True` if `a` is a Z3 function application.

Note that, constants are function applications with 0 arguments.

>>> a = Int('a')
>>> is_app(a)
True
>>> is_app(a + 1)
True
>>> is_app(IntSort())
False
>>> is_app(1)
False
>>> is_app(IntVal(1))
True
>>> x = Int('x')
>>> is_app(ForAll(x, x >= 0))
False

Definition at line 1374 of file z3py.py.

1374def is_app(a):
1375 """Return `True` if `a` is a Z3 function application.
1376
1377 Note that, constants are function applications with 0 arguments.
1378
1379 >>> a = Int('a')
1380 >>> is_app(a)
1381 True
1382 >>> is_app(a + 1)
1383 True
1384 >>> is_app(IntSort())
1385 False
1386 >>> is_app(1)
1387 False
1388 >>> is_app(IntVal(1))
1389 True
1390 >>> x = Int('x')
1391 >>> is_app(ForAll(x, x >= 0))
1392 False
1393 """
1394 if not isinstance(a, ExprRef):
1395 return False
1396 k = _ast_kind(a.ctx, a)
1397 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1398
1399

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

◆ is_app_of()

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

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

Definition at line 1477 of file z3py.py.

1477def is_app_of(a, k):
1478 """Return `True` if `a` is an application of the given kind `k`.
1479
1480 >>> x = Int('x')
1481 >>> n = x + 1
1482 >>> is_app_of(n, Z3_OP_ADD)
1483 True
1484 >>> is_app_of(n, Z3_OP_MUL)
1485 False
1486 """
1487 return is_app(a) and a.kind() == k
1488
1489

Referenced by is_add(), is_and(), is_const_array(), is_default(), is_distinct(), is_div(), is_eq(), is_false(), is_ge(), is_gt(), is_idiv(), is_implies(), is_is_int(), is_K(), is_le(), is_lt(), is_map(), is_mod(), is_mul(), is_not(), is_or(), is_select(), is_store(), is_sub(), is_to_int(), is_to_real(), and is_true().

◆ is_arith()

is_arith (   a) 
Return `True` if `a` is an arithmetical expression.

>>> x = Int('x')
>>> is_arith(x)
True
>>> is_arith(x + 1)
True
>>> is_arith(1)
False
>>> is_arith(IntVal(1))
True
>>> y = Real('y')
>>> is_arith(y)
True
>>> is_arith(y + 1)
True

Definition at line 2825 of file z3py.py.

2825def is_arith(a):
2826 """Return `True` if `a` is an arithmetical expression.
2827
2828 >>> x = Int('x')
2829 >>> is_arith(x)
2830 True
2831 >>> is_arith(x + 1)
2832 True
2833 >>> is_arith(1)
2834 False
2835 >>> is_arith(IntVal(1))
2836 True
2837 >>> y = Real('y')
2838 >>> is_arith(y)
2839 True
2840 >>> is_arith(y + 1)
2841 True
2842 """
2843 return isinstance(a, ArithRef)
2844
2845

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

◆ is_arith_sort()

bool is_arith_sort ( Any  s) 
Return `True` if s is an arithmetical sort (type).

>>> is_arith_sort(IntSort())
True
>>> is_arith_sort(RealSort())
True
>>> is_arith_sort(BoolSort())
False
>>> n = Int('x') + 1
>>> is_arith_sort(n.sort())
True

Definition at line 2513 of file z3py.py.

2513def is_arith_sort(s : Any) -> bool:
2514 """Return `True` if s is an arithmetical sort (type).
2515
2516 >>> is_arith_sort(IntSort())
2517 True
2518 >>> is_arith_sort(RealSort())
2519 True
2520 >>> is_arith_sort(BoolSort())
2521 False
2522 >>> n = Int('x') + 1
2523 >>> is_arith_sort(n.sort())
2524 True
2525 """
2526 return isinstance(s, ArithSortRef)
2527
2528

Referenced by ArithSortRef.subsort().

◆ is_array()

bool is_array ( Any  a) 
Return `True` if `a` is a Z3 array expression.

>>> a = Array('a', IntSort(), IntSort())
>>> is_array(a)
True
>>> is_array(Store(a, 0, 1))
True
>>> is_array(a[0])
False

Definition at line 4846 of file z3py.py.

4846def is_array(a : Any) -> bool:
4847 """Return `True` if `a` is a Z3 array expression.
4848
4849 >>> a = Array('a', IntSort(), IntSort())
4850 >>> is_array(a)
4851 True
4852 >>> is_array(Store(a, 0, 1))
4853 True
4854 >>> is_array(a[0])
4855 False
4856 """
4857 return isinstance(a, ArrayRef)
4858
4859

Referenced by Ext(), and Map().

◆ is_array_sort()

is_array_sort (   a)

Definition at line 4842 of file z3py.py.

4842def is_array_sort(a):
4843 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4844
4845

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

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

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

◆ is_ast()

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

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

Definition at line 482 of file z3py.py.

482def is_ast(a : Any) -> bool:
483 """Return `True` if `a` is an AST node.
484
485 >>> is_ast(10)
486 False
487 >>> is_ast(IntVal(10))
488 True
489 >>> is_ast(Int('x'))
490 True
491 >>> is_ast(BoolSort())
492 True
493 >>> is_ast(Function('f', IntSort(), IntSort()))
494 True
495 >>> is_ast("x")
496 False
497 >>> is_ast(Solver())
498 False
499 """
500 return isinstance(a, AstRef)
501
502

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

◆ is_bool()

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

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

Definition at line 1710 of file z3py.py.

1710def is_bool(a : Any) -> bool:
1711 """Return `True` if `a` is a Z3 Boolean expression.
1712
1713 >>> p = Bool('p')
1714 >>> is_bool(p)
1715 True
1716 >>> q = Bool('q')
1717 >>> is_bool(And(p, q))
1718 True
1719 >>> x = Real('x')
1720 >>> is_bool(x)
1721 False
1722 >>> is_bool(x == 0)
1723 True
1724 """
1725 return isinstance(a, BoolRef)
1726
1727

Referenced by _mk_quantifier().

◆ is_bv()

is_bv (   a) 
Return `True` if `a` is a Z3 bit-vector expression.

>>> b = BitVec('b', 32)
>>> is_bv(b)
True
>>> is_bv(b + 10)
True
>>> is_bv(Int('x'))
False

Definition at line 4117 of file z3py.py.

4117def is_bv(a):
4118 """Return `True` if `a` is a Z3 bit-vector expression.
4119
4120 >>> b = BitVec('b', 32)
4121 >>> is_bv(b)
4122 True
4123 >>> is_bv(b + 10)
4124 True
4125 >>> is_bv(Int('x'))
4126 False
4127 """
4128 return isinstance(a, BitVecRef)
4129
4130

Referenced by _check_bv_args(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), Concat(), Extract(), is_bv_value(), RepeatBitVec(), SignExt(), and ZeroExt().

◆ is_bv_sort()

is_bv_sort (   s) 
Return True if `s` is a Z3 bit-vector sort.

>>> is_bv_sort(BitVecSort(32))
True
>>> is_bv_sort(IntSort())
False

Definition at line 3644 of file z3py.py.

3644def is_bv_sort(s):
3645 """Return True if `s` is a Z3 bit-vector sort.
3646
3647 >>> is_bv_sort(BitVecSort(32))
3648 True
3649 >>> is_bv_sort(IntSort())
3650 False
3651 """
3652 return isinstance(s, BitVecSortRef)
3653
3654

Referenced by BitVecVal(), and BitVecSortRef.subsort().

◆ is_bv_value()

is_bv_value (   a) 
Return `True` if `a` is a Z3 bit-vector numeral value.

>>> b = BitVec('b', 32)
>>> is_bv_value(b)
False
>>> b = BitVecVal(10, 32)
>>> b
10
>>> is_bv_value(b)
True

Definition at line 4131 of file z3py.py.

4131def is_bv_value(a):
4132 """Return `True` if `a` is a Z3 bit-vector numeral value.
4133
4134 >>> b = BitVec('b', 32)
4135 >>> is_bv_value(b)
4136 False
4137 >>> b = BitVecVal(10, 32)
4138 >>> b
4139 10
4140 >>> is_bv_value(b)
4141 True
4142 """
4143 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4144
4145

◆ is_const()

is_const (   a) 
Return `True` if `a` is Z3 constant/variable expression.

>>> a = Int('a')
>>> is_const(a)
True
>>> is_const(a + 1)
False
>>> is_const(1)
False
>>> is_const(IntVal(1))
True
>>> x = Int('x')
>>> is_const(ForAll(x, x >= 0))
False

Definition at line 1400 of file z3py.py.

1400def is_const(a):
1401 """Return `True` if `a` is Z3 constant/variable expression.
1402
1403 >>> a = Int('a')
1404 >>> is_const(a)
1405 True
1406 >>> is_const(a + 1)
1407 False
1408 >>> is_const(1)
1409 False
1410 >>> is_const(IntVal(1))
1411 True
1412 >>> x = Int('x')
1413 >>> is_const(ForAll(x, x >= 0))
1414 False
1415 """
1416 return is_app(a) and a.num_args() == 0
1417
1418

Referenced by ModelRef.__getitem__(), _mk_quantifier(), Solver.assert_and_track(), and ModelRef.get_interp().

◆ is_const_array()

is_const_array (   a) 
Return `True` if `a` is a Z3 constant array.

>>> a = K(IntSort(), 10)
>>> is_const_array(a)
True
>>> a = Array('a', IntSort(), IntSort())
>>> is_const_array(a)
False

Definition at line 4860 of file z3py.py.

4860def is_const_array(a):
4861 """Return `True` if `a` is a Z3 constant array.
4862
4863 >>> a = K(IntSort(), 10)
4864 >>> is_const_array(a)
4865 True
4866 >>> a = Array('a', IntSort(), IntSort())
4867 >>> is_const_array(a)
4868 False
4869 """
4870 return is_app_of(a, Z3_OP_CONST_ARRAY)
4871
4872

◆ is_default()

is_default (   a) 
Return `True` if `a` is a Z3 default array expression.
>>> d = Default(K(IntSort(), 10))
>>> is_default(d)
True

Definition at line 4902 of file z3py.py.

4902def is_default(a):
4903 """Return `True` if `a` is a Z3 default array expression.
4904 >>> d = Default(K(IntSort(), 10))
4905 >>> is_default(d)
4906 True
4907 """
4908 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4909
4910

◆ is_distinct()

bool is_distinct ( Any  a) 
Return `True` if `a` is a Z3 distinct expression.

>>> x, y, z = Ints('x y z')
>>> is_distinct(x == y)
False
>>> is_distinct(Distinct(x, y, z))
True

Definition at line 1818 of file z3py.py.

1818def is_distinct(a : Any) -> bool:
1819 """Return `True` if `a` is a Z3 distinct expression.
1820
1821 >>> x, y, z = Ints('x y z')
1822 >>> is_distinct(x == y)
1823 False
1824 >>> is_distinct(Distinct(x, y, z))
1825 True
1826 """
1827 return is_app_of(a, Z3_OP_DISTINCT)
1828
1829

◆ is_div()

bool is_div ( Any  a) 
Return `True` if `a` is an expression of the form b / c.

>>> x, y = Reals('x y')
>>> is_div(x / y)
True
>>> is_div(x + y)
False
>>> x, y = Ints('x y')
>>> is_div(x / y)
False
>>> is_idiv(x / y)
True

Definition at line 2988 of file z3py.py.

2988def is_div(a : Any) -> bool:
2989 """Return `True` if `a` is an expression of the form b / c.
2990
2991 >>> x, y = Reals('x y')
2992 >>> is_div(x / y)
2993 True
2994 >>> is_div(x + y)
2995 False
2996 >>> x, y = Ints('x y')
2997 >>> is_div(x / y)
2998 False
2999 >>> is_idiv(x / y)
3000 True
3001 """
3002 return is_app_of(a, Z3_OP_DIV)
3003
3004

◆ is_eq()

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

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

Definition at line 1808 of file z3py.py.

1808def is_eq(a : Any) -> bool:
1809 """Return `True` if `a` is a Z3 equality expression.
1810
1811 >>> x, y = Ints('x y')
1812 >>> is_eq(x == y)
1813 True
1814 """
1815 return is_app_of(a, Z3_OP_EQ)
1816
1817

Referenced by AstRef.__bool__().

◆ is_expr()

is_expr (   a) 
Return `True` if `a` is a Z3 expression.

>>> a = Int('a')
>>> is_expr(a)
True
>>> is_expr(a + 1)
True
>>> is_expr(IntSort())
False
>>> is_expr(1)
False
>>> is_expr(IntVal(1))
True
>>> x = Int('x')
>>> is_expr(ForAll(x, x >= 0))
True
>>> is_expr(FPVal(1.0))
True

Definition at line 1351 of file z3py.py.

1351def is_expr(a):
1352 """Return `True` if `a` is a Z3 expression.
1353
1354 >>> a = Int('a')
1355 >>> is_expr(a)
1356 True
1357 >>> is_expr(a + 1)
1358 True
1359 >>> is_expr(IntSort())
1360 False
1361 >>> is_expr(1)
1362 False
1363 >>> is_expr(IntVal(1))
1364 True
1365 >>> x = Int('x')
1366 >>> is_expr(ForAll(x, x >= 0))
1367 True
1368 >>> is_expr(FPVal(1.0))
1369 True
1370 """
1371 return isinstance(a, ExprRef)
1372
1373

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

◆ is_false()

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

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

Definition at line 1746 of file z3py.py.

1746def is_false(a : Any) -> bool:
1747 """Return `True` if `a` is the Z3 false expression.
1748
1749 >>> p = Bool('p')
1750 >>> is_false(p)
1751 False
1752 >>> is_false(False)
1753 False
1754 >>> is_false(BoolVal(False))
1755 True
1756 """
1757 return is_app_of(a, Z3_OP_FALSE)
1758
1759

Referenced by AstRef.__bool__(), and BoolRef.py_value().

◆ is_finite_domain()

is_finite_domain (   a) 
Return `True` if `a` is a Z3 finite-domain expression.

>>> s = FiniteDomainSort('S', 100)
>>> b = Const('b', s)
>>> is_finite_domain(b)
True
>>> is_finite_domain(Int('x'))
False

Definition at line 8458 of file z3py.py.

8458def is_finite_domain(a):
8459 """Return `True` if `a` is a Z3 finite-domain expression.
8460
8461 >>> s = FiniteDomainSort('S', 100)
8462 >>> b = Const('b', s)
8463 >>> is_finite_domain(b)
8464 True
8465 >>> is_finite_domain(Int('x'))
8466 False
8467 """
8468 return isinstance(a, FiniteDomainRef)
8469
8470

◆ is_finite_domain_sort()

is_finite_domain_sort (   s) 
Return True if `s` is a Z3 finite-domain sort.

>>> is_finite_domain_sort(FiniteDomainSort('S', 100))
True
>>> is_finite_domain_sort(IntSort())
False

Definition at line 8435 of file z3py.py.

8435def is_finite_domain_sort(s):
8436 """Return True if `s` is a Z3 finite-domain sort.
8437
8438 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
8439 True
8440 >>> is_finite_domain_sort(IntSort())
8441 False
8442 """
8443 return isinstance(s, FiniteDomainSortRef)
8444
8445

◆ is_finite_domain_value()

is_finite_domain_value (   a) 
Return `True` if `a` is a Z3 finite-domain value.

>>> s = FiniteDomainSort('S', 100)
>>> b = Const('b', s)
>>> is_finite_domain_value(b)
False
>>> b = FiniteDomainVal(10, s)
>>> b
10
>>> is_finite_domain_value(b)
True

Definition at line 8512 of file z3py.py.

8512def is_finite_domain_value(a):
8513 """Return `True` if `a` is a Z3 finite-domain value.
8514
8515 >>> s = FiniteDomainSort('S', 100)
8516 >>> b = Const('b', s)
8517 >>> is_finite_domain_value(b)
8518 False
8519 >>> b = FiniteDomainVal(10, s)
8520 >>> b
8521 10
8522 >>> is_finite_domain_value(b)
8523 True
8524 """
8525 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
8526
8527

◆ is_finite_set()

is_finite_set (   a) 
Return True if a is a Z3 finite set expression.
>>> s = FiniteSetSort(IntSort())
>>> is_finite_set(FiniteSetEmpty(s))
True
>>> is_finite_set(IntVal(1))
False

Definition at line 5344 of file z3py.py.

5344def is_finite_set(a):
5345 """Return True if a is a Z3 finite set expression.
5346 >>> s = FiniteSetSort(IntSort())
5347 >>> is_finite_set(FiniteSetEmpty(s))
5348 True
5349 >>> is_finite_set(IntVal(1))
5350 False
5351 """
5352 return isinstance(a, FiniteSetRef)
5353
5354

Referenced by IsMember(), IsSubset(), SetAdd(), SetDel(), SetDifference(), SetIntersect(), and SetUnion().

◆ is_finite_set_sort()

is_finite_set_sort (   s) 
Return True if s is a Z3 finite set sort.
>>> is_finite_set_sort(FiniteSetSort(IntSort()))
True
>>> is_finite_set_sort(IntSort())
False

Definition at line 5355 of file z3py.py.

5355def is_finite_set_sort(s):
5356 """Return True if s is a Z3 finite set sort.
5357 >>> is_finite_set_sort(FiniteSetSort(IntSort()))
5358 True
5359 >>> is_finite_set_sort(IntSort())
5360 False
5361 """
5362 return isinstance(s, FiniteSetSortRef)
5363
5364

Referenced by EmptySet().

◆ is_fp()

is_fp (   a) 
Return `True` if `a` is a Z3 floating-point expression.

>>> b = FP('b', FPSort(8, 24))
>>> is_fp(b)
True
>>> is_fp(b + 1.0)
True
>>> is_fp(Int('x'))
False

Definition at line 10684 of file z3py.py.

10684def is_fp(a):
10685 """Return `True` if `a` is a Z3 floating-point expression.
10686
10687 >>> b = FP('b', FPSort(8, 24))
10688 >>> is_fp(b)
10689 True
10690 >>> is_fp(b + 1.0)
10691 True
10692 >>> is_fp(Int('x'))
10693 False
10694 """
10695 return isinstance(a, FPRef)
10696
10697

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

10258def is_fp_sort(s):
10259 """Return True if `s` is a Z3 floating-point sort.
10260
10261 >>> is_fp_sort(FPSort(8, 24))
10262 True
10263 >>> is_fp_sort(IntSort())
10264 False
10265 """
10266 return isinstance(s, FPSortRef)
10267
10268

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

10698def is_fp_value(a):
10699 """Return `True` if `a` is a Z3 floating-point numeral value.
10700
10701 >>> b = FP('b', FPSort(8, 24))
10702 >>> is_fp_value(b)
10703 False
10704 >>> b = FPVal(1.0, FPSort(8, 24))
10705 >>> b
10706 1
10707 >>> is_fp_value(b)
10708 True
10709 """
10710 return is_fp(a) and _is_numeral(a.ctx, a.ast)
10711
10712

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

10518def is_fprm(a):
10519 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
10520
10521 >>> rm = RNE()
10522 >>> is_fprm(rm)
10523 True
10524 >>> rm = 1.0
10525 >>> is_fprm(rm)
10526 False
10527 """
10528 return isinstance(a, FPRMRef)
10529
10530

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

10269def is_fprm_sort(s):
10270 """Return True if `s` is a Z3 floating-point rounding mode sort.
10271
10272 >>> is_fprm_sort(FPSort(8, 24))
10273 False
10274 >>> is_fprm_sort(RNE().sort())
10275 True
10276 """
10277 return isinstance(s, FPRMSortRef)
10278
10279# FP Expressions
10280
10281

◆ is_fprm_value()

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

Definition at line 10531 of file z3py.py.

10531def is_fprm_value(a):
10532 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
10533 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
10534
10535# FP Numerals
10536
10537

◆ is_func_decl()

is_func_decl (   a) 
Return `True` if `a` is a Z3 function declaration.

>>> f = Function('f', IntSort(), IntSort())
>>> is_func_decl(f)
True
>>> x = Real('x')
>>> is_func_decl(x)
False

Definition at line 909 of file z3py.py.

909def is_func_decl(a):
910 """Return `True` if `a` is a Z3 function declaration.
911
912 >>> f = Function('f', IntSort(), IntSort())
913 >>> is_func_decl(f)
914 True
915 >>> x = Real('x')
916 >>> is_func_decl(x)
917 False
918 """
919 return isinstance(a, FuncDeclRef)
920
921

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

◆ is_ge()

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

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

Definition at line 3053 of file z3py.py.

3053def is_ge(a : Any) -> bool:
3054 """Return `True` if `a` is an expression of the form b >= c.
3055
3056 >>> x, y = Ints('x y')
3057 >>> is_ge(x >= y)
3058 True
3059 >>> is_ge(x == y)
3060 False
3061 """
3062 return is_app_of(a, Z3_OP_GE)
3063
3064

◆ is_gt()

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

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

Definition at line 3065 of file z3py.py.

3065def is_gt(a : Any) -> bool:
3066 """Return `True` if `a` is an expression of the form b > c.
3067
3068 >>> x, y = Ints('x y')
3069 >>> is_gt(x > y)
3070 True
3071 >>> is_gt(x == y)
3072 False
3073 """
3074 return is_app_of(a, Z3_OP_GT)
3075
3076

◆ is_idiv()

bool is_idiv ( Any  a) 
Return `True` if `a` is an expression of the form b div c.

>>> x, y = Ints('x y')
>>> is_idiv(x / y)
True
>>> is_idiv(x + y)
False

Definition at line 3005 of file z3py.py.

3005def is_idiv(a : Any) -> bool:
3006 """Return `True` if `a` is an expression of the form b div c.
3007
3008 >>> x, y = Ints('x y')
3009 >>> is_idiv(x / y)
3010 True
3011 >>> is_idiv(x + y)
3012 False
3013 """
3014 return is_app_of(a, Z3_OP_IDIV)
3015
3016

◆ is_implies()

bool is_implies ( Any  a) 
Return `True` if `a` is a Z3 implication expression.

>>> p, q = Bools('p q')
>>> is_implies(Implies(p, q))
True
>>> is_implies(And(p, q))
False

Definition at line 1784 of file z3py.py.

1784def is_implies(a : Any) -> bool:
1785 """Return `True` if `a` is a Z3 implication expression.
1786
1787 >>> p, q = Bools('p q')
1788 >>> is_implies(Implies(p, q))
1789 True
1790 >>> is_implies(And(p, q))
1791 False
1792 """
1793 return is_app_of(a, Z3_OP_IMPLIES)
1794
1795

◆ is_int()

bool is_int (   a) 
Return `True` if `a` is an integer expression.

>>> x = Int('x')
>>> is_int(x + 1)
True
>>> is_int(1)
False
>>> is_int(IntVal(1))
True
>>> y = Real('y')
>>> is_int(y)
False
>>> is_int(y + 1)
False

Definition at line 2846 of file z3py.py.

2846def is_int(a) -> bool:
2847 """Return `True` if `a` is an integer expression.
2848
2849 >>> x = Int('x')
2850 >>> is_int(x + 1)
2851 True
2852 >>> is_int(1)
2853 False
2854 >>> is_int(IntVal(1))
2855 True
2856 >>> y = Real('y')
2857 >>> is_int(y)
2858 False
2859 >>> is_int(y + 1)
2860 False
2861 """
2862 return is_arith(a) and a.is_int()
2863
2864

◆ is_int_value()

is_int_value (   a) 
Return `True` if `a` is an integer value of sort Int.

>>> is_int_value(IntVal(1))
True
>>> is_int_value(1)
False
>>> is_int_value(Int('x'))
False
>>> n = Int('x') + 1
>>> n
x + 1
>>> n.arg(1)
1
>>> is_int_value(n.arg(1))
True
>>> is_int_value(RealVal("1/3"))
False
>>> is_int_value(RealVal(1))
False

Definition at line 2892 of file z3py.py.

2892def is_int_value(a):
2893 """Return `True` if `a` is an integer value of sort Int.
2894
2895 >>> is_int_value(IntVal(1))
2896 True
2897 >>> is_int_value(1)
2898 False
2899 >>> is_int_value(Int('x'))
2900 False
2901 >>> n = Int('x') + 1
2902 >>> n
2903 x + 1
2904 >>> n.arg(1)
2905 1
2906 >>> is_int_value(n.arg(1))
2907 True
2908 >>> is_int_value(RealVal("1/3"))
2909 False
2910 >>> is_int_value(RealVal(1))
2911 False
2912 """
2913 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2914
2915

◆ is_is_int()

bool is_is_int ( Any  a) 
Return `True` if `a` is an expression of the form IsInt(b).

>>> x = Real('x')
>>> is_is_int(IsInt(x))
True
>>> is_is_int(x)
False

Definition at line 3077 of file z3py.py.

3077def is_is_int(a : Any) -> bool:
3078 """Return `True` if `a` is an expression of the form IsInt(b).
3079
3080 >>> x = Real('x')
3081 >>> is_is_int(IsInt(x))
3082 True
3083 >>> is_is_int(x)
3084 False
3085 """
3086 return is_app_of(a, Z3_OP_IS_INT)
3087
3088

◆ is_K()

is_K (   a) 
Return `True` if `a` is a Z3 constant array.

>>> a = K(IntSort(), 10)
>>> is_K(a)
True
>>> a = Array('a', IntSort(), IntSort())
>>> is_K(a)
False

Definition at line 4873 of file z3py.py.

4873def is_K(a):
4874 """Return `True` if `a` is a Z3 constant array.
4875
4876 >>> a = K(IntSort(), 10)
4877 >>> is_K(a)
4878 True
4879 >>> a = Array('a', IntSort(), IntSort())
4880 >>> is_K(a)
4881 False
4882 """
4883 return is_app_of(a, Z3_OP_CONST_ARRAY)
4884
4885

◆ is_le()

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

>>> x, y = Ints('x y')
>>> is_le(x <= y)
True
>>> is_le(x < y)
False

Definition at line 3029 of file z3py.py.

3029def is_le(a : Any) -> bool:
3030 """Return `True` if `a` is an expression of the form b <= c.
3031
3032 >>> x, y = Ints('x y')
3033 >>> is_le(x <= y)
3034 True
3035 >>> is_le(x < y)
3036 False
3037 """
3038 return is_app_of(a, Z3_OP_LE)
3039
3040

◆ is_lt()

bool is_lt ( Any  a) 
Return `True` if `a` is an expression of the form b < c.

>>> x, y = Ints('x y')
>>> is_lt(x < y)
True
>>> is_lt(x == y)
False

Definition at line 3041 of file z3py.py.

3041def is_lt(a : Any) -> bool:
3042 """Return `True` if `a` is an expression of the form b < c.
3043
3044 >>> x, y = Ints('x y')
3045 >>> is_lt(x < y)
3046 True
3047 >>> is_lt(x == y)
3048 False
3049 """
3050 return is_app_of(a, Z3_OP_LT)
3051
3052

◆ is_map()

is_map (   a) 
Return `True` if `a` is a Z3 map array expression.

>>> f = Function('f', IntSort(), IntSort())
>>> b = Array('b', IntSort(), IntSort())
>>> a  = Map(f, b)
>>> a
Map(f, b)
>>> is_map(a)
True
>>> is_map(b)
False

Definition at line 4886 of file z3py.py.

4886def is_map(a):
4887 """Return `True` if `a` is a Z3 map array expression.
4888
4889 >>> f = Function('f', IntSort(), IntSort())
4890 >>> b = Array('b', IntSort(), IntSort())
4891 >>> a = Map(f, b)
4892 >>> a
4893 Map(f, b)
4894 >>> is_map(a)
4895 True
4896 >>> is_map(b)
4897 False
4898 """
4899 return is_app_of(a, Z3_OP_ARRAY_MAP)
4900
4901

Referenced by get_map_func().

◆ is_mod()

bool is_mod ( Any  a) 
Return `True` if `a` is an expression of the form b % c.

>>> x, y = Ints('x y')
>>> is_mod(x % y)
True
>>> is_mod(x + y)
False

Definition at line 3017 of file z3py.py.

3017def is_mod(a : Any) -> bool:
3018 """Return `True` if `a` is an expression of the form b % c.
3019
3020 >>> x, y = Ints('x y')
3021 >>> is_mod(x % y)
3022 True
3023 >>> is_mod(x + y)
3024 False
3025 """
3026 return is_app_of(a, Z3_OP_MOD)
3027
3028

◆ is_mul()

bool is_mul ( Any  a) 
Return `True` if `a` is an expression of the form b * c.

>>> x, y = Ints('x y')
>>> is_mul(x * y)
True
>>> is_mul(x - y)
False

Definition at line 2964 of file z3py.py.

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

◆ is_not()

bool is_not ( Any  a) 
Return `True` if `a` is a Z3 not expression.

>>> p = Bool('p')
>>> is_not(p)
False
>>> is_not(Not(p))
True

Definition at line 1796 of file z3py.py.

1796def is_not(a : Any) -> bool:
1797 """Return `True` if `a` is a Z3 not expression.
1798
1799 >>> p = Bool('p')
1800 >>> is_not(p)
1801 False
1802 >>> is_not(Not(p))
1803 True
1804 """
1805 return is_app_of(a, Z3_OP_NOT)
1806
1807

Referenced by mk_not().

◆ is_or()

bool is_or ( Any  a) 
Return `True` if `a` is a Z3 or expression.

>>> p, q = Bools('p q')
>>> is_or(Or(p, q))
True
>>> is_or(And(p, q))
False

Definition at line 1772 of file z3py.py.

1772def is_or(a : Any) -> bool:
1773 """Return `True` if `a` is a Z3 or expression.
1774
1775 >>> p, q = Bools('p q')
1776 >>> is_or(Or(p, q))
1777 True
1778 >>> is_or(And(p, q))
1779 False
1780 """
1781 return is_app_of(a, Z3_OP_OR)
1782
1783

◆ is_pattern()

is_pattern (   a) 
Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.

>>> f = Function('f', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
>>> q
ForAll(x, f(x) == 0)
>>> q.num_patterns()
1
>>> is_pattern(q.pattern(0))
True
>>> q.pattern(0)
f(Var(0))

Definition at line 2072 of file z3py.py.

2072def is_pattern(a):
2073 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
2074
2075 >>> f = Function('f', IntSort(), IntSort())
2076 >>> x = Int('x')
2077 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
2078 >>> q
2079 ForAll(x, f(x) == 0)
2080 >>> q.num_patterns()
2081 1
2082 >>> is_pattern(q.pattern(0))
2083 True
2084 >>> q.pattern(0)
2085 f(Var(0))
2086 """
2087 return isinstance(a, PatternRef)
2088
2089

Referenced by _mk_quantifier(), and _to_pattern().

◆ is_probe()

is_probe (   p) 
Return `True` if `p` is a Z3 probe.

>>> is_probe(Int('x'))
False
>>> is_probe(Probe('memory'))
True

Definition at line 9439 of file z3py.py.

9439def is_probe(p):
9440 """Return `True` if `p` is a Z3 probe.
9441
9442 >>> is_probe(Int('x'))
9443 False
9444 >>> is_probe(Probe('memory'))
9445 True
9446 """
9447 return isinstance(p, Probe)
9448
9449

Referenced by _ctx_from_ast_arg_list(), _has_probe(), and Not().

◆ is_quantifier()

is_quantifier (   a) 
Return `True` if `a` is a Z3 quantifier.

>>> f = Function('f', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) == 0)
>>> is_quantifier(q)
True
>>> is_quantifier(f(x))
False

Definition at line 2322 of file z3py.py.

2322def is_quantifier(a):
2323 """Return `True` if `a` is a Z3 quantifier.
2324
2325 >>> f = Function('f', IntSort(), IntSort())
2326 >>> x = Int('x')
2327 >>> q = ForAll(x, f(x) == 0)
2328 >>> is_quantifier(q)
2329 True
2330 >>> is_quantifier(f(x))
2331 False
2332 """
2333 return isinstance(a, QuantifierRef)
2334
2335

◆ is_rational_value()

is_rational_value (   a) 
Return `True` if `a` is rational value of sort Real.

>>> is_rational_value(RealVal(1))
True
>>> is_rational_value(RealVal("3/5"))
True
>>> is_rational_value(IntVal(1))
False
>>> is_rational_value(1)
False
>>> n = Real('x') + 1
>>> n.arg(1)
1
>>> is_rational_value(n.arg(1))
True
>>> is_rational_value(Real('x'))
False

Definition at line 2916 of file z3py.py.

2916def is_rational_value(a):
2917 """Return `True` if `a` is rational value of sort Real.
2918
2919 >>> is_rational_value(RealVal(1))
2920 True
2921 >>> is_rational_value(RealVal("3/5"))
2922 True
2923 >>> is_rational_value(IntVal(1))
2924 False
2925 >>> is_rational_value(1)
2926 False
2927 >>> n = Real('x') + 1
2928 >>> n.arg(1)
2929 1
2930 >>> is_rational_value(n.arg(1))
2931 True
2932 >>> is_rational_value(Real('x'))
2933 False
2934 """
2935 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2936
2937

◆ is_re()

is_re (   s)

Definition at line 12027 of file z3py.py.

12027def is_re(s):
12028 return isinstance(s, ReRef)
12029
12030

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

2865def is_real(a):
2866 """Return `True` if `a` is a real expression.
2867
2868 >>> x = Int('x')
2869 >>> is_real(x + 1)
2870 False
2871 >>> y = Real('y')
2872 >>> is_real(y)
2873 True
2874 >>> is_real(y + 1)
2875 True
2876 >>> is_real(1)
2877 False
2878 >>> is_real(RealVal(1))
2879 True
2880 """
2881 return is_arith(a) and a.is_real()
2882
2883

◆ is_select()

is_select (   a) 
Return `True` if `a` is a Z3 array select application.

>>> a = Array('a', IntSort(), IntSort())
>>> is_select(a)
False
>>> i = Int('i')
>>> is_select(a[i])
True

Definition at line 5133 of file z3py.py.

5133def is_select(a):
5134 """Return `True` if `a` is a Z3 array select application.
5135
5136 >>> a = Array('a', IntSort(), IntSort())
5137 >>> is_select(a)
5138 False
5139 >>> i = Int('i')
5140 >>> is_select(a[i])
5141 True
5142 """
5143 return is_app_of(a, Z3_OP_SELECT)
5144
5145

◆ is_seq()

is_seq (   a) 
Return `True` if `a` is a Z3 sequence expression.
>>> print (is_seq(Unit(IntVal(0))))
True
>>> print (is_seq(StringVal("abc")))
True

Definition at line 11709 of file z3py.py.

11709def is_seq(a):
11710 """Return `True` if `a` is a Z3 sequence expression.
11711 >>> print (is_seq(Unit(IntVal(0))))
11712 True
11713 >>> print (is_seq(StringVal("abc")))
11714 True
11715 """
11716 return isinstance(a, SeqRef)
11717
11718

Referenced by Concat(), and Extract().

◆ is_sort()

bool is_sort ( Any  s) 
Return `True` if `s` is a Z3 sort.

>>> is_sort(IntSort())
True
>>> is_sort(Int('x'))
False
>>> is_expr(Int('x'))
True

Definition at line 682 of file z3py.py.

682def is_sort(s : Any) -> bool:
683 """Return `True` if `s` is a Z3 sort.
684
685 >>> is_sort(IntSort())
686 True
687 >>> is_sort(Int('x'))
688 False
689 >>> is_expr(Int('x'))
690 True
691 """
692 return isinstance(s, SortRef)
693
694

Referenced by _valid_accessor(), ArraySort(), CreateDatatypes(), CreatePolymorphicDatatype(), FreshConst(), FreshFunction(), Function(), K(), RecFunction(), and Var().

◆ is_store()

is_store (   a) 
Return `True` if `a` is a Z3 array store application.

>>> a = Array('a', IntSort(), IntSort())
>>> is_store(a)
False
>>> is_store(Store(a, 0, 1))
True

Definition at line 5146 of file z3py.py.

5146def is_store(a):
5147 """Return `True` if `a` is a Z3 array store application.
5148
5149 >>> a = Array('a', IntSort(), IntSort())
5150 >>> is_store(a)
5151 False
5152 >>> is_store(Store(a, 0, 1))
5153 True
5154 """
5155 return is_app_of(a, Z3_OP_STORE)
5156

◆ is_string()

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

Definition at line 11719 of file z3py.py.

11719def is_string(a: Any) -> bool:
11720 """Return `True` if `a` is a Z3 string expression.
11721 >>> print (is_string(StringVal("ab")))
11722 True
11723 """
11724 return isinstance(a, SeqRef) and a.is_string()
11725
11726

◆ is_string_value()

bool is_string_value ( Any  a) 
return 'True' if 'a' is a Z3 string constant expression.
>>> print (is_string_value(StringVal("a")))
True
>>> print (is_string_value(StringVal("a") + StringVal("b")))
False

Definition at line 11727 of file z3py.py.

11727def is_string_value(a: Any) -> bool:
11728 """return 'True' if 'a' is a Z3 string constant expression.
11729 >>> print (is_string_value(StringVal("a")))
11730 True
11731 >>> print (is_string_value(StringVal("a") + StringVal("b")))
11732 False
11733 """
11734 return isinstance(a, SeqRef) and a.is_string_value()
11735

◆ is_sub()

bool is_sub ( Any  a) 
Return `True` if `a` is an expression of the form b - c.

>>> x, y = Ints('x y')
>>> is_sub(x - y)
True
>>> is_sub(x + y)
False

Definition at line 2976 of file z3py.py.

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

◆ is_to_int()

bool is_to_int ( Any  a) 
Return `True` if `a` is an expression of the form ToInt(b).

>>> x = Real('x')
>>> n = ToInt(x)
>>> n
ToInt(x)
>>> is_to_int(n)
True
>>> is_to_int(x)
False

Definition at line 3104 of file z3py.py.

3104def is_to_int(a : Any) -> bool:
3105 """Return `True` if `a` is an expression of the form ToInt(b).
3106
3107 >>> x = Real('x')
3108 >>> n = ToInt(x)
3109 >>> n
3110 ToInt(x)
3111 >>> is_to_int(n)
3112 True
3113 >>> is_to_int(x)
3114 False
3115 """
3116 return is_app_of(a, Z3_OP_TO_INT)
3117
3118

◆ is_to_real()

bool is_to_real ( Any  a) 
Return `True` if `a` is an expression of the form ToReal(b).

>>> x = Int('x')
>>> n = ToReal(x)
>>> n
ToReal(x)
>>> is_to_real(n)
True
>>> is_to_real(x)
False

Definition at line 3089 of file z3py.py.

3089def is_to_real(a : Any) -> bool:
3090 """Return `True` if `a` is an expression of the form ToReal(b).
3091
3092 >>> x = Int('x')
3093 >>> n = ToReal(x)
3094 >>> n
3095 ToReal(x)
3096 >>> is_to_real(n)
3097 True
3098 >>> is_to_real(x)
3099 False
3100 """
3101 return is_app_of(a, Z3_OP_TO_REAL)
3102
3103

◆ is_true()

bool is_true ( Any  a) 
Return `True` if `a` is the Z3 true expression.

>>> p = Bool('p')
>>> is_true(p)
False
>>> is_true(simplify(p == p))
True
>>> x = Real('x')
>>> is_true(x == 0)
False
>>> # True is a Python Boolean expression
>>> is_true(True)
False

Definition at line 1728 of file z3py.py.

1728def is_true(a : Any) -> bool:
1729 """Return `True` if `a` is the Z3 true expression.
1730
1731 >>> p = Bool('p')
1732 >>> is_true(p)
1733 False
1734 >>> is_true(simplify(p == p))
1735 True
1736 >>> x = Real('x')
1737 >>> is_true(x == 0)
1738 False
1739 >>> # True is a Python Boolean expression
1740 >>> is_true(True)
1741 False
1742 """
1743 return is_app_of(a, Z3_OP_TRUE)
1744
1745

Referenced by AstRef.__bool__(), and BoolRef.py_value().

◆ is_var()

is_var (   a) 
Return `True` if `a` is variable.

Z3 uses de-Bruijn indices for representing bound variables in
quantifiers.

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

Definition at line 1419 of file z3py.py.

1419def is_var(a):
1420 """Return `True` if `a` is variable.
1421
1422 Z3 uses de-Bruijn indices for representing bound variables in
1423 quantifiers.
1424
1425 >>> x = Int('x')
1426 >>> is_var(x)
1427 False
1428 >>> is_const(x)
1429 True
1430 >>> f = Function('f', IntSort(), IntSort())
1431 >>> # Z3 replaces x with bound variables when ForAll is executed.
1432 >>> q = ForAll(x, f(x) == x)
1433 >>> b = q.body()
1434 >>> b
1435 f(Var(0)) == Var(0)
1436 >>> b.arg(1)
1437 Var(0)
1438 >>> is_var(b.arg(1))
1439 True
1440 """
1441 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1442
1443

Referenced by get_var_index().

◆ IsInt()

IsInt (   a) 
 Return the Z3 predicate IsInt(a).

>>> x = Real('x')
>>> IsInt(x + "1/2")
IsInt(x + 1/2)
>>> solve(IsInt(x + "1/2"), x > 0, x < 1)
[x = 1/2]
>>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
no solution

Definition at line 3562 of file z3py.py.

3562def IsInt(a):
3563 """ Return the Z3 predicate IsInt(a).
3564
3565 >>> x = Real('x')
3566 >>> IsInt(x + "1/2")
3567 IsInt(x + 1/2)
3568 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3569 [x = 1/2]
3570 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3571 no solution
3572 """
3573 if z3_debug():
3574 _z3_assert(a.is_real(), "Z3 real expression expected.")
3575 ctx = a.ctx
3576 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3577
3578
Z3_mk_is_int
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.

◆ IsMember()

IsMember (   e,
  s 
) 
 Check if e is a member of set s
>>> a = Const('a', SetSort(IntSort()))
>>> IsMember(1, a)
a[1]

Definition at line 5270 of file z3py.py.

5270def IsMember(e, s):
5271 """ Check if e is a member of set s
5272 >>> a = Const('a', SetSort(IntSort()))
5273 >>> IsMember(1, a)
5274 a[1]
5275 """
5276 ctx = _ctx_from_ast_arg_list([s, e])
5277 e = _py2expr(e, ctx)
5278 if is_finite_set(s):
5279 return FiniteSetIsMember(e, s)
5280 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5281
5282
Z3_mk_set_member
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.

◆ IsSubset()

IsSubset (   a,
  b 
) 
 Check if a is a subset of b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> IsSubset(a, b)
subset(a, b)

Definition at line 5283 of file z3py.py.

5283def IsSubset(a, b):
5284 """ Check if a is a subset of b
5285 >>> a = Const('a', SetSort(IntSort()))
5286 >>> b = Const('b', SetSort(IntSort()))
5287 >>> IsSubset(a, b)
5288 subset(a, b)
5289 """
5290 ctx = _ctx_from_ast_arg_list([a, b])
5291 if is_finite_set(a):
5292 return FiniteSetIsSubset(a, b)
5293 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5294
5295
Z3_mk_set_subset
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.

◆ K()

K (   dom,
  v 
) 
Return a Z3 constant array expression.

>>> a = K(IntSort(), 10)
>>> a
K(Int, 10)
>>> a.sort()
Array(Int, Int)
>>> i = Int('i')
>>> a[i]
K(Int, 10)[i]
>>> simplify(a[i])
10

Definition at line 5081 of file z3py.py.

5081def K(dom, v):
5082 """Return a Z3 constant array expression.
5083
5084 >>> a = K(IntSort(), 10)
5085 >>> a
5086 K(Int, 10)
5087 >>> a.sort()
5088 Array(Int, Int)
5089 >>> i = Int('i')
5090 >>> a[i]
5091 K(Int, 10)[i]
5092 >>> simplify(a[i])
5093 10
5094 """
5095 if z3_debug():
5096 _z3_assert(is_sort(dom), "Z3 sort expected")
5097 ctx = dom.ctx
5098 if not is_expr(v):
5099 v = _py2expr(v, ctx)
5100 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
5101
5102
Z3_mk_const_array
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.

Referenced by ModelRef.get_interp().

◆ Lambda()

Lambda (   vs,
  body 
) 
Create a Z3 lambda expression.

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> mem0 = Array('mem0', IntSort(), IntSort())
>>> lo, hi, e, i = Ints('lo hi e i')
>>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
>>> mem1
Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))

Definition at line 2410 of file z3py.py.

2410def Lambda(vs, body):
2411 """Create a Z3 lambda expression.
2412
2413 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2414 >>> mem0 = Array('mem0', IntSort(), IntSort())
2415 >>> lo, hi, e, i = Ints('lo hi e i')
2416 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2417 >>> mem1
2418 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2419 """
2420 ctx = body.ctx
2421 if is_app(vs):
2422 vs = [vs]
2423 num_vars = len(vs)
2424 _vs = (Ast * num_vars)()
2425 for i in range(num_vars):
2426 # TODO: Check if is constant
2427 _vs[i] = vs[i].as_ast()
2428 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2429
Z3_mk_lambda_const
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 11912 of file z3py.py.

11912def LastIndexOf(s, substr):
11913 """Retrieve the last index of substring within a string"""
11914 ctx = None
11915 ctx = _get_ctx2(s, substr, ctx)
11916 s = _coerce_seq(s, ctx)
11917 substr = _coerce_seq(substr, ctx)
11918 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11919
11920
Z3_mk_seq_last_index
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 11921 of file z3py.py.

11921def Length(s):
11922 """Obtain the length of a sequence 's'
11923 >>> l = Length(StringVal("abc"))
11924 >>> simplify(l)
11925 3
11926 """
11927 s = _coerce_seq(s)
11928 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11929
Z3_mk_seq_length
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 12199 of file z3py.py.

12199def LinearOrder(a, index):
12200 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
12201
12202
Z3_mk_linear_order
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 12149 of file z3py.py.

12149def Loop(re, lo, hi=0):
12150 """Create the regular expression accepting between a lower and upper bound repetitions
12151 >>> re = Loop(Re("a"), 1, 3)
12152 >>> print(simplify(InRe("aa", re)))
12153 True
12154 >>> print(simplify(InRe("aaaa", re)))
12155 False
12156 >>> print(simplify(InRe("", re)))
12157 False
12158 """
12159 if z3_debug():
12160 _z3_assert(is_expr(re), "expression expected")
12161 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
12162
12163
Z3_mk_re_loop
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...

◆ LShR()

LShR (   a,
  b 
) 
Create the Z3 expression logical right shift.

Use the operator >> for the arithmetical right shift.

>>> x, y = BitVecs('x y', 32)
>>> LShR(x, y)
LShR(x, y)
>>> (x >> y).sexpr()
'(bvashr x y)'
>>> LShR(x, y).sexpr()
'(bvlshr x y)'
>>> BitVecVal(4, 3)
4
>>> BitVecVal(4, 3).as_signed_long()
-4
>>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
-2
>>> simplify(BitVecVal(4, 3) >> 1)
6
>>> simplify(LShR(BitVecVal(4, 3), 1))
2
>>> simplify(BitVecVal(2, 3) >> 1)
1
>>> simplify(LShR(BitVecVal(2, 3), 1))
1

Definition at line 4495 of file z3py.py.

4495def LShR(a, b):
4496 """Create the Z3 expression logical right shift.
4497
4498 Use the operator >> for the arithmetical right shift.
4499
4500 >>> x, y = BitVecs('x y', 32)
4501 >>> LShR(x, y)
4502 LShR(x, y)
4503 >>> (x >> y).sexpr()
4504 '(bvashr x y)'
4505 >>> LShR(x, y).sexpr()
4506 '(bvlshr x y)'
4507 >>> BitVecVal(4, 3)
4508 4
4509 >>> BitVecVal(4, 3).as_signed_long()
4510 -4
4511 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4512 -2
4513 >>> simplify(BitVecVal(4, 3) >> 1)
4514 6
4515 >>> simplify(LShR(BitVecVal(4, 3), 1))
4516 2
4517 >>> simplify(BitVecVal(2, 3) >> 1)
4518 1
4519 >>> simplify(LShR(BitVecVal(2, 3), 1))
4520 1
4521 """
4522 _check_bv_args(a, b)
4523 a, b = _coerce_exprs(a, b)
4524 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4525
4526
Z3_mk_bvlshr
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.

◆ main_ctx()

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

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

Definition at line 266 of file z3py.py.

266def main_ctx() -> Context:
267 """Return a reference to the global Z3 context.
268
269 >>> x = Real('x')
270 >>> x.ctx == main_ctx()
271 True
272 >>> c = Context()
273 >>> c == main_ctx()
274 False
275 >>> x2 = Real('x', c)
276 >>> x2.ctx == c
277 True
278 >>> eq(x, x2)
279 False
280 """
281 global _main_ctx
282 if _main_ctx is None:
283 _main_ctx = Context()
284 return _main_ctx
285
286

Referenced by _get_ctx().

◆ Map()

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

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

Definition at line 5058 of file z3py.py.

5058def Map(f, *args):
5059 """Return a Z3 map array expression.
5060
5061 >>> f = Function('f', IntSort(), IntSort(), IntSort())
5062 >>> a1 = Array('a1', IntSort(), IntSort())
5063 >>> a2 = Array('a2', IntSort(), IntSort())
5064 >>> b = Map(f, a1, a2)
5065 >>> b
5066 Map(f, a1, a2)
5067 >>> prove(b[0] == f(a1[0], a2[0]))
5068 proved
5069 """
5070 args = _get_args(args)
5071 if z3_debug():
5072 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
5073 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
5074 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
5075 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
5076 _args, sz = _to_ast_array(args)
5077 ctx = f.ctx
5078 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
5079
5080
Z3_mk_map
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 1973 of file z3py.py.

1973def mk_not(a):
1974 if is_not(a):
1975 return a.arg(0)
1976 else:
1977 return Not(a)
1978
1979

◆ Model()

Model (   ctx = None,
  eval = {} 
)

Definition at line 7331 of file z3py.py.

7331def Model(ctx=None, eval = {}):
7332 ctx = _get_ctx(ctx)
7333 mdl = ModelRef(Z3_mk_model(ctx.ref()), ctx)
7334 for k, v in eval.items():
7335 mdl.update_value(k, v)
7336 return mdl
7337
7338
Z3_mk_model
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.

◆ MultiPattern()

MultiPattern ( *  args) 
Create a Z3 multi-pattern using the given expressions `*args`

>>> f = Function('f', IntSort(), IntSort())
>>> g = Function('g', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
>>> q
ForAll(x, f(x) != g(x))
>>> q.num_patterns()
1
>>> is_pattern(q.pattern(0))
True
>>> q.pattern(0)
MultiPattern(f(Var(0)), g(Var(0)))

Definition at line 2090 of file z3py.py.

2090def MultiPattern(*args):
2091 """Create a Z3 multi-pattern using the given expressions `*args`
2092
2093 >>> f = Function('f', IntSort(), IntSort())
2094 >>> g = Function('g', IntSort(), IntSort())
2095 >>> x = Int('x')
2096 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
2097 >>> q
2098 ForAll(x, f(x) != g(x))
2099 >>> q.num_patterns()
2100 1
2101 >>> is_pattern(q.pattern(0))
2102 True
2103 >>> q.pattern(0)
2104 MultiPattern(f(Var(0)), g(Var(0)))
2105 """
2106 if z3_debug():
2107 _z3_assert(len(args) > 0, "At least one argument expected")
2108 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2109 ctx = args[0].ctx
2110 args, sz = _to_ast_array(args)
2111 return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
2112
2113
Z3_mk_pattern
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.

Referenced by _to_pattern().

◆ Not()

Not (   a,
  ctx = None 
) 
Create a Z3 not expression or probe.

>>> p = Bool('p')
>>> Not(Not(p))
Not(Not(p))
>>> simplify(Not(Not(p)))
p

Definition at line 1954 of file z3py.py.

1954def Not(a, ctx=None):
1955 """Create a Z3 not expression or probe.
1956
1957 >>> p = Bool('p')
1958 >>> Not(Not(p))
1959 Not(Not(p))
1960 >>> simplify(Not(Not(p)))
1961 p
1962 """
1963 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1964 if is_probe(a):
1965 # Not is also used to build probes
1966 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1967 else:
1968 s = BoolSort(ctx)
1969 a = s.cast(a)
1970 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1971
1972
Z3_probe_not
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_mk_not
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 12239 of file z3py.py.

12239def on_clause_eh(ctx, p, n, dep, clause):
12240 onc = _my_hacky_class
12241 p = _to_expr_ref(to_Ast(p), onc.ctx)
12242 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
12243 deps = [dep[i] for i in range(n)]
12244 onc.on_clause(p, deps, clause)
12245

◆ open_log()

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

Definition at line 122 of file z3py.py.

122def open_log(fname):
123 """Log interaction to a file. This function must be invoked immediately after init(). """
124 Z3_open_log(fname)
125
126
Z3_open_log
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 12114 of file z3py.py.

12114def Option(re):
12115 """Create the regular expression that optionally accepts the argument.
12116 >>> re = Option(Re("a"))
12117 >>> print(simplify(InRe("a", re)))
12118 True
12119 >>> print(simplify(InRe("", re)))
12120 True
12121 >>> print(simplify(InRe("aa", re)))
12122 False
12123 """
12124 if z3_debug():
12125 _z3_assert(is_expr(re), "expression expected")
12126 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
12127
12128
Z3_mk_re_option
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].

◆ Or()

Or ( *  args) 
Create a Z3 or-expression or or-probe.

>>> p, q, r = Bools('p q r')
>>> Or(p, q, r)
Or(p, q, r)
>>> P = BoolVector('p', 5)
>>> Or(P)
Or(p__0, p__1, p__2, p__3, p__4)

Definition at line 2021 of file z3py.py.

2021def Or(*args):
2022 """Create a Z3 or-expression or or-probe.
2023
2024 >>> p, q, r = Bools('p q r')
2025 >>> Or(p, q, r)
2026 Or(p, q, r)
2027 >>> P = BoolVector('p', 5)
2028 >>> Or(P)
2029 Or(p__0, p__1, p__2, p__3, p__4)
2030 """
2031 last_arg = None
2032 if len(args) > 0:
2033 last_arg = args[len(args) - 1]
2034 if isinstance(last_arg, Context):
2035 ctx = args[len(args) - 1]
2036 args = args[:len(args) - 1]
2037 elif len(args) == 1 and isinstance(args[0], AstVector):
2038 ctx = args[0].ctx
2039 args = [a for a in args[0]]
2040 else:
2041 ctx = None
2042 args = _get_args(args)
2043 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
2044 if z3_debug():
2045 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
2046 if _has_probe(args):
2047 return _probe_or(args, ctx)
2048 else:
2049 args = _coerce_expr_list(args, ctx)
2050 _args, sz = _to_ast_array(args)
2051 return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
2052
Z3_mk_or
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 9132 of file z3py.py.

9132def OrElse(*ts, **ks):
9133 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
9134
9135 >>> x = Int('x')
9136 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
9137 >>> # Tactic split-clause fails if there is no clause in the given goal.
9138 >>> t(x == 0)
9139 [[x == 0]]
9140 >>> t(Or(x == 0, x == 1))
9141 [[x == 0], [x == 1]]
9142 """
9143 if z3_debug():
9144 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9145 ctx = ks.get("ctx", None)
9146 num = len(ts)
9147 r = ts[0]
9148 for i in range(num - 1):
9149 r = _or_else(r, ts[i + 1], ctx)
9150 return r
9151
9152

◆ ParAndThen()

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

Definition at line 9188 of file z3py.py.

9188def ParAndThen(t1, t2, ctx=None):
9189 """Alias for ParThen(t1, t2, ctx)."""
9190 return ParThen(t1, t2, ctx)
9191
9192

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

9153def ParOr(*ts, **ks):
9154 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
9155
9156 >>> x = Int('x')
9157 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
9158 >>> t(x + 1 == 2)
9159 [[x == 1]]
9160 """
9161 if z3_debug():
9162 _z3_assert(len(ts) >= 2, "At least two arguments expected")
9163 ctx = _get_ctx(ks.get("ctx", None))
9164 ts = [_to_tactic(t, ctx) for t in ts]
9165 sz = len(ts)
9166 _args = (TacticObj * sz)()
9167 for i in range(sz):
9168 _args[i] = ts[i].tactic
9169 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
9170
9171
Z3_tactic_par_or
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 10068 of file z3py.py.

10068def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
10069 """Parse a file in SMT 2.0 format using the given sorts and decls.
10070
10071 This function is similar to parse_smt2_string().
10072 """
10073 ctx = _get_ctx(ctx)
10074 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
10075 dsz, dnames, ddecls = _dict2darray(decls, ctx)
10076 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
10077
10078
Z3_parse_smtlib2_file
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 10047 of file z3py.py.

10047def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
10048 """Parse a string in SMT 2.0 format using the given sorts and decls.
10049
10050 The arguments sorts and decls are Python dictionaries used to initialize
10051 the symbol table used for the SMT 2.0 parser.
10052
10053 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
10054 [x > 0, x < 10]
10055 >>> x, y = Ints('x y')
10056 >>> f = Function('f', IntSort(), IntSort())
10057 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
10058 [x + f(y) > 0]
10059 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
10060 [a > 0]
10061 """
10062 ctx = _get_ctx(ctx)
10063 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
10064 dsz, dnames, ddecls = _dict2darray(decls, ctx)
10065 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
10066
10067
Z3_parse_smtlib2_string
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 9172 of file z3py.py.

9172def ParThen(t1, t2, ctx=None):
9173 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
9174 The subgoals are processed in parallel.
9175
9176 >>> x, y = Ints('x y')
9177 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
9178 >>> t(And(Or(x == 1, x == 2), y == x + 1))
9179 [[x == 1, y == 2], [x == 2, y == 3]]
9180 """
9181 t1 = _to_tactic(t1, ctx)
9182 t2 = _to_tactic(t2, ctx)
9183 if z3_debug():
9184 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
9185 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
9186
9187
Z3_tactic_par_and_then
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 12195 of file z3py.py.

12195def PartialOrder(a, index):
12196 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
12197
12198
Z3_mk_partial_order
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 9824 of file z3py.py.

9824def PbEq(args, k, ctx=None):
9825 """Create a Pseudo-Boolean equality k constraint.
9826
9827 >>> a, b, c = Bools('a b c')
9828 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9829 """
9830 _z3_check_cint_overflow(k, "k")
9831 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9832 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9833
9834
Z3_mk_pbeq
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 9813 of file z3py.py.

9813def PbGe(args, k):
9814 """Create a Pseudo-Boolean inequality k constraint.
9815
9816 >>> a, b, c = Bools('a b c')
9817 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9818 """
9819 _z3_check_cint_overflow(k, "k")
9820 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9821 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9822
9823
Z3_mk_pbge
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 9802 of file z3py.py.

9802def PbLe(args, k):
9803 """Create a Pseudo-Boolean inequality k constraint.
9804
9805 >>> a, b, c = Bools('a b c')
9806 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9807 """
9808 _z3_check_cint_overflow(k, "k")
9809 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9810 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9811
9812
Z3_mk_pble
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 12207 of file z3py.py.

12207def PiecewiseLinearOrder(a, index):
12208 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
12209
12210
Z3_mk_piecewise_linear_order
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 12099 of file z3py.py.

12099def Plus(re):
12100 """Create the regular expression accepting one or more repetitions of argument.
12101 >>> re = Plus(Re("a"))
12102 >>> print(simplify(InRe("aa", re)))
12103 True
12104 >>> print(simplify(InRe("ab", re)))
12105 False
12106 >>> print(simplify(InRe("", re)))
12107 False
12108 """
12109 if z3_debug():
12110 _z3_assert(is_expr(re), "expression expected")
12111 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
12112
12113
Z3_mk_re_plus
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 11828 of file z3py.py.

11828def PrefixOf(a, b):
11829 """Check if 'a' is a prefix of 'b'
11830 >>> s1 = PrefixOf("ab", "abc")
11831 >>> simplify(s1)
11832 True
11833 >>> s2 = PrefixOf("bc", "abc")
11834 >>> simplify(s2)
11835 False
11836 """
11837 ctx = _get_ctx2(a, b)
11838 a = _coerce_seq(a, ctx)
11839 b = _coerce_seq(b, ctx)
11840 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11841
11842
Z3_mk_seq_prefix
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 9468 of file z3py.py.

9468def probe_description(name, ctx=None):
9469 """Return a short description for the probe named `name`.
9470
9471 >>> d = probe_description('memory')
9472 """
9473 ctx = _get_ctx(ctx)
9474 return Z3_probe_get_descr(ctx.ref(), name)
9475
9476
Z3_probe_get_descr
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 9457 of file z3py.py.

9457def probes(ctx=None):
9458 """Return a list of all available probes in Z3.
9459
9460 >>> l = probes()
9461 >>> l.count('memory') == 1
9462 True
9463 """
9464 ctx = _get_ctx(ctx)
9465 return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
9466
9467
Z3_get_num_probes
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
Z3_get_probe_name
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 9709 of file z3py.py.

9709def Product(*args):
9710 """Create the product of the Z3 expressions.
9711
9712 >>> a, b, c = Ints('a b c')
9713 >>> Product(a, b, c)
9714 a*b*c
9715 >>> Product([a, b, c])
9716 a*b*c
9717 >>> A = IntVector('a', 5)
9718 >>> Product(A)
9719 a__0*a__1*a__2*a__3*a__4
9720 """
9721 args = _get_args(args)
9722 if len(args) == 0:
9723 return 1
9724 ctx = _ctx_from_ast_arg_list(args)
9725 if ctx is None:
9726 return _reduce(lambda a, b: a * b, args, 1)
9727 args = _coerce_expr_list(args, ctx)
9728 if is_bv(args[0]):
9729 return _reduce(lambda a, b: a * b, args, 1)
9730 else:
9731 _args, sz = _to_ast_array(args)
9732 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
9733
Z3_mk_mul
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 12404 of file z3py.py.

12404def PropagateFunction(name, *sig):
12405 """Create a function that gets tracked by user propagator.
12406 Every term headed by this function symbol is tracked.
12407 If a term is fixed and the fixed callback is registered a
12408 callback is invoked that the term headed by this function is fixed.
12409 """
12410 sig = _get_args(sig)
12411 if z3_debug():
12412 _z3_assert(len(sig) > 0, "At least two arguments expected")
12413 arity = len(sig) - 1
12414 rng = sig[arity]
12415 if z3_debug():
12416 _z3_assert(is_sort(rng), "Z3 sort expected")
12417 dom = (Sort * arity)()
12418 for i in range(arity):
12419 if z3_debug():
12420 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
12421 dom[i] = sig[i].ast
12422 ctx = rng.ctx
12423 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
12424
12425
12426
Z3_solver_propagate_declare
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 9896 of file z3py.py.

9896def prove(claim, show=False, **keywords):
9897 """Try to prove the given claim.
9898
9899 This is a simple function for creating demonstrations. It tries to prove
9900 `claim` by showing the negation is unsatisfiable.
9901
9902 >>> p, q = Bools('p q')
9903 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9904 proved
9905 """
9906 if z3_debug():
9907 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9908 s = Solver()
9909 s.set(**keywords)
9910 s.add(Not(claim))
9911 if show:
9912 print(s)
9913 r = s.check()
9914 if r == unsat:
9915 print("proved")
9916 elif r == unknown:
9917 print("failed to prove")
9918 print(s.model())
9919 else:
9920 print("counterexample")
9921 print(s.model())
9922
9923

◆ Q()

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

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

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

Definition at line 3401 of file z3py.py.

3401def Q(a, b, ctx=None):
3402 """Return a Z3 rational a/b.
3403
3404 If `ctx=None`, then the global context is used.
3405
3406 >>> Q(3,5)
3407 3/5
3408 >>> Q(3,5).sort()
3409 Real
3410 """
3411 return simplify(RatVal(a, b, ctx=ctx))
3412
3413

◆ Range()

Range (   lo,
  hi,
  ctx = None 
) 
Create the range regular expression over two sequences of length 1
>>> range = Range("a","z")
>>> print(simplify(InRe("b", range)))
True
>>> print(simplify(InRe("bb", range)))
False

Definition at line 12164 of file z3py.py.

12164def Range(lo, hi, ctx=None):
12165 """Create the range regular expression over two sequences of length 1
12166 >>> range = Range("a","z")
12167 >>> print(simplify(InRe("b", range)))
12168 True
12169 >>> print(simplify(InRe("bb", range)))
12170 False
12171 """
12172 lo = _coerce_seq(lo, ctx)
12173 hi = _coerce_seq(hi, ctx)
12174 if z3_debug():
12175 _z3_assert(is_expr(lo), "expression expected")
12176 _z3_assert(is_expr(hi), "expression expected")
12177 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
12178
Z3_mk_re_range
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.

◆ RatVal()

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

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

Note: Division by zero (b == 0) is allowed in Z3 symbolic expressions.
Z3 can reason about such expressions symbolically.

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

Definition at line 3381 of file z3py.py.

3381def RatVal(a, b, ctx=None):
3382 """Return a Z3 rational a/b.
3383
3384 If `ctx=None`, then the global context is used.
3385
3386 Note: Division by zero (b == 0) is allowed in Z3 symbolic expressions.
3387 Z3 can reason about such expressions symbolically.
3388
3389 >>> RatVal(3,5)
3390 3/5
3391 >>> RatVal(3,5).sort()
3392 Real
3393 """
3394 if z3_debug():
3395 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3396 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3397 # Division by 0 is intentionally allowed - Z3 handles it symbolically
3398 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3399
3400

Referenced by Q().

◆ Re()

Re (   s,
  ctx = None 
) 
The regular expression that accepts sequence 's'
>>> s1 = Re("ab")
>>> s2 = Re(StringVal("ab"))
>>> s3 = Re(Unit(BoolVal(True)))

Definition at line 11992 of file z3py.py.

11992def Re(s, ctx=None):
11993 """The regular expression that accepts sequence 's'
11994 >>> s1 = Re("ab")
11995 >>> s2 = Re(StringVal("ab"))
11996 >>> s3 = Re(Unit(BoolVal(True)))
11997 """
11998 s = _coerce_seq(s, ctx)
11999 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
12000
12001
12002# Regular expressions
12003
Z3_mk_seq_to_re
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.

◆ Real()

Real (   name,
  ctx = None 
) 
Return a real constant named `name`. If `ctx=None`, then the global context is used.

>>> x = Real('x')
>>> is_real(x)
True
>>> is_real(x + 1)
True

Definition at line 3467 of file z3py.py.

3467def Real(name, ctx=None):
3468 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3469
3470 >>> x = Real('x')
3471 >>> is_real(x)
3472 True
3473 >>> is_real(x + 1)
3474 True
3475 """
3476 ctx = _get_ctx(ctx)
3477 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3478
3479

Referenced by Reals(), and RealVector().

◆ Reals()

Reals (   names,
  ctx = None 
) 
Return a tuple of real constants.

>>> x, y, z = Reals('x y z')
>>> Sum(x, y, z)
x + y + z
>>> Sum(x, y, z).sort()
Real

Definition at line 3480 of file z3py.py.

3480def Reals(names, ctx=None):
3481 """Return a tuple of real constants.
3482
3483 >>> x, y, z = Reals('x y z')
3484 >>> Sum(x, y, z)
3485 x + y + z
3486 >>> Sum(x, y, z).sort()
3487 Real
3488 """
3489 ctx = _get_ctx(ctx)
3490 if isinstance(names, str):
3491 names = names.split(" ")
3492 return [Real(name, ctx) for name in names]
3493
3494

◆ RealSort()

RealSort (   ctx = None) 
Return the real sort in the given context. If `ctx=None`, then the global context is used.

>>> RealSort()
Real
>>> x = Const('x', RealSort())
>>> is_real(x)
True
>>> is_int(x)
False
>>> x.sort() == RealSort()
True

Definition at line 3321 of file z3py.py.

3321def RealSort(ctx=None):
3322 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3323
3324 >>> RealSort()
3325 Real
3326 >>> x = Const('x', RealSort())
3327 >>> is_real(x)
3328 True
3329 >>> is_int(x)
3330 False
3331 >>> x.sort() == RealSort()
3332 True
3333 """
3334 ctx = _get_ctx(ctx)
3335 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3336
3337
Z3_mk_real_sort
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 3362 of file z3py.py.

3362def RealVal(val, ctx=None):
3363 """Return a Z3 real value.
3364
3365 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3366 If `ctx=None`, then the global context is used.
3367
3368 >>> RealVal(1)
3369 1
3370 >>> RealVal(1).sort()
3371 Real
3372 >>> RealVal("3/5")
3373 3/5
3374 >>> RealVal("1.5")
3375 3/2
3376 """
3377 ctx = _get_ctx(ctx)
3378 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3379
3380

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

◆ RealVar()

ExprRef RealVar ( int  idx,
  ctx = None 
) 
Create a real free variable. Free variables are used to create quantified formulas.
They are also used to create polynomials.

>>> RealVar(0)
Var(0)

Definition at line 1596 of file z3py.py.

1596def RealVar(idx: int, ctx=None) -> ExprRef:
1597 """
1598 Create a real free variable. Free variables are used to create quantified formulas.
1599 They are also used to create polynomials.
1600
1601 >>> RealVar(0)
1602 Var(0)
1603 """
1604 return Var(idx, RealSort(ctx))
1605

Referenced by RealVarVector().

◆ RealVarVector()

RealVarVector ( int  n,
  ctx = None 
) 
Create a list of Real free variables.
The variables have ids: 0, 1, ..., n-1

>>> x0, x1, x2, x3 = RealVarVector(4)
>>> x2
Var(2)

Definition at line 1606 of file z3py.py.

1606def RealVarVector(n: int, ctx= None):
1607 """
1608 Create a list of Real free variables.
1609 The variables have ids: 0, 1, ..., n-1
1610
1611 >>> x0, x1, x2, x3 = RealVarVector(4)
1612 >>> x2
1613 Var(2)
1614 """
1615 return [RealVar(i, ctx) for i in range(n)]
1616

◆ RealVector()

RealVector (   prefix,
  sz,
  ctx = None 
) 
Return a list of real constants of size `sz`.

>>> X = RealVector('x', 3)
>>> X
[x__0, x__1, x__2]
>>> Sum(X)
x__0 + x__1 + x__2
>>> Sum(X).sort()
Real

Definition at line 3495 of file z3py.py.

3495def RealVector(prefix, sz, ctx=None):
3496 """Return a list of real constants of size `sz`.
3497
3498 >>> X = RealVector('x', 3)
3499 >>> X
3500 [x__0, x__1, x__2]
3501 >>> Sum(X)
3502 x__0 + x__1 + x__2
3503 >>> Sum(X).sort()
3504 Real
3505 """
3506 ctx = _get_ctx(ctx)
3507 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3508
3509

◆ RecAddDefinition()

RecAddDefinition (   f,
  args,
  body 
) 
Set the body of a recursive function.
   Recursive definitions can be simplified if they are applied to ground
   arguments.
>>> ctx = Context()
>>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
>>> n = Int('n', ctx)
>>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
>>> simplify(fac(5))
120
>>> s = Solver(ctx=ctx)
>>> s.add(fac(n) < 3)
>>> s.check()
sat
>>> s.model().eval(fac(5))
120

Definition at line 986 of file z3py.py.

986def RecAddDefinition(f, args, body):
987 """Set the body of a recursive function.
988 Recursive definitions can be simplified if they are applied to ground
989 arguments.
990 >>> ctx = Context()
991 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
992 >>> n = Int('n', ctx)
993 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
994 >>> simplify(fac(5))
995 120
996 >>> s = Solver(ctx=ctx)
997 >>> s.add(fac(n) < 3)
998 >>> s.check()
999 sat
1000 >>> s.model().eval(fac(5))
1001 120
1002 """
1003 if is_app(args):
1004 args = [args]
1005 ctx = body.ctx
1006 args = _get_args(args)
1007 n = len(args)
1008 _args = (Ast * n)()
1009 for i in range(n):
1010 _args[i] = args[i].ast
1011 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
1012
Z3_add_rec_def
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body)
Define the body of a recursive function.

◆ RecFunction()

RecFunction (   name,
*  sig 
) 
Create a new Z3 recursive with the given sorts.

Definition at line 968 of file z3py.py.

968def RecFunction(name, *sig):
969 """Create a new Z3 recursive with the given sorts."""
970 sig = _get_args(sig)
971 if z3_debug():
972 _z3_assert(len(sig) > 0, "At least two arguments expected")
973 arity = len(sig) - 1
974 rng = sig[arity]
975 if z3_debug():
976 _z3_assert(is_sort(rng), "Z3 sort expected")
977 dom = (Sort * arity)()
978 for i in range(arity):
979 if z3_debug():
980 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
981 dom[i] = sig[i].ast
982 ctx = rng.ctx
983 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
984
985
Z3_mk_rec_func_decl
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 9221 of file z3py.py.

9221def Repeat(t, max=4294967295, ctx=None):
9222 """Return a tactic that keeps applying `t` until the goal is not modified anymore
9223 or the maximum number of iterations `max` is reached.
9224
9225 >>> x, y = Ints('x y')
9226 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
9227 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
9228 >>> r = t(c)
9229 >>> for subgoal in r: print(subgoal)
9230 [x == 0, y == 0, x > y]
9231 [x == 0, y == 1, x > y]
9232 [x == 1, y == 0, x > y]
9233 [x == 1, y == 1, x > y]
9234 >>> t = Then(t, Tactic('propagate-values'))
9235 >>> t(c)
9236 [[x == 1, y == 0]]
9237 """
9238 t = _to_tactic(t, ctx)
9239 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
9240
9241
Z3_tactic_repeat
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...

◆ RepeatBitVec()

RepeatBitVec (   n,
  a 
) 
Return an expression representing `n` copies of `a`.

>>> x = BitVec('x', 8)
>>> n = RepeatBitVec(4, x)
>>> n
RepeatBitVec(4, x)
>>> n.size()
32
>>> v0 = BitVecVal(10, 4)
>>> print("%.x" % v0.as_long())
a
>>> v = simplify(RepeatBitVec(4, v0))
>>> v.size()
16
>>> print("%.x" % v.as_long())
aaaa

Definition at line 4617 of file z3py.py.

4617def RepeatBitVec(n, a):
4618 """Return an expression representing `n` copies of `a`.
4619
4620 >>> x = BitVec('x', 8)
4621 >>> n = RepeatBitVec(4, x)
4622 >>> n
4623 RepeatBitVec(4, x)
4624 >>> n.size()
4625 32
4626 >>> v0 = BitVecVal(10, 4)
4627 >>> print("%.x" % v0.as_long())
4628 a
4629 >>> v = simplify(RepeatBitVec(4, v0))
4630 >>> v.size()
4631 16
4632 >>> print("%.x" % v.as_long())
4633 aaaa
4634 """
4635 if z3_debug():
4636 _z3_assert(_is_int(n), "First argument must be an integer")
4637 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4638 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4639
4640
Z3_mk_repeat
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 11877 of file z3py.py.

11877def Replace(s, src, dst):
11878 """Replace the first occurrence of 'src' by 'dst' in 's'
11879 >>> r = Replace("aaa", "a", "b")
11880 >>> simplify(r)
11881 "baa"
11882 """
11883 ctx = _get_ctx2(dst, s)
11884 if ctx is None and is_expr(src):
11885 ctx = src.ctx
11886 src = _coerce_seq(src, ctx)
11887 dst = _coerce_seq(dst, ctx)
11888 s = _coerce_seq(s, ctx)
11889 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11890
11891
Z3_mk_seq_replace
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.

◆ reset_params()

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

Definition at line 322 of file z3py.py.

322def reset_params() -> None:
323 """Reset all global (or module) parameters.
324 """
325 Z3_global_param_reset_all()
326
327
Z3_global_param_reset_all
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 12011 of file z3py.py.

12011def ReSort(s):
12012 if is_ast(s):
12013 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
12014 if s is None or isinstance(s, Context):
12015 ctx = _get_ctx(s)
12016 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
12017 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
12018
12019
Z3_mk_re_sort
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_mk_string_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 10483 of file z3py.py.

10483def RNA(ctx=None):
10484 ctx = _get_ctx(ctx)
10485 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
10486
10487
Z3_mk_fpa_round_nearest_ties_to_away
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 10473 of file z3py.py.

10473def RNE(ctx=None):
10474 ctx = _get_ctx(ctx)
10475 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
10476
10477
Z3_mk_fpa_round_nearest_ties_to_even
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 4527 of file z3py.py.

4527def RotateLeft(a, b):
4528 """Return an expression representing `a` rotated to the left `b` times.
4529
4530 >>> a, b = BitVecs('a b', 16)
4531 >>> RotateLeft(a, b)
4532 RotateLeft(a, b)
4533 >>> simplify(RotateLeft(a, 0))
4534 a
4535 >>> simplify(RotateLeft(a, 16))
4536 a
4537 """
4538 _check_bv_args(a, b)
4539 a, b = _coerce_exprs(a, b)
4540 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4541
4542
Z3_mk_ext_rotate_left
Z3_ast Z3_API Z3_mk_ext_rotate_left(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the left t2 times.

◆ RotateRight()

RotateRight (   a,
  b 
) 
Return an expression representing `a` rotated to the right `b` times.

>>> a, b = BitVecs('a b', 16)
>>> RotateRight(a, b)
RotateRight(a, b)
>>> simplify(RotateRight(a, 0))
a
>>> simplify(RotateRight(a, 16))
a

Definition at line 4543 of file z3py.py.

4543def RotateRight(a, b):
4544 """Return an expression representing `a` rotated to the right `b` times.
4545
4546 >>> a, b = BitVecs('a b', 16)
4547 >>> RotateRight(a, b)
4548 RotateRight(a, b)
4549 >>> simplify(RotateRight(a, 0))
4550 a
4551 >>> simplify(RotateRight(a, 16))
4552 a
4553 """
4554 _check_bv_args(a, b)
4555 a, b = _coerce_exprs(a, b)
4556 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4557
4558
Z3_mk_ext_rotate_right
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 10478 of file z3py.py.

10478def RoundNearestTiesToAway(ctx=None):
10479 ctx = _get_ctx(ctx)
10480 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
10481
10482

◆ RoundNearestTiesToEven()

RoundNearestTiesToEven (   ctx = None)

Definition at line 10468 of file z3py.py.

10468def RoundNearestTiesToEven(ctx=None):
10469 ctx = _get_ctx(ctx)
10470 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
10471
10472

◆ RoundTowardNegative()

RoundTowardNegative (   ctx = None)

Definition at line 10498 of file z3py.py.

10498def RoundTowardNegative(ctx=None):
10499 ctx = _get_ctx(ctx)
10500 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
10501
10502
Z3_mk_fpa_round_toward_negative
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 10488 of file z3py.py.

10488def RoundTowardPositive(ctx=None):
10489 ctx = _get_ctx(ctx)
10490 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
10491
10492
Z3_mk_fpa_round_toward_positive
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 10508 of file z3py.py.

10508def RoundTowardZero(ctx=None):
10509 ctx = _get_ctx(ctx)
10510 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
10511
10512
Z3_mk_fpa_round_toward_zero
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 10503 of file z3py.py.

10503def RTN(ctx=None):
10504 ctx = _get_ctx(ctx)
10505 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
10506
10507

◆ RTP()

RTP (   ctx = None)

Definition at line 10493 of file z3py.py.

10493def RTP(ctx=None):
10494 ctx = _get_ctx(ctx)
10495 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
10496
10497

◆ RTZ()

RTZ (   ctx = None)

Definition at line 10513 of file z3py.py.

10513def RTZ(ctx=None):
10514 ctx = _get_ctx(ctx)
10515 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
10516
10517

◆ Select()

Select (   a,
*  args 
) 
Return a Z3 select array expression.

>>> a = Array('a', IntSort(), IntSort())
>>> i = Int('i')
>>> Select(a, i)
a[i]
>>> eq(Select(a, i), a[i])
True

Definition at line 5042 of file z3py.py.

5042def Select(a, *args):
5043 """Return a Z3 select array expression.
5044
5045 >>> a = Array('a', IntSort(), IntSort())
5046 >>> i = Int('i')
5047 >>> Select(a, i)
5048 a[i]
5049 >>> eq(Select(a, i), a[i])
5050 True
5051 """
5052 args = _get_args(args)
5053 if z3_debug():
5054 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
5055 return a[args]
5056
5057

◆ SeqFoldLeft()

SeqFoldLeft (   f,
  a,
  s 
)

Definition at line 11944 of file z3py.py.

11944def SeqFoldLeft(f, a, s):
11945 ctx = _get_ctx2(f, s)
11946 s = _coerce_seq(s, ctx)
11947 a = _py2expr(a)
11948 return _to_expr_ref(Z3_mk_seq_foldl(s.ctx_ref(), f.as_ast(), a.as_ast(), s.as_ast()), ctx)
11949
Z3_mk_seq_foldl
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 11950 of file z3py.py.

11950def SeqFoldLeftI(f, i, a, s):
11951 ctx = _get_ctx2(f, s)
11952 s = _coerce_seq(s, ctx)
11953 a = _py2expr(a)
11954 i = _py2expr(i)
11955 return _to_expr_ref(Z3_mk_seq_foldli(s.ctx_ref(), f.as_ast(), i.as_ast(), a.as_ast(), s.as_ast()), ctx)
11956
Z3_mk_seq_foldli
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 11930 of file z3py.py.

11930def SeqMap(f, s):
11931 """Map function 'f' over sequence 's'"""
11932 ctx = _get_ctx2(f, s)
11933 s = _coerce_seq(s, ctx)
11934 return _to_expr_ref(Z3_mk_seq_map(s.ctx_ref(), f.as_ast(), s.as_ast()), ctx)
11935
Z3_mk_seq_map
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 11936 of file z3py.py.

11936def SeqMapI(f, i, s):
11937 """Map function 'f' over sequence 's' at index 'i'"""
11938 ctx = _get_ctx2(f, s)
11939 s = _coerce_seq(s, ctx)
11940 if not is_expr(i):
11941 i = _py2expr(i)
11942 return _to_expr_ref(Z3_mk_seq_mapi(s.ctx_ref(), f.as_ast(), i.as_ast(), s.as_ast()), ctx)
11943
Z3_mk_seq_mapi
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 11577 of file z3py.py.

11577def SeqSort(s):
11578 """Create a sequence sort over elements provided in the argument
11579 >>> s = SeqSort(IntSort())
11580 >>> s == Unit(IntVal(1)).sort()
11581 True
11582 """
11583 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
11584
11585
Z3_mk_seq_sort
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 10129 of file z3py.py.

10129def set_default_fp_sort(ebits, sbits, ctx=None):
10130 global _dflt_fpsort_ebits
10131 global _dflt_fpsort_sbits
10132 _dflt_fpsort_ebits = ebits
10133 _dflt_fpsort_sbits = sbits
10134
10135

◆ set_default_rounding_mode()

set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 10116 of file z3py.py.

10116def set_default_rounding_mode(rm, ctx=None):
10117 global _dflt_rounding_mode
10118 if is_fprm_value(rm):
10119 _dflt_rounding_mode = rm.kind()
10120 else:
10121 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
10122 _dflt_rounding_mode = rm
10123
10124

◆ set_option()

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

Definition at line 328 of file z3py.py.

328def set_option(*args, **kws):
329 """Alias for 'set_param' for backward compatibility.
330 """
331 return set_param(*args, **kws)
332
333

◆ set_param()

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

>>> set_param(precision=10)

Definition at line 298 of file z3py.py.

298def set_param(*args, **kws):
299 """Set Z3 global (or module) parameters.
300
301 >>> set_param(precision=10)
302 """
303 if z3_debug():
304 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
305 new_kws = {}
306 for k in kws:
307 v = kws[k]
308 if not set_pp_option(k, v):
309 new_kws[k] = v
310 for key in new_kws:
311 value = new_kws[key]
312 Z3_global_param_set(str(key).upper(), _to_param_value(value))
313 prev = None
314 for a in args:
315 if prev is None:
316 prev = a
317 else:
318 Z3_global_param_set(str(prev), _to_param_value(a))
319 prev = None
320
321
Z3_global_param_set
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.

Referenced by set_option().

◆ SetAdd()

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

Definition at line 5221 of file z3py.py.

5221def SetAdd(s, e):
5222 """ Add element e to set s
5223 >>> a = Const('a', SetSort(IntSort()))
5224 >>> SetAdd(a, 1)
5225 Store(a, 1, True)
5226 """
5227 ctx = _ctx_from_ast_arg_list([s, e])
5228 e = _py2expr(e, ctx)
5229 if is_finite_set(s):
5230 return FiniteSetSingleton(e) | s
5231 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5232
5233
Z3_mk_set_add
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.

◆ SetComplement()

SetComplement (   s) 
 The complement of set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetComplement(a)
complement(a)

Definition at line 5247 of file z3py.py.

5247def SetComplement(s):
5248 """ The complement of set s
5249 >>> a = Const('a', SetSort(IntSort()))
5250 >>> SetComplement(a)
5251 complement(a)
5252 """
5253 ctx = s.ctx
5254 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
5255
5256
Z3_mk_set_complement
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.

◆ SetDel()

SetDel (   s,
  e 
) 
 Remove element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetDel(a, 1)
Store(a, 1, False)

Definition at line 5234 of file z3py.py.

5234def SetDel(s, e):
5235 """ Remove element e to set s
5236 >>> a = Const('a', SetSort(IntSort()))
5237 >>> SetDel(a, 1)
5238 Store(a, 1, False)
5239 """
5240 ctx = _ctx_from_ast_arg_list([s, e])
5241 e = _py2expr(e, ctx)
5242 if is_finite_set(s):
5243 return s - FiniteSetSingleton(e)
5244 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5245
5246
Z3_mk_set_del
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.

◆ SetDifference()

SetDifference (   a,
  b 
) 
 The set difference of a and b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetDifference(a, b)
setminus(a, b)

Definition at line 5257 of file z3py.py.

5257def SetDifference(a, b):
5258 """ The set difference of a and b
5259 >>> a = Const('a', SetSort(IntSort()))
5260 >>> b = Const('b', SetSort(IntSort()))
5261 >>> SetDifference(a, b)
5262 setminus(a, b)
5263 """
5264 ctx = _ctx_from_ast_arg_list([a, b])
5265 if is_finite_set(a):
5266 return FiniteSetDifference(a, b)
5267 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5268
5269
Z3_mk_set_difference
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.

◆ SetIntersect()

SetIntersect ( *  args) 
 Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetIntersect(a, b)
intersection(a, b)

Definition at line 5205 of file z3py.py.

5205def SetIntersect(*args):
5206 """ Take the union of sets
5207 >>> a = Const('a', SetSort(IntSort()))
5208 >>> b = Const('b', SetSort(IntSort()))
5209 >>> SetIntersect(a, b)
5210 intersection(a, b)
5211 """
5212 args = _get_args(args)
5213 ctx = _ctx_from_ast_arg_list(args)
5214 if len(args) > 0 and is_finite_set(args[0]):
5215 from functools import reduce
5216 return reduce(FiniteSetIntersect, args)
5217 _args, sz = _to_ast_array(args)
5218 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
5219
5220
Z3_mk_set_intersect
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 5164 of file z3py.py.

5164def SetSort(s):
5165 """ Create a set sort over element sort s"""
5166 return ArraySort(s, BoolSort())
5167
5168

◆ SetUnion()

SetUnion ( *  args) 
 Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetUnion(a, b)
union(a, b)

Definition at line 5189 of file z3py.py.

5189def SetUnion(*args):
5190 """ Take the union of sets
5191 >>> a = Const('a', SetSort(IntSort()))
5192 >>> b = Const('b', SetSort(IntSort()))
5193 >>> SetUnion(a, b)
5194 union(a, b)
5195 """
5196 args = _get_args(args)
5197 if len(args) > 0 and is_finite_set(args[0]):
5198 from functools import reduce
5199 return reduce(FiniteSetUnion, args)
5200 ctx = _ctx_from_ast_arg_list(args)
5201 _args, sz = _to_ast_array(args)
5202 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
5203
5204
Z3_mk_set_union
Z3_ast Z3_API Z3_mk_set_union(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the union of a list of sets.

◆ SignExt()

SignExt (   n,
  a 
) 
Return a bit-vector expression with `n` extra sign-bits.

>>> x = BitVec('x', 16)
>>> n = SignExt(8, x)
>>> n.size()
24
>>> n
SignExt(8, x)
>>> n.sort()
BitVec(24)
>>> v0 = BitVecVal(2, 2)
>>> v0
2
>>> v0.size()
2
>>> v  = simplify(SignExt(6, v0))
>>> v
254
>>> v.size()
8
>>> print("%.x" % v.as_long())
fe

Definition at line 4559 of file z3py.py.

4559def SignExt(n, a):
4560 """Return a bit-vector expression with `n` extra sign-bits.
4561
4562 >>> x = BitVec('x', 16)
4563 >>> n = SignExt(8, x)
4564 >>> n.size()
4565 24
4566 >>> n
4567 SignExt(8, x)
4568 >>> n.sort()
4569 BitVec(24)
4570 >>> v0 = BitVecVal(2, 2)
4571 >>> v0
4572 2
4573 >>> v0.size()
4574 2
4575 >>> v = simplify(SignExt(6, v0))
4576 >>> v
4577 254
4578 >>> v.size()
4579 8
4580 >>> print("%.x" % v.as_long())
4581 fe
4582 """
4583 if z3_debug():
4584 _z3_assert(_is_int(n), "First argument must be an integer")
4585 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4586 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4587
4588
Z3_mk_sign_ext
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...

◆ SimpleSolver()

SimpleSolver (   ctx = None,
  logFile = None 
) 
Return a simple general purpose solver with limited amount of preprocessing.

>>> s = SimpleSolver()
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.check()
sat

Definition at line 8130 of file z3py.py.

8130def SimpleSolver(ctx=None, logFile=None):
8131 """Return a simple general purpose solver with limited amount of preprocessing.
8132
8133 >>> s = SimpleSolver()
8134 >>> x = Int('x')
8135 >>> s.add(x > 0)
8136 >>> s.check()
8137 sat
8138 """
8139 ctx = _get_ctx(ctx)
8140 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
8141
Z3_mk_simple_solver
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 9573 of file z3py.py.

9573def simplify(a, *arguments, **keywords):
9574 """Simplify the expression `a` using the given options.
9575
9576 This function has many options. Use `help_simplify` to obtain the complete list.
9577
9578 >>> x = Int('x')
9579 >>> y = Int('y')
9580 >>> simplify(x + 1 + y + x + 1)
9581 2 + 2*x + y
9582 >>> simplify((x + 1)*(y + 1), som=True)
9583 1 + x + y + x*y
9584 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
9585 And(Not(x == y), Not(x == 1), Not(y == 1))
9586 >>> simplify(And(x == 0, y == 1), elim_and=True)
9587 Not(Or(Not(x == 0), Not(y == 1)))
9588 """
9589 if z3_debug():
9590 _z3_assert(is_expr(a), "Z3 expression expected")
9591 if len(arguments) > 0 or len(keywords) > 0:
9592 p = args2params(arguments, keywords, a.ctx)
9593 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
9594 else:
9595 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
9596
9597
Z3_simplify
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_simplify_ex
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 9603 of file z3py.py.

9603def simplify_param_descrs():
9604 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
9605 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
9606
9607
Z3_simplify_get_param_descrs
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.

◆ Singleton()

Singleton (   elem) 
Create a singleton finite set containing elem.
>>> Singleton(IntVal(1))
set.singleton(1)

Definition at line 5403 of file z3py.py.

5403def Singleton(elem):
5404 """Create a singleton finite set containing elem.
5405 >>> Singleton(IntVal(1))
5406 set.singleton(1)
5407 """
5408 ctx = elem.ctx
5409 return FiniteSetRef(Z3_mk_finite_set_singleton(ctx.ref(), elem.as_ast()), ctx)
5410
5411
Z3_mk_finite_set_singleton
Z3_ast Z3_API Z3_mk_finite_set_singleton(Z3_context c, Z3_ast elem)
Create a singleton finite set.

Referenced by FiniteSetSortRef.cast().

◆ solve()

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

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

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

Definition at line 9835 of file z3py.py.

9835def solve(*args, **keywords):
9836 """Solve the constraints `*args`.
9837
9838 This is a simple function for creating demonstrations. It creates a solver,
9839 configure it using the options in `keywords`, adds the constraints
9840 in `args`, and invokes check.
9841
9842 >>> a = Int('a')
9843 >>> solve(a > 0, a < 2)
9844 [a = 1]
9845 """
9846 show = keywords.pop("show", False)
9847 s = Solver()
9848 s.set(**keywords)
9849 s.add(*args)
9850 if show:
9851 print(s)
9852 r = s.check()
9853 if r == unsat:
9854 print("no solution")
9855 elif r == unknown:
9856 print("failed to solve")
9857 try:
9858 print(s.model())
9859 except Z3Exception:
9860 return
9861 else:
9862 print(s.model())
9863
9864

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

9865def solve_using(s, *args, **keywords):
9866 """Solve the constraints `*args` using solver `s`.
9867
9868 This is a simple function for creating demonstrations. It is similar to `solve`,
9869 but it uses the given solver `s`.
9870 It configures solver `s` using the options in `keywords`, adds the constraints
9871 in `args`, and invokes check.
9872 """
9873 show = keywords.pop("show", False)
9874 if z3_debug():
9875 _z3_assert(isinstance(s, Solver), "Solver object expected")
9876 s.set(**keywords)
9877 s.add(*args)
9878 if show:
9879 print("Problem:")
9880 print(s)
9881 r = s.check()
9882 if r == unsat:
9883 print("no solution")
9884 elif r == unknown:
9885 print("failed to solve")
9886 try:
9887 print(s.model())
9888 except Z3Exception:
9889 return
9890 else:
9891 if show:
9892 print("Solution:")
9893 print(s.model())
9894
9895

◆ SolverFor()

SolverFor (   logic,
  ctx = None,
  logFile = None 
) 
Create a solver customized for the given logic.

The parameter `logic` is a string. It should be contains
the name of a SMT-LIB logic.
See http://www.smtlib.org/ for the name of all available logics.

>>> s = SolverFor("QF_LIA")
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.add(x < 2)
>>> s.check()
sat
>>> s.model()
[x = 1]

Definition at line 8109 of file z3py.py.

8109def SolverFor(logic, ctx=None, logFile=None):
8110 """Create a solver customized for the given logic.
8111
8112 The parameter `logic` is a string. It should be contains
8113 the name of a SMT-LIB logic.
8114 See http://www.smtlib.org/ for the name of all available logics.
8115
8116 >>> s = SolverFor("QF_LIA")
8117 >>> x = Int('x')
8118 >>> s.add(x > 0)
8119 >>> s.add(x < 2)
8120 >>> s.check()
8121 sat
8122 >>> s.model()
8123 [x = 1]
8124 """
8125 ctx = _get_ctx(ctx)
8126 logic = to_symbol(logic)
8127 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
8128
8129
Z3_mk_solver_for_logic
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic)
Create a new solver customized for the given logic. It behaves like Z3_mk_solver if the logic is unkn...

◆ Sqrt()

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

>>> x = Real('x')
>>> Sqrt(x)
x**(1/2)

Definition at line 3579 of file z3py.py.

3579def Sqrt(a, ctx=None):
3580 """ Return a Z3 expression which represents the square root of a.
3581
3582 >>> x = Real('x')
3583 >>> Sqrt(x)
3584 x**(1/2)
3585 """
3586 if not is_expr(a):
3587 ctx = _get_ctx(ctx)
3588 a = RealVal(a, ctx)
3589 return a ** "1/2"
3590
3591

◆ SRem()

SRem (   a,
  b 
) 
Create the Z3 expression signed remainder.

Use the operator % for signed modulus, and URem() for unsigned remainder.

>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> SRem(x, y)
SRem(x, y)
>>> SRem(x, y).sort()
BitVec(32)
>>> (x % y).sexpr()
'(bvsmod x y)'
>>> SRem(x, y).sexpr()
'(bvsrem x y)'

Definition at line 4474 of file z3py.py.

4474def SRem(a, b):
4475 """Create the Z3 expression signed remainder.
4476
4477 Use the operator % for signed modulus, and URem() for unsigned remainder.
4478
4479 >>> x = BitVec('x', 32)
4480 >>> y = BitVec('y', 32)
4481 >>> SRem(x, y)
4482 SRem(x, y)
4483 >>> SRem(x, y).sort()
4484 BitVec(32)
4485 >>> (x % y).sexpr()
4486 '(bvsmod x y)'
4487 >>> SRem(x, y).sexpr()
4488 '(bvsrem x y)'
4489 """
4490 _check_bv_args(a, b)
4491 a, b = _coerce_exprs(a, b)
4492 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4493
4494
Z3_mk_bvsrem
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 12134 of file z3py.py.

12134def Star(re):
12135 """Create the regular expression accepting zero or more repetitions of argument.
12136 >>> re = Star(Re("a"))
12137 >>> print(simplify(InRe("aa", re)))
12138 True
12139 >>> print(simplify(InRe("ab", re)))
12140 False
12141 >>> print(simplify(InRe("", re)))
12142 True
12143 """
12144 if z3_debug():
12145 _z3_assert(is_expr(re), "expression expected")
12146 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
12147
12148
Z3_mk_re_star
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 5025 of file z3py.py.

5025def Store(a, *args):
5026 """Return a Z3 store array expression.
5027
5028 >>> a = Array('a', IntSort(), IntSort())
5029 >>> i, v = Ints('i v')
5030 >>> s = Store(a, i, v)
5031 >>> s.sort()
5032 Array(Int, Int)
5033 >>> prove(s[i] == v)
5034 proved
5035 >>> j = Int('j')
5036 >>> prove(Implies(i != j, s[j] == a[j]))
5037 proved
5038 """
5039 return Update(a, args)
5040
5041

Referenced by ModelRef.get_interp().

◆ StrFromCode()

StrFromCode (   c) 
Convert code to a string

Definition at line 11986 of file z3py.py.

11986def StrFromCode(c):
11987 """Convert code to a string"""
11988 if not is_expr(c):
11989 c = _py2expr(c)
11990 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11991
Z3_mk_string_from_code
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 11743 of file z3py.py.

11743def String(name, ctx=None):
11744 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11745
11746 >>> x = String('x')
11747 """
11748 ctx = _get_ctx(ctx)
11749 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
11750
11751

◆ Strings()

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

Definition at line 11752 of file z3py.py.

11752def Strings(names, ctx=None):
11753 """Return a tuple of String constants. """
11754 ctx = _get_ctx(ctx)
11755 if isinstance(names, str):
11756 names = names.split(" ")
11757 return [String(name, ctx) for name in names]
11758
11759

◆ StringSort()

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

Definition at line 11558 of file z3py.py.

11558def StringSort(ctx=None):
11559 """Create a string sort
11560 >>> s = StringSort()
11561 >>> print(s)
11562 String
11563 """
11564 ctx = _get_ctx(ctx)
11565 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
11566

◆ StringVal()

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

Definition at line 11736 of file z3py.py.

11736def StringVal(s, ctx=None):
11737 """create a string expression"""
11738 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11739 ctx = _get_ctx(ctx)
11740 return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
11741
11742
Z3_mk_string
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 11980 of file z3py.py.

11980def StrToCode(s):
11981 """Convert a unit length string to integer code"""
11982 if not is_expr(s):
11983 s = _py2expr(s)
11984 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11985
Z3_mk_string_to_code
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 11957 of file z3py.py.

11957def StrToInt(s):
11958 """Convert string expression to integer
11959 >>> a = StrToInt("1")
11960 >>> simplify(1 == a)
11961 True
11962 >>> b = StrToInt("2")
11963 >>> simplify(1 == b)
11964 False
11965 >>> c = StrToInt(IntToStr(2))
11966 >>> simplify(1 == c)
11967 False
11968 """
11969 s = _coerce_seq(s)
11970 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11971
11972
Z3_mk_str_to_int
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.

This is a convenience function that redirects to Extract(s, offset, length).

>>> s = StringVal("hello world")
>>> SubSeq(s, 0, 5)  # Extract "hello"  
str.substr("hello world", 0, 5)
>>> simplify(SubSeq(StringVal("testing"), 2, 4))
"stin"

Definition at line 11774 of file z3py.py.

11774def SubSeq(s, offset, length):
11775 """Extract substring or subsequence starting at offset.
11776
11777 This is a convenience function that redirects to Extract(s, offset, length).
11778
11779 >>> s = StringVal("hello world")
11780 >>> SubSeq(s, 0, 5) # Extract "hello"
11781 str.substr("hello world", 0, 5)
11782 >>> simplify(SubSeq(StringVal("testing"), 2, 4))
11783 "stin"
11784 """
11785 return Extract(s, offset, length)
11786
11787

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

9608def substitute(t, *m):
9609 """Apply substitution m on t, m is a list of pairs of the form (from, to).
9610 Every occurrence in t of from is replaced with to.
9611
9612 >>> x = Int('x')
9613 >>> y = Int('y')
9614 >>> substitute(x + 1, (x, y + 1))
9615 y + 1 + 1
9616 >>> f = Function('f', IntSort(), IntSort())
9617 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
9618 1 + 1
9619 """
9620 if isinstance(m, tuple):
9621 m1 = _get_args(m)
9622 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9623 m = m1
9624 if z3_debug():
9625 _z3_assert(is_expr(t), "Z3 expression expected")
9626 _z3_assert(
9627 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
9628 "Z3 invalid substitution, expression pairs expected.")
9629 _z3_assert(
9630 all([p[0].sort().eq(p[1].sort()) for p in m]),
9631 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
9632 num = len(m)
9633 _from = (Ast * num)()
9634 _to = (Ast * num)()
9635 for i in range(num):
9636 _from[i] = m[i][0].as_ast()
9637 _to[i] = m[i][1].as_ast()
9638 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
9639
9640
Z3_substitute
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 9661 of file z3py.py.

9661def substitute_funs(t, *m):
9662 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
9663 Every occurrence in to of the function from is replaced with the expression to.
9664 The expression to can have free variables, that refer to the arguments of from.
9665 For examples, see
9666 """
9667 if isinstance(m, tuple):
9668 m1 = _get_args(m)
9669 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
9670 m = m1
9671 if z3_debug():
9672 _z3_assert(is_expr(t), "Z3 expression expected")
9673 _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.")
9674 num = len(m)
9675 _from = (FuncDecl * num)()
9676 _to = (Ast * num)()
9677 for i in range(num):
9678 _from[i] = m[i][0].as_func_decl()
9679 _to[i] = m[i][1].as_ast()
9680 return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
9681
9682
Z3_substitute_funs
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 9641 of file z3py.py.

9641def substitute_vars(t, *m):
9642 """Substitute the free variables in t with the expression in m.
9643
9644 >>> v0 = Var(0, IntSort())
9645 >>> v1 = Var(1, IntSort())
9646 >>> x = Int('x')
9647 >>> f = Function('f', IntSort(), IntSort(), IntSort())
9648 >>> # replace v0 with x+1 and v1 with x
9649 >>> substitute_vars(f(v0, v1), x + 1, x)
9650 f(x + 1, x)
9651 """
9652 if z3_debug():
9653 _z3_assert(is_expr(t), "Z3 expression expected")
9654 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
9655 num = len(m)
9656 _to = (Ast * num)()
9657 for i in range(num):
9658 _to[i] = m[i].as_ast()
9659 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
9660
Z3_substitute_vars
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the variables in a with the expressions in to. For every i smaller than num_exprs,...

◆ SubString()

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

This is a convenience function that redirects to Extract(s, offset, length).

>>> s = StringVal("hello world") 
>>> SubString(s, 6, 5)  # Extract "world"
str.substr("hello world", 6, 5)
>>> simplify(SubString(StringVal("hello"), 1, 3))
"ell"

Definition at line 11760 of file z3py.py.

11760def SubString(s, offset, length):
11761 """Extract substring or subsequence starting at offset.
11762
11763 This is a convenience function that redirects to Extract(s, offset, length).
11764
11765 >>> s = StringVal("hello world")
11766 >>> SubString(s, 6, 5) # Extract "world"
11767 str.substr("hello world", 6, 5)
11768 >>> simplify(SubString(StringVal("hello"), 1, 3))
11769 "ell"
11770 """
11771 return Extract(s, offset, length)
11772
11773

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

11843def SuffixOf(a, b):
11844 """Check if 'a' is a suffix of 'b'
11845 >>> s1 = SuffixOf("ab", "abc")
11846 >>> simplify(s1)
11847 False
11848 >>> s2 = SuffixOf("bc", "abc")
11849 >>> simplify(s2)
11850 True
11851 """
11852 ctx = _get_ctx2(a, b)
11853 a = _coerce_seq(a, ctx)
11854 b = _coerce_seq(b, ctx)
11855 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11856
11857
Z3_mk_seq_suffix
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 9683 of file z3py.py.

9683def Sum(*args):
9684 """Create the sum of the Z3 expressions.
9685
9686 >>> a, b, c = Ints('a b c')
9687 >>> Sum(a, b, c)
9688 a + b + c
9689 >>> Sum([a, b, c])
9690 a + b + c
9691 >>> A = IntVector('a', 5)
9692 >>> Sum(A)
9693 a__0 + a__1 + a__2 + a__3 + a__4
9694 """
9695 args = _get_args(args)
9696 if len(args) == 0:
9697 return 0
9698 ctx = _ctx_from_ast_arg_list(args)
9699 if ctx is None:
9700 return _reduce(lambda a, b: a + b, args, 0)
9701 args = _coerce_expr_list(args, ctx)
9702 if is_bv(args[0]):
9703 return _reduce(lambda a, b: a + b, args, 0)
9704 else:
9705 _args, sz = _to_ast_array(args)
9706 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
9707
9708
Z3_mk_add
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 9262 of file z3py.py.

9262def tactic_description(name, ctx=None):
9263 """Return a short description for the tactic named `name`.
9264
9265 >>> d = tactic_description('simplify')
9266 """
9267 ctx = _get_ctx(ctx)
9268 return Z3_tactic_get_descr(ctx.ref(), name)
9269
9270
Z3_tactic_get_descr
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 9251 of file z3py.py.

9251def tactics(ctx=None):
9252 """Return a list of all available tactics in Z3.
9253
9254 >>> l = tactics()
9255 >>> l.count('simplify') == 1
9256 True
9257 """
9258 ctx = _get_ctx(ctx)
9259 return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
9260
9261
Z3_get_num_tactics
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
Z3_get_tactic_name
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 9119 of file z3py.py.

9119def Then(*ts, **ks):
9120 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
9121
9122 >>> x, y = Ints('x y')
9123 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
9124 >>> t(And(x == 0, y > x + 1))
9125 [[Not(y <= 1)]]
9126 >>> t(And(x == 0, y > x + 1)).as_expr()
9127 Not(y <= 1)
9128 """
9129 return AndThen(*ts, **ks)
9130
9131

◆ to_Ast()

to_Ast (   ptr)

Definition at line 12218 of file z3py.py.

12218def to_Ast(ptr,):
12219 ast = Ast(ptr)
12220 super(ctypes.c_void_p, ast).__init__(ptr)
12221 return ast
12222

◆ to_AstVectorObj()

to_AstVectorObj (   ptr)

Definition at line 12228 of file z3py.py.

12228def to_AstVectorObj(ptr,):
12229 v = AstVectorObj(ptr)
12230 super(ctypes.c_void_p, v).__init__(ptr)
12231 return v
12232
12233# NB. my-hacky-class only works for a single instance of OnClause
12234# it should be replaced with a proper correlation between OnClause
12235# and object references that can be passed over the FFI.
12236# for UserPropagator we use a global dictionary, which isn't great code.
12237

◆ to_ContextObj()

to_ContextObj (   ptr)

Definition at line 12223 of file z3py.py.

12223def to_ContextObj(ptr,):
12224 ctx = ContextObj(ptr)
12225 super(ctypes.c_void_p, ctx).__init__(ptr)
12226 return ctx
12227

◆ to_symbol()

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

Definition at line 132 of file z3py.py.

132def to_symbol(s, ctx = None):
133 """Convert an integer or string into a Z3 symbol."""
134 if _is_int(s):
135 return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
136 else:
137 return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
138
139
Z3_mk_string_symbol
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_mk_int_symbol
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.

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

◆ ToInt()

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

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

Definition at line 3544 of file z3py.py.

3544def ToInt(a):
3545 """ Return the Z3 expression ToInt(a).
3546
3547 >>> x = Real('x')
3548 >>> x.sort()
3549 Real
3550 >>> n = ToInt(x)
3551 >>> n
3552 ToInt(x)
3553 >>> n.sort()
3554 Int
3555 """
3556 if z3_debug():
3557 _z3_assert(a.is_real(), "Z3 real expression expected.")
3558 ctx = a.ctx
3559 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3560
3561
Z3_mk_real2int
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 3524 of file z3py.py.

3524def ToReal(a):
3525 """ Return the Z3 expression ToReal(a).
3526
3527 >>> x = Int('x')
3528 >>> x.sort()
3529 Int
3530 >>> n = ToReal(x)
3531 >>> n
3532 ToReal(x)
3533 >>> n.sort()
3534 Real
3535 """
3536 ctx = a.ctx
3537 if isinstance(a, BoolRef):
3538 return If(a, RealVal(1, ctx), RealVal(0, ctx))
3539 if z3_debug():
3540 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3541 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3542
3543
Z3_mk_int2real
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 12211 of file z3py.py.

12211def TransitiveClosure(f):
12212 """Given a binary relation R, such that the two arguments have the same sort
12213 create the transitive closure relation R+.
12214 The transitive closure R+ is a new relation.
12215 """
12216 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
12217
Z3_mk_transitive_closure
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 12203 of file z3py.py.

12203def TreeOrder(a, index):
12204 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
12205
12206
Z3_mk_tree_order
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 9242 of file z3py.py.

9242def TryFor(t, ms, ctx=None):
9243 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
9244
9245 If `t` does not terminate in `ms` milliseconds, then it fails.
9246 """
9247 t = _to_tactic(t, ctx)
9248 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
9249
9250
Z3_tactic_try_for
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms)
Return a tactic that applies t to a given goal for ms milliseconds. If t does not terminate in ms mil...

◆ TupleSort()

TupleSort (   name,
  sorts,
  ctx = None 
) 
Create a named tuple sort base on a set of underlying sorts
Example:
    >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])

Definition at line 5975 of file z3py.py.

5975def TupleSort(name, sorts, ctx=None):
5976 """Create a named tuple sort base on a set of underlying sorts
5977 Example:
5978 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5979 """
5980 tuple = Datatype(name, ctx)
5981 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5982 tuple.declare(name, *projects)
5983 tuple = tuple.create()
5984 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5985
5986

◆ UDiv()

UDiv (   a,
  b 
) 
Create the Z3 expression (unsigned) division `self / other`.

Use the operator / for signed division.

>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> UDiv(x, y)
UDiv(x, y)
>>> UDiv(x, y).sort()
BitVec(32)
>>> (x / y).sexpr()
'(bvsdiv x y)'
>>> UDiv(x, y).sexpr()
'(bvudiv x y)'

Definition at line 4432 of file z3py.py.

4432def UDiv(a, b):
4433 """Create the Z3 expression (unsigned) division `self / other`.
4434
4435 Use the operator / for signed division.
4436
4437 >>> x = BitVec('x', 32)
4438 >>> y = BitVec('y', 32)
4439 >>> UDiv(x, y)
4440 UDiv(x, y)
4441 >>> UDiv(x, y).sort()
4442 BitVec(32)
4443 >>> (x / y).sexpr()
4444 '(bvsdiv x y)'
4445 >>> UDiv(x, y).sexpr()
4446 '(bvudiv x y)'
4447 """
4448 _check_bv_args(a, b)
4449 a, b = _coerce_exprs(a, b)
4450 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4451
4452
Z3_mk_bvudiv
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 4396 of file z3py.py.

4396def UGE(a, b):
4397 """Create the Z3 expression (unsigned) `other >= self`.
4398
4399 Use the operator >= for signed greater than or equal to.
4400
4401 >>> x, y = BitVecs('x y', 32)
4402 >>> UGE(x, y)
4403 UGE(x, y)
4404 >>> (x >= y).sexpr()
4405 '(bvsge x y)'
4406 >>> UGE(x, y).sexpr()
4407 '(bvuge x y)'
4408 """
4409 _check_bv_args(a, b)
4410 a, b = _coerce_exprs(a, b)
4411 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4412
4413
Z3_mk_bvuge
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.

◆ UGT()

UGT (   a,
  b 
) 
Create the Z3 expression (unsigned) `other > self`.

Use the operator > for signed greater than.

>>> x, y = BitVecs('x y', 32)
>>> UGT(x, y)
UGT(x, y)
>>> (x > y).sexpr()
'(bvsgt x y)'
>>> UGT(x, y).sexpr()
'(bvugt x y)'

Definition at line 4414 of file z3py.py.

4414def UGT(a, b):
4415 """Create the Z3 expression (unsigned) `other > self`.
4416
4417 Use the operator > for signed greater than.
4418
4419 >>> x, y = BitVecs('x y', 32)
4420 >>> UGT(x, y)
4421 UGT(x, y)
4422 >>> (x > y).sexpr()
4423 '(bvsgt x y)'
4424 >>> UGT(x, y).sexpr()
4425 '(bvugt x y)'
4426 """
4427 _check_bv_args(a, b)
4428 a, b = _coerce_exprs(a, b)
4429 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4430
4431
Z3_mk_bvugt
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 4360 of file z3py.py.

4360def ULE(a, b):
4361 """Create the Z3 expression (unsigned) `other <= self`.
4362
4363 Use the operator <= for signed less than or equal to.
4364
4365 >>> x, y = BitVecs('x y', 32)
4366 >>> ULE(x, y)
4367 ULE(x, y)
4368 >>> (x <= y).sexpr()
4369 '(bvsle x y)'
4370 >>> ULE(x, y).sexpr()
4371 '(bvule x y)'
4372 """
4373 _check_bv_args(a, b)
4374 a, b = _coerce_exprs(a, b)
4375 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4376
4377
Z3_mk_bvule
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.

◆ ULT()

ULT (   a,
  b 
) 
Create the Z3 expression (unsigned) `other < self`.

Use the operator < for signed less than.

>>> x, y = BitVecs('x y', 32)
>>> ULT(x, y)
ULT(x, y)
>>> (x < y).sexpr()
'(bvslt x y)'
>>> ULT(x, y).sexpr()
'(bvult x y)'

Definition at line 4378 of file z3py.py.

4378def ULT(a, b):
4379 """Create the Z3 expression (unsigned) `other < self`.
4380
4381 Use the operator < for signed less than.
4382
4383 >>> x, y = BitVecs('x y', 32)
4384 >>> ULT(x, y)
4385 ULT(x, y)
4386 >>> (x < y).sexpr()
4387 '(bvslt x y)'
4388 >>> ULT(x, y).sexpr()
4389 '(bvult x y)'
4390 """
4391 _check_bv_args(a, b)
4392 a, b = _coerce_exprs(a, b)
4393 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4394
4395
Z3_mk_bvult
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 12045 of file z3py.py.

12045def Union(*args):
12046 """Create union of regular expressions.
12047 >>> re = Union(Re("a"), Re("b"), Re("c"))
12048 >>> print (simplify(InRe("d", re)))
12049 False
12050 """
12051 args = _get_args(args)
12052 sz = len(args)
12053 if z3_debug():
12054 _z3_assert(sz > 0, "At least one argument expected.")
12055 arg0 = args[0]
12056 if is_finite_set(arg0):
12057 for a in args[1:]:
12058 if not is_finite_set(a):
12059 raise Z3Exception("All arguments must be regular expressions or finite sets.")
12060 arg0 = arg0 | a
12061 return arg0
12062 if z3_debug():
12063 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
12064 if sz == 1:
12065 return args[0]
12066 ctx = args[0].ctx
12067 v = (Ast * sz)()
12068 for i in range(sz):
12069 v[i] = args[i].as_ast()
12070 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
12071
12072
Z3_mk_re_union
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 11823 of file z3py.py.

11823def Unit(a):
11824 """Create a singleton sequence"""
11825 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11826
11827
Z3_mk_seq_unit
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 4982 of file z3py.py.

4982def Update(a, *args):
4983 """Return a Z3 store array expression.
4984
4985 >>> a = Array('a', IntSort(), IntSort())
4986 >>> i, v = Ints('i v')
4987 >>> s = Update(a, i, v)
4988 >>> s.sort()
4989 Array(Int, Int)
4990 >>> prove(s[i] == v)
4991 proved
4992 >>> j = Int('j')
4993 >>> prove(Implies(i != j, s[j] == a[j]))
4994 proved
4995 """
4996 if z3_debug():
4997 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4998 args = _get_args(args)
4999 ctx = a.ctx
5000 if len(args) <= 1:
5001 raise Z3Exception("array update requires index and value arguments")
5002 if len(args) == 2:
5003 i = args[0]
5004 v = args[1]
5005 i = a.sort().domain().cast(i)
5006 v = a.sort().range().cast(v)
5007 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
5008 v = a.sort().range().cast(args[-1])
5009 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
5010 _args, sz = _to_ast_array(idxs)
5011 return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
5012
5013
Z3_mk_store
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
Z3_mk_store_n
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs, Z3_ast v)
n-ary Array update.

Referenced by Store().

◆ URem()

URem (   a,
  b 
) 
Create the Z3 expression (unsigned) remainder `self % other`.

Use the operator % for signed modulus, and SRem() for signed remainder.

>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> URem(x, y)
URem(x, y)
>>> URem(x, y).sort()
BitVec(32)
>>> (x % y).sexpr()
'(bvsmod x y)'
>>> URem(x, y).sexpr()
'(bvurem x y)'

Definition at line 4453 of file z3py.py.

4453def URem(a, b):
4454 """Create the Z3 expression (unsigned) remainder `self % other`.
4455
4456 Use the operator % for signed modulus, and SRem() for signed remainder.
4457
4458 >>> x = BitVec('x', 32)
4459 >>> y = BitVec('y', 32)
4460 >>> URem(x, y)
4461 URem(x, y)
4462 >>> URem(x, y).sort()
4463 BitVec(32)
4464 >>> (x % y).sexpr()
4465 '(bvsmod x y)'
4466 >>> URem(x, y).sexpr()
4467 '(bvurem x y)'
4468 """
4469 _check_bv_args(a, b)
4470 a, b = _coerce_exprs(a, b)
4471 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4472
4473
Z3_mk_bvurem
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.

◆ user_prop_binding()

user_prop_binding (   ctx,
  cb,
  q_ref,
  inst_ref 
)

Definition at line 12381 of file z3py.py.

12381def user_prop_binding(ctx, cb, q_ref, inst_ref):
12382 prop = _prop_closures.get(ctx)
12383 old_cb = prop.cb
12384 prop.cb = cb
12385 q = _to_expr_ref(to_Ast(q_ref), prop.ctx())
12386 inst = _to_expr_ref(to_Ast(inst_ref), prop.ctx())
12387 r = prop.binding(q, inst)
12388 prop.cb = old_cb
12389 return r
12390
12391

◆ user_prop_created()

user_prop_created (   ctx,
  cb,
  id 
)

Definition at line 12339 of file z3py.py.

12339def user_prop_created(ctx, cb, id):
12340 prop = _prop_closures.get(ctx)
12341 old_cb = prop.cb
12342 prop.cb = cb
12343 id = _to_expr_ref(to_Ast(id), prop.ctx())
12344 prop.created(id)
12345 prop.cb = old_cb
12346
12347

◆ user_prop_decide()

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

Definition at line 12373 of file z3py.py.

12373def user_prop_decide(ctx, cb, t_ref, idx, phase):
12374 prop = _prop_closures.get(ctx)
12375 old_cb = prop.cb
12376 prop.cb = cb
12377 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
12378 prop.decide(t, idx, phase)
12379 prop.cb = old_cb
12380

◆ user_prop_diseq()

user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 12364 of file z3py.py.

12364def user_prop_diseq(ctx, cb, x, y):
12365 prop = _prop_closures.get(ctx)
12366 old_cb = prop.cb
12367 prop.cb = cb
12368 x = _to_expr_ref(to_Ast(x), prop.ctx())
12369 y = _to_expr_ref(to_Ast(y), prop.ctx())
12370 prop.diseq(x, y)
12371 prop.cb = old_cb
12372

◆ user_prop_eq()

user_prop_eq (   ctx,
  cb,
  x,
  y 
)

Definition at line 12355 of file z3py.py.

12355def user_prop_eq(ctx, cb, x, y):
12356 prop = _prop_closures.get(ctx)
12357 old_cb = prop.cb
12358 prop.cb = cb
12359 x = _to_expr_ref(to_Ast(x), prop.ctx())
12360 y = _to_expr_ref(to_Ast(y), prop.ctx())
12361 prop.eq(x, y)
12362 prop.cb = old_cb
12363

◆ user_prop_final()

user_prop_final (   ctx,
  cb 
)

Definition at line 12348 of file z3py.py.

12348def user_prop_final(ctx, cb):
12349 prop = _prop_closures.get(ctx)
12350 old_cb = prop.cb
12351 prop.cb = cb
12352 prop.final()
12353 prop.cb = old_cb
12354

◆ user_prop_fixed()

user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 12330 of file z3py.py.

12330def user_prop_fixed(ctx, cb, id, value):
12331 prop = _prop_closures.get(ctx)
12332 old_cb = prop.cb
12333 prop.cb = cb
12334 id = _to_expr_ref(to_Ast(id), prop.ctx())
12335 value = _to_expr_ref(to_Ast(value), prop.ctx())
12336 prop.fixed(id, value)
12337 prop.cb = old_cb
12338

◆ user_prop_fresh()

user_prop_fresh (   ctx,
  _new_ctx 
)

Definition at line 12316 of file z3py.py.

12316def user_prop_fresh(ctx, _new_ctx):
12317 _prop_closures.set_threaded()
12318 prop = _prop_closures.get(ctx)
12319 nctx = Context()
12320 Z3_del_context(nctx.ctx)
12321 new_ctx = to_ContextObj(_new_ctx)
12322 nctx.ctx = new_ctx
12323 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
12324 nctx.owner = False
12325 new_prop = prop.fresh(nctx)
12326 _prop_closures.set(new_prop.id, new_prop)
12327 return new_prop.id
12328
12329
Z3_del_context
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
Z3_set_error_handler
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 12310 of file z3py.py.

12310def user_prop_pop(ctx, cb, num_scopes):
12311 prop = _prop_closures.get(ctx)
12312 prop.cb = cb
12313 prop.pop(num_scopes)
12314
12315

◆ user_prop_push()

user_prop_push (   ctx,
  cb 
)

Definition at line 12304 of file z3py.py.

12304def user_prop_push(ctx, cb):
12305 prop = _prop_closures.get(ctx)
12306 prop.cb = cb
12307 prop.push()
12308
12309

◆ Var()

ExprRef Var ( int  idx,
SortRef  s 
) 
Create a Z3 free variable. Free variables are used to create quantified formulas.
A free variable with index n is bound when it occurs within the scope of n+1 quantified
declarations.

>>> Var(0, IntSort())
Var(0)
>>> eq(Var(0, IntSort()), Var(0, BoolSort()))
False

Definition at line 1581 of file z3py.py.

1581def Var(idx : int, s : SortRef) -> ExprRef:
1582 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1583 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1584 declarations.
1585
1586 >>> Var(0, IntSort())
1587 Var(0)
1588 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1589 False
1590 """
1591 if z3_debug():
1592 _z3_assert(is_sort(s), "Z3 sort expected")
1593 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1594
1595
Z3_mk_bound
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 9536 of file z3py.py.

9536def When(p, t, ctx=None):
9537 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
9538 Otherwise, it returns the input goal unmodified.
9539
9540 >>> t = When(Probe('size') > 2, Tactic('simplify'))
9541 >>> x, y = Ints('x y')
9542 >>> g = Goal()
9543 >>> g.add(x > 0)
9544 >>> g.add(y > 0)
9545 >>> t(g)
9546 [[x > 0, y > 0]]
9547 >>> g.add(x == y + 1)
9548 >>> t(g)
9549 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
9550 """
9551 p = _to_probe(p, ctx)
9552 t = _to_tactic(t, ctx)
9553 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
9554
9555
Z3_tactic_when
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 9193 of file z3py.py.

9193def With(t, *args, **keys):
9194 """Return a tactic that applies tactic `t` using the given configuration options.
9195
9196 >>> x, y = Ints('x y')
9197 >>> t = With(Tactic('simplify'), som=True)
9198 >>> t((x + 1)*(y + 2) == 0)
9199 [[2*x + y + x*y == -2]]
9200 """
9201 ctx = keys.pop("ctx", None)
9202 t = _to_tactic(t, ctx)
9203 p = args2params(args, keys, t.ctx)
9204 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
9205
9206
Z3_tactic_using_params
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 9207 of file z3py.py.

9207def WithParams(t, p):
9208 """Return a tactic that applies tactic `t` using the given configuration options.
9209
9210 >>> x, y = Ints('x y')
9211 >>> p = ParamsRef()
9212 >>> p.set("som", True)
9213 >>> t = WithParams(Tactic('simplify'), p)
9214 >>> t((x + 1)*(y + 2) == 0)
9215 [[2*x + y + x*y == -2]]
9216 """
9217 t = _to_tactic(t, None)
9218 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
9219
9220

◆ Xor()

Xor (   a,
  b,
  ctx = None 
) 
Create a Z3 Xor expression.

>>> p, q = Bools('p q')
>>> Xor(p, q)
Xor(p, q)
>>> simplify(Xor(p, q))
Not(p == q)

Definition at line 1938 of file z3py.py.

1938def Xor(a, b, ctx=None):
1939 """Create a Z3 Xor expression.
1940
1941 >>> p, q = Bools('p q')
1942 >>> Xor(p, q)
1943 Xor(p, q)
1944 >>> simplify(Xor(p, q))
1945 Not(p == q)
1946 """
1947 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1948 s = BoolSort(ctx)
1949 a = s.cast(a)
1950 b = s.cast(b)
1951 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1952
1953
Z3_mk_xor
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.

Referenced by BoolRef.__xor__().

◆ z3_debug()

z3_debug ( )

Definition at line 70 of file z3py.py.

70def z3_debug():
71 global Z3_DEBUG
72 return Z3_DEBUG
73
74

Referenced by QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _check_bv_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _mk_bin(), _mk_quantifier(), _py2expr(), _to_sort_ref(), DatatypeSortRef.accessor(), And(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), AsArray(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), CreatePolymorphicDatatype(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FreshConst(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), IsInt(), K(), ExprRef.kind(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), QuantifierRef.pattern(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Update(), ExprRef.update(), DatatypeRef.update_field(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().

◆ z3_error_handler()

z3_error_handler (   c,
  e 
)

Definition at line 184 of file z3py.py.

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

◆ ZeroExt()

ZeroExt (   n,
  a 
) 
Return a bit-vector expression with `n` extra zero-bits.

>>> x = BitVec('x', 16)
>>> n = ZeroExt(8, x)
>>> n.size()
24
>>> n
ZeroExt(8, x)
>>> n.sort()
BitVec(24)
>>> v0 = BitVecVal(2, 2)
>>> v0
2
>>> v0.size()
2
>>> v  = simplify(ZeroExt(6, v0))
>>> v
2
>>> v.size()
8

Definition at line 4589 of file z3py.py.

4589def ZeroExt(n, a):
4590 """Return a bit-vector expression with `n` extra zero-bits.
4591
4592 >>> x = BitVec('x', 16)
4593 >>> n = ZeroExt(8, x)
4594 >>> n.size()
4595 24
4596 >>> n
4597 ZeroExt(8, x)
4598 >>> n.sort()
4599 BitVec(24)
4600 >>> v0 = BitVecVal(2, 2)
4601 >>> v0
4602 2
4603 >>> v0.size()
4604 2
4605 >>> v = simplify(ZeroExt(6, v0))
4606 >>> v
4607 2
4608 >>> v.size()
4609 8
4610 """
4611 if z3_debug():
4612 _z3_assert(_is_int(n), "First argument must be an integer")
4613 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4614 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4615
4616
Z3_mk_zero_ext
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 10088 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

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

◆ _main_ctx

_main_ctx = None
protected

Definition at line 263 of file z3py.py.

◆ _my_hacky_class

_my_hacky_class = None
protected

Definition at line 12238 of file z3py.py.

◆ _on_clause_eh

_on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 12246 of file z3py.py.

◆ _on_model_eh

_on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 8574 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 8566 of file z3py.py.

◆ _prop_closures

_prop_closures = None
protected

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

◆ _user_prop_binding

_user_prop_binding = Z3_on_binding_eh(user_prop_binding)
protected

Definition at line 12401 of file z3py.py.

◆ _user_prop_created

_user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 12396 of file z3py.py.

◆ _user_prop_decide

_user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 12400 of file z3py.py.

◆ _user_prop_diseq

_user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 12399 of file z3py.py.

◆ _user_prop_eq

_user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 12398 of file z3py.py.

◆ _user_prop_final

_user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 12397 of file z3py.py.

◆ _user_prop_fixed

_user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 12395 of file z3py.py.

◆ _user_prop_fresh

_user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 12394 of file z3py.py.

◆ _user_prop_pop

_user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 12393 of file z3py.py.

◆ _user_prop_push

_user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 12392 of file z3py.py.

◆ sat

sat = CheckSatResult(Z3_L_TRUE)

Definition at line 7537 of file z3py.py.

◆ unknown

unknown = CheckSatResult(Z3_L_UNDEF)

Definition at line 7539 of file z3py.py.

◆ unsat

unsat = CheckSatResult(Z3_L_FALSE)

Definition at line 7538 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 67 of file z3py.py.

Generated on Fri Jul 17 2026 02:38:48 for Z3 by doxygen 1.9.8