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  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  UserPropagateBase
 
class  Z3PPObject
 ASTs base class. More...
 

Functions

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

Variables

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

Function Documentation

◆ _and_then()

def _and_then (   t1,
  t2,
  ctx = None 
)
protected

Definition at line 8329 of file z3py.py.

8329def _and_then(t1, t2, ctx=None):
8330 t1 = _to_tactic(t1, ctx)
8331 t2 = _to_tactic(t2, ctx)
8332 if z3_debug():
8333 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8334 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8335
8336
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.

Referenced by AndThen().

◆ _array_select()

def _array_select (   ar,
  arg 
)
protected

Definition at line 4590 of file z3py.py.

4590def _array_select(ar, arg):
4591 if isinstance(arg, tuple):
4592 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4593 _args, sz = _to_ast_array(args)
4594 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4595 arg = ar.sort().domain().cast(arg)
4596 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4597
4598
Z3_ast Z3_API Z3_mk_select(Z3_context c, Z3_ast a, Z3_ast i)
Array read. The argument a is the array and i is the index of the array that gets read.
Z3_ast Z3_API Z3_mk_select_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs)
n-ary Array read. The argument a is the array and idxs are the indices of the array that gets read.

Referenced by QuantifierRef.__getitem__(), and ArrayRef.__getitem__().

◆ _ast_kind()

def _ast_kind (   ctx,
  a 
)
protected

Definition at line 491 of file z3py.py.

491def _ast_kind(ctx, a):
492 if is_ast(a):
493 a = a.as_ast()
494 return Z3_get_ast_kind(ctx.ref(), a)
495
496
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.

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

◆ _check_bv_args()

def _check_bv_args (   a,
  b 
)
protected

Definition at line 4151 of file z3py.py.

4151def _check_bv_args(a, b):
4152 if z3_debug():
4153 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4154
4155

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

◆ _check_fp_args()

def _check_fp_args (   a,
  b 
)
protected

Definition at line 10431 of file z3py.py.

10431def _check_fp_args(a, b):
10432 if z3_debug():
10433 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10434
10435

◆ _coerce_char()

def _coerce_char (   ch,
  ctx = None 
)
protected

Definition at line 10871 of file z3py.py.

10871def _coerce_char(ch, ctx=None):
10872 if isinstance(ch, str):
10873 ctx = _get_ctx(ctx)
10874 ch = CharVal(ch, ctx)
10875 if not is_expr(ch):
10876 raise Z3Exception("Character expression expected")
10877 return ch
10878

Referenced by CharRef.__le__(), CharIsDigit(), CharToBv(), and CharToInt().

◆ _coerce_expr_list()

def _coerce_expr_list (   alist,
  ctx = None 
)
protected

Definition at line 1226 of file z3py.py.

1226def _coerce_expr_list(alist, ctx=None):
1227 has_expr = False
1228 for a in alist:
1229 if is_expr(a):
1230 has_expr = True
1231 break
1232 if not has_expr:
1233 alist = [_py2expr(a, ctx) for a in alist]
1234 s = _reduce(_coerce_expr_merge, alist, None)
1235 return [s.cast(a) for a in alist]
1236
1237

Referenced by _coerce_fp_expr_list(), _pb_args_coeffs(), And(), AtLeast(), AtMost(), Distinct(), Or(), Product(), and Sum().

◆ _coerce_expr_merge()

def _coerce_expr_merge (   s,
  a 
)
protected

Definition at line 1179 of file z3py.py.

1179def _coerce_expr_merge(s, a):
1180 if is_expr(a):
1181 s1 = a.sort()
1182 if s is None:
1183 return s1
1184 if s1.eq(s):
1185 return s
1186 elif s.subsort(s1):
1187 return s1
1188 elif s1.subsort(s):
1189 return s
1190 else:
1191 if z3_debug():
1192 _z3_assert(s1.ctx == s.ctx, "context mismatch")
1193 _z3_assert(False, "sort mismatch")
1194 else:
1195 return s
1196
1197

Referenced by _coerce_exprs().

◆ _coerce_exprs()

def _coerce_exprs (   a,
  b,
  ctx = None 
)
protected

Definition at line 1198 of file z3py.py.

1198def _coerce_exprs(a, b, ctx=None):
1199 if not is_expr(a) and not is_expr(b):
1200 a = _py2expr(a, ctx)
1201 b = _py2expr(b, ctx)
1202 if isinstance(a, str) and isinstance(b, SeqRef):
1203 a = StringVal(a, b.ctx)
1204 if isinstance(b, str) and isinstance(a, SeqRef):
1205 b = StringVal(b, a.ctx)
1206 if isinstance(a, float) and isinstance(b, ArithRef):
1207 a = RealVal(a, b.ctx)
1208 if isinstance(b, float) and isinstance(a, ArithRef):
1209 b = RealVal(b, a.ctx)
1210
1211 s = None
1212 s = _coerce_expr_merge(s, a)
1213 s = _coerce_expr_merge(s, b)
1214 a = s.cast(a)
1215 b = s.cast(b)
1216 return (a, b)
1217
1218

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

◆ _coerce_fp_expr_list()

def _coerce_fp_expr_list (   alist,
  ctx 
)
protected

Definition at line 9390 of file z3py.py.

9390def _coerce_fp_expr_list(alist, ctx):
9391 first_fp_sort = None
9392 for a in alist:
9393 if is_fp(a):
9394 if first_fp_sort is None:
9395 first_fp_sort = a.sort()
9396 elif first_fp_sort == a.sort():
9397 pass # OK, same as before
9398 else:
9399 # we saw at least 2 different float sorts; something will
9400 # throw a sort mismatch later, for now assume None.
9401 first_fp_sort = None
9402 break
9403
9404 r = []
9405 for i in range(len(alist)):
9406 a = alist[i]
9407 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9408 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9409 r.append(FPVal(a, None, first_fp_sort, ctx))
9410 else:
9411 r.append(a)
9412 return _coerce_expr_list(r, ctx)
9413
9414
9415# FP Sorts
9416

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), FPRef.__sub__(), _mk_fp_bin(), _mk_fp_bin_norm(), _mk_fp_bin_pred(), _mk_fp_tern(), _mk_fp_unary(), _mk_fp_unary_pred(), fpAbs(), and fpNeg().

◆ _coerce_seq()

def _coerce_seq (   s,
  ctx = None 
)
protected

Definition at line 10921 of file z3py.py.

10921def _coerce_seq(s, ctx=None):
10922 if isinstance(s, str):
10923 ctx = _get_ctx(ctx)
10924 s = StringVal(s, ctx)
10925 if not is_expr(s):
10926 raise Z3Exception("Non-expression passed as a sequence")
10927 if not is_seq(s):
10928 raise Z3Exception("Non-sequence passed as a sequence")
10929 return s
10930
10931

Referenced by Concat(), Contains(), IndexOf(), InRe(), LastIndexOf(), Length(), PrefixOf(), Range(), Re(), Replace(), StrToInt(), and SuffixOf().

◆ _ctx_from_ast_arg_list()

def _ctx_from_ast_arg_list (   args,
  default_ctx = None 
)
protected

Definition at line 497 of file z3py.py.

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

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

◆ _ctx_from_ast_args()

def _ctx_from_ast_args ( args)
protected

Definition at line 511 of file z3py.py.

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

◆ _dflt_fps()

def _dflt_fps (   ctx = None)
protected

Definition at line 9386 of file z3py.py.

9386def _dflt_fps(ctx=None):
9387 return get_default_fp_sort(ctx)
9388
9389

Referenced by FPVal().

◆ _dflt_rm()

def _dflt_rm (   ctx = None)
protected

Definition at line 9382 of file z3py.py.

9382def _dflt_rm(ctx=None):
9383 return get_default_rounding_mode(ctx)
9384
9385

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), and FPRef.__sub__().

◆ _dict2darray()

def _dict2darray (   decls,
  ctx 
)
protected

Definition at line 9255 of file z3py.py.

9255def _dict2darray(decls, ctx):
9256 sz = len(decls)
9257 _names = (Symbol * sz)()
9258 _decls = (FuncDecl * sz)()
9259 i = 0
9260 for k in decls:
9261 v = decls[k]
9262 if z3_debug():
9263 _z3_assert(isinstance(k, str), "String expected")
9264 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9265 _names[i] = to_symbol(k, ctx)
9266 if is_const(v):
9267 _decls[i] = v.decl().ast
9268 else:
9269 _decls[i] = v.ast
9270 i = i + 1
9271 return sz, _names, _decls
9272

Referenced by parse_smt2_file(), and parse_smt2_string().

◆ _dict2sarray()

def _dict2sarray (   sorts,
  ctx 
)
protected

Definition at line 9239 of file z3py.py.

9239def _dict2sarray(sorts, ctx):
9240 sz = len(sorts)
9241 _names = (Symbol * sz)()
9242 _sorts = (Sort * sz)()
9243 i = 0
9244 for k in sorts:
9245 v = sorts[k]
9246 if z3_debug():
9247 _z3_assert(isinstance(k, str), "String expected")
9248 _z3_assert(is_sort(v), "Z3 sort expected")
9249 _names[i] = to_symbol(k, ctx)
9250 _sorts[i] = v.ast
9251 i = i + 1
9252 return sz, _names, _sorts
9253
9254

Referenced by parse_smt2_file(), and parse_smt2_string().

◆ _get_args()

def _get_args (   args)
protected

Definition at line 144 of file z3py.py.

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

Referenced by FuncDeclRef.__call__(), Fixedpoint.add_rule(), And(), ArraySort(), Goal.assert_exprs(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), AtLeast(), AtMost(), Solver.check(), Optimize.check(), Concat(), CreateDatatypes(), Fixedpoint.declare_var(), Distinct(), FreshFunction(), Function(), Intersect(), Map(), Or(), Product(), PropagateFunction(), Fixedpoint.query(), Fixedpoint.query_from_lvl(), RecAddDefinition(), RecFunction(), Fixedpoint.register_relation(), Select(), Fixedpoint.set_predicate_representation(), SetIntersect(), SetUnion(), substitute(), substitute_funs(), Sum(), Union(), Update(), and Fixedpoint.update_rule().

◆ _get_args_ast_list()

def _get_args_ast_list (   args)
protected

Definition at line 158 of file z3py.py.

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

Referenced by _pb_args_coeffs().

◆ _get_ctx()

def _get_ctx (   ctx)
protected

◆ _get_ctx2()

def _get_ctx2 (   a,
  b,
  ctx = None 
)
protected

Definition at line 10932 of file z3py.py.

10932def _get_ctx2(a, b, ctx=None):
10933 if is_expr(a):
10934 return a.ctx
10935 if is_expr(b):
10936 return b.ctx
10937 if ctx is None:
10938 ctx = main_ctx()
10939 return ctx
10940
10941

Referenced by Contains(), IndexOf(), LastIndexOf(), PrefixOf(), Replace(), and SuffixOf().

◆ _global_on_model()

def _global_on_model (   ctx)
protected

Definition at line 7850 of file z3py.py.

7850def _global_on_model(ctx):
7851 (fn, mdl) = _on_models[ctx]
7852 fn(mdl)
7853
7854

◆ _has_probe()

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

Definition at line 1837 of file z3py.py.

1837def _has_probe(args):
1838 """Return `True` if one of the elements of the given collection is a Z3 probe."""
1839 for arg in args:
1840 if is_probe(arg):
1841 return True
1842 return False
1843
1844

Referenced by And(), and Or().

◆ _is_algebraic()

def _is_algebraic (   ctx,
  a 
)
protected

Definition at line 2724 of file z3py.py.

2724def _is_algebraic(ctx, a):
2725 return Z3_is_algebraic_number(ctx.ref(), a)
2726
2727
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()

def _is_int (   v)
protected

◆ _is_numeral()

def _is_numeral (   ctx,
  a 
)
protected

Definition at line 2720 of file z3py.py.

2720def _is_numeral(ctx, a):
2721 return Z3_is_numeral_ast(ctx.ref(), a)
2722
2723
bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a)

Referenced by _to_expr_ref(), is_bv_value(), is_finite_domain_value(), is_fp_value(), is_fprm_value(), is_int_value(), and is_rational_value().

◆ _mk_bin()

def _mk_bin (   f,
  a,
  b 
)
protected

Definition at line 1424 of file z3py.py.

1424def _mk_bin(f, a, b):
1425 args = (Ast * 2)()
1426 if z3_debug():
1427 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1428 args[0] = a.as_ast()
1429 args[1] = b.as_ast()
1430 return f(a.ctx.ref(), 2, args)
1431
1432

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

◆ _mk_fp_bin()

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

Definition at line 10219 of file z3py.py.

10219def _mk_fp_bin(f, rm, a, b, ctx):
10220 ctx = _get_ctx(ctx)
10221 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10222 if z3_debug():
10223 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10224 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10225 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10226
10227

Referenced by fpAdd(), fpDiv(), fpMul(), and fpSub().

◆ _mk_fp_bin_norm()

def _mk_fp_bin_norm (   f,
  a,
  b,
  ctx 
)
protected

Definition at line 10228 of file z3py.py.

10228def _mk_fp_bin_norm(f, a, b, ctx):
10229 ctx = _get_ctx(ctx)
10230 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10231 if z3_debug():
10232 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10233 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10234
10235

Referenced by fpMax(), fpMin(), and fpRem().

◆ _mk_fp_bin_pred()

def _mk_fp_bin_pred (   f,
  a,
  b,
  ctx 
)
protected

Definition at line 10236 of file z3py.py.

10236def _mk_fp_bin_pred(f, a, b, ctx):
10237 ctx = _get_ctx(ctx)
10238 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10239 if z3_debug():
10240 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10241 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10242
10243

Referenced by fpEQ(), fpGEQ(), fpGT(), fpLEQ(), and fpLT().

◆ _mk_fp_tern()

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

Definition at line 10244 of file z3py.py.

10244def _mk_fp_tern(f, rm, a, b, c, ctx):
10245 ctx = _get_ctx(ctx)
10246 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10247 if z3_debug():
10248 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10249 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10250 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10251 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10252
10253

Referenced by fpFMA().

◆ _mk_fp_unary()

def _mk_fp_unary (   f,
  rm,
  a,
  ctx 
)
protected

Definition at line 10202 of file z3py.py.

10202def _mk_fp_unary(f, rm, a, ctx):
10203 ctx = _get_ctx(ctx)
10204 [a] = _coerce_fp_expr_list([a], ctx)
10205 if z3_debug():
10206 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10207 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10208 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10209
10210

Referenced by fpRoundToIntegral(), and fpSqrt().

◆ _mk_fp_unary_pred()

def _mk_fp_unary_pred (   f,
  a,
  ctx 
)
protected

Definition at line 10211 of file z3py.py.

10211def _mk_fp_unary_pred(f, a, ctx):
10212 ctx = _get_ctx(ctx)
10213 [a] = _coerce_fp_expr_list([a], ctx)
10214 if z3_debug():
10215 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10216 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10217
10218

Referenced by fpIsInf(), fpIsNaN(), fpIsNegative(), fpIsNormal(), fpIsPositive(), fpIsSubnormal(), and fpIsZero().

◆ _mk_quantifier()

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

Definition at line 2183 of file z3py.py.

2183def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2184 if z3_debug():
2185 _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2186 _z3_assert(is_const(vs) or (len(vs) > 0 and all([is_const(v) for v in vs])), "Invalid bounded variable(s)")
2187 _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2188 _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2189 if is_app(vs):
2190 ctx = vs.ctx
2191 vs = [vs]
2192 else:
2193 ctx = vs[0].ctx
2194 if not is_expr(body):
2195 body = BoolVal(body, ctx)
2196 num_vars = len(vs)
2197 if num_vars == 0:
2198 return body
2199 _vs = (Ast * num_vars)()
2200 for i in range(num_vars):
2201 # TODO: Check if is constant
2202 _vs[i] = vs[i].as_ast()
2203 patterns = [_to_pattern(p) for p in patterns]
2204 num_pats = len(patterns)
2205 _pats = (Pattern * num_pats)()
2206 for i in range(num_pats):
2207 _pats[i] = patterns[i].ast
2208 _no_pats, num_no_pats = _to_ast_array(no_patterns)
2209 qid = to_symbol(qid, ctx)
2210 skid = to_symbol(skid, ctx)
2211 return QuantifierRef(Z3_mk_quantifier_const_ex(ctx.ref(), is_forall, weight, qid, skid,
2212 num_vars, _vs,
2213 num_pats, _pats,
2214 num_no_pats, _no_pats,
2215 body.as_ast()), ctx)
2216
2217
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()

def _or_else (   t1,
  t2,
  ctx = None 
)
protected

Definition at line 8337 of file z3py.py.

8337def _or_else(t1, t2, ctx=None):
8338 t1 = _to_tactic(t1, ctx)
8339 t2 = _to_tactic(t2, ctx)
8340 if z3_debug():
8341 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8342 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8343
8344
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...

Referenced by OrElse().

◆ _pb_args_coeffs()

def _pb_args_coeffs (   args,
  default_ctx = None 
)
protected

Definition at line 9028 of file z3py.py.

9028def _pb_args_coeffs(args, default_ctx=None):
9029 args = _get_args_ast_list(args)
9030 if len(args) == 0:
9031 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
9032 args = [_reorder_pb_arg(arg) for arg in args]
9033 args, coeffs = zip(*args)
9034 if z3_debug():
9035 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
9036 ctx = _ctx_from_ast_arg_list(args)
9037 if z3_debug():
9038 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9039 args = _coerce_expr_list(args, ctx)
9040 _args, sz = _to_ast_array(args)
9041 _coeffs = (ctypes.c_int * len(coeffs))()
9042 for i in range(len(coeffs)):
9043 _z3_check_cint_overflow(coeffs[i], "coefficient")
9044 _coeffs[i] = coeffs[i]
9045 return ctx, sz, _args, _coeffs, args
9046
9047

Referenced by PbEq(), PbGe(), and PbLe().

◆ _probe_and()

def _probe_and (   args,
  ctx 
)
protected

Definition at line 8752 of file z3py.py.

8752def _probe_and(args, ctx):
8753 return _probe_nary(Z3_probe_and, args, ctx)
8754
8755

Referenced by And().

◆ _probe_nary()

def _probe_nary (   f,
  args,
  ctx 
)
protected

Definition at line 8742 of file z3py.py.

8742def _probe_nary(f, args, ctx):
8743 if z3_debug():
8744 _z3_assert(len(args) > 0, "At least one argument expected")
8745 num = len(args)
8746 r = _to_probe(args[0], ctx)
8747 for i in range(num - 1):
8748 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8749 return r
8750
8751

Referenced by _probe_and(), and _probe_or().

◆ _probe_or()

def _probe_or (   args,
  ctx 
)
protected

Definition at line 8756 of file z3py.py.

8756def _probe_or(args, ctx):
8757 return _probe_nary(Z3_probe_or, args, ctx)
8758
8759

Referenced by Or().

◆ _prove_html()

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

Definition at line 9219 of file z3py.py.

9219def _prove_html(claim, show=False, **keywords):
9220 """Version of function `prove` that renders HTML."""
9221 if z3_debug():
9222 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9223 s = Solver()
9224 s.set(**keywords)
9225 s.add(Not(claim))
9226 if show:
9227 print(s)
9228 r = s.check()
9229 if r == unsat:
9230 print("<b>proved</b>")
9231 elif r == unknown:
9232 print("<b>failed to prove</b>")
9233 print(s.model())
9234 else:
9235 print("<b>counterexample</b>")
9236 print(s.model())
9237
9238

◆ _py2expr()

def _py2expr (   a,
  ctx = None 
)
protected

Definition at line 3119 of file z3py.py.

3119def _py2expr(a, ctx=None):
3120 if isinstance(a, bool):
3121 return BoolVal(a, ctx)
3122 if _is_int(a):
3123 return IntVal(a, ctx)
3124 if isinstance(a, float):
3125 return RealVal(a, ctx)
3126 if isinstance(a, str):
3127 return StringVal(a, ctx)
3128 if is_expr(a):
3129 return a
3130 if z3_debug():
3131 _z3_assert(False, "Python bool, int, long or float expected")
3132
3133

Referenced by _coerce_expr_list(), _coerce_exprs(), IntToStr(), IsMember(), K(), Solver.next(), Solver.root(), SetAdd(), SetDel(), SetHasSize(), StrFromCode(), StrToCode(), and ModelRef.update_value().

◆ _reduce()

def _reduce (   func,
  sequence,
  initial 
)
protected

Definition at line 1219 of file z3py.py.

1219def _reduce(func, sequence, initial):
1220 result = initial
1221 for element in sequence:
1222 result = func(result, element)
1223 return result
1224
1225

Referenced by _coerce_expr_list(), Product(), and Sum().

◆ _reorder_pb_arg()

def _reorder_pb_arg (   arg)
protected

Definition at line 9021 of file z3py.py.

9021def _reorder_pb_arg(arg):
9022 a, b = arg
9023 if not _is_int(b) and _is_int(a):
9024 return b, a
9025 return arg
9026
9027

Referenced by _pb_args_coeffs().

◆ _solve_html()

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

Definition at line 9170 of file z3py.py.

9170def _solve_html(*args, **keywords):
9171 """Version of function `solve` that renders HTML output."""
9172 show = keywords.pop("show", False)
9173 s = Solver()
9174 s.set(**keywords)
9175 s.add(*args)
9176 if show:
9177 print("<b>Problem:</b>")
9178 print(s)
9179 r = s.check()
9180 if r == unsat:
9181 print("<b>no solution</b>")
9182 elif r == unknown:
9183 print("<b>failed to solve</b>")
9184 try:
9185 print(s.model())
9186 except Z3Exception:
9187 return
9188 else:
9189 if show:
9190 print("<b>Solution:</b>")
9191 print(s.model())
9192
9193

◆ _solve_using_html()

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

Definition at line 9194 of file z3py.py.

9194def _solve_using_html(s, *args, **keywords):
9195 """Version of function `solve_using` that renders HTML."""
9196 show = keywords.pop("show", False)
9197 if z3_debug():
9198 _z3_assert(isinstance(s, Solver), "Solver object expected")
9199 s.set(**keywords)
9200 s.add(*args)
9201 if show:
9202 print("<b>Problem:</b>")
9203 print(s)
9204 r = s.check()
9205 if r == unsat:
9206 print("<b>no solution</b>")
9207 elif r == unknown:
9208 print("<b>failed to solve</b>")
9209 try:
9210 print(s.model())
9211 except Z3Exception:
9212 return
9213 else:
9214 if show:
9215 print("<b>Solution:</b>")
9216 print(s.model())
9217
9218

◆ _sort()

def _sort (   ctx,
  a 
)
protected

Definition at line 689 of file z3py.py.

689def _sort(ctx, a):
690 return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
691
692
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.

Referenced by ExprRef.sort(), and QuantifierRef.sort().

◆ _sort_kind()

def _sort_kind (   ctx,
  s 
)
protected

Sorts.

Definition at line 555 of file z3py.py.

555def _sort_kind(ctx, s):
556 return Z3_get_sort_kind(ctx.ref(), s)
557
558
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).

Referenced by _to_sort_ref(), and SortRef.kind().

◆ _symbol2py()

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

Definition at line 132 of file z3py.py.

132def _symbol2py(ctx, s):
133 """Convert a Z3 symbol back into a Python object. """
134 if Z3_get_symbol_kind(ctx.ref(), s) == Z3_INT_SYMBOL:
135 return "k!%s" % Z3_get_symbol_int(ctx.ref(), s)
136 else:
137 return Z3_get_symbol_string(ctx.ref(), s)
138
139# Hack for having nary functions that can receive one argument that is the
140# list of arguments.
141# Use this when function takes a single list of arguments
142
143
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s)
Return Z3_INT_SYMBOL if the symbol was constructed using Z3_mk_int_symbol, and Z3_STRING_SYMBOL if th...
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.

Referenced by ParamDescrsRef.get_name(), Fixedpoint.get_rule_names_along_trace(), SortRef.name(), FuncDeclRef.name(), and QuantifierRef.var_name().

◆ _to_ast_array()

def _to_ast_array (   args)
protected

Definition at line 523 of file z3py.py.

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

Referenced by ExprRef.__ne__(), _array_select(), _mk_quantifier(), _pb_args_coeffs(), And(), AtLeast(), AtMost(), Distinct(), Map(), MultiPattern(), Or(), Product(), UserPropagateBase.propagate(), SetIntersect(), SetUnion(), Sum(), Fixedpoint.to_string(), and Update().

◆ _to_ast_ref()

def _to_ast_ref (   a,
  ctx 
)
protected

Definition at line 539 of file z3py.py.

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

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

◆ _to_expr_ref()

def _to_expr_ref (   a,
  ctx 
)
protected

Definition at line 1129 of file z3py.py.

1129def _to_expr_ref(a, ctx):
1130 if isinstance(a, Pattern):
1131 return PatternRef(a, ctx)
1132 ctx_ref = ctx.ref()
1133 k = Z3_get_ast_kind(ctx_ref, a)
1134 if k == Z3_QUANTIFIER_AST:
1135 return QuantifierRef(a, ctx)
1136 sk = Z3_get_sort_kind(ctx_ref, Z3_get_sort(ctx_ref, a))
1137 if sk == Z3_BOOL_SORT:
1138 return BoolRef(a, ctx)
1139 if sk == Z3_INT_SORT:
1140 if k == Z3_NUMERAL_AST:
1141 return IntNumRef(a, ctx)
1142 return ArithRef(a, ctx)
1143 if sk == Z3_REAL_SORT:
1144 if k == Z3_NUMERAL_AST:
1145 return RatNumRef(a, ctx)
1146 if _is_algebraic(ctx, a):
1147 return AlgebraicNumRef(a, ctx)
1148 return ArithRef(a, ctx)
1149 if sk == Z3_BV_SORT:
1150 if k == Z3_NUMERAL_AST:
1151 return BitVecNumRef(a, ctx)
1152 else:
1153 return BitVecRef(a, ctx)
1154 if sk == Z3_ARRAY_SORT:
1155 return ArrayRef(a, ctx)
1156 if sk == Z3_DATATYPE_SORT:
1157 return DatatypeRef(a, ctx)
1158 if sk == Z3_FLOATING_POINT_SORT:
1159 if k == Z3_APP_AST and _is_numeral(ctx, a):
1160 return FPNumRef(a, ctx)
1161 else:
1162 return FPRef(a, ctx)
1163 if sk == Z3_FINITE_DOMAIN_SORT:
1164 if k == Z3_NUMERAL_AST:
1165 return FiniteDomainNumRef(a, ctx)
1166 else:
1167 return FiniteDomainRef(a, ctx)
1168 if sk == Z3_ROUNDING_MODE_SORT:
1169 return FPRMRef(a, ctx)
1170 if sk == Z3_SEQ_SORT:
1171 return SeqRef(a, ctx)
1172 if sk == Z3_CHAR_SORT:
1173 return CharRef(a, ctx)
1174 if sk == Z3_RE_SORT:
1175 return ReRef(a, ctx)
1176 return ExprRef(a, ctx)
1177
1178

Referenced by FuncDeclRef.__call__(), SeqRef.__ge__(), SeqRef.__getitem__(), SeqRef.__gt__(), SeqRef.__le__(), CharRef.__le__(), SeqRef.__lt__(), _array_select(), _to_ast_ref(), ExprRef.arg(), FuncEntry.arg_value(), QuantifierRef.body(), CharFromBv(), CharVal(), Const(), ArrayRef.default(), FuncInterp.else_value(), ModelRef.eval(), Ext(), FreshConst(), Goal.get(), Fixedpoint.get_answer(), Fixedpoint.get_cover_delta(), Fixedpoint.get_ground_sat_answer(), ModelRef.get_interp(), If(), CharRef.is_digit(), OptimizeObjective.lower(), Solver.next(), QuantifierRef.no_pattern(), on_clause_eh(), Solver.proof(), Solver.root(), SetHasSize(), simplify(), substitute(), substitute_funs(), substitute_vars(), CharRef.to_bv(), CharRef.to_int(), Update(), OptimizeObjective.upper(), user_prop_created(), user_prop_decide(), user_prop_diseq(), user_prop_eq(), user_prop_fixed(), FuncEntry.value(), and Var().

◆ _to_float_str()

def _to_float_str (   val,
  exp = 0 
)
protected

Definition at line 9964 of file z3py.py.

9964def _to_float_str(val, exp=0):
9965 if isinstance(val, float):
9966 if math.isnan(val):
9967 res = "NaN"
9968 elif val == 0.0:
9969 sone = math.copysign(1.0, val)
9970 if sone < 0.0:
9971 return "-0.0"
9972 else:
9973 return "+0.0"
9974 elif val == float("+inf"):
9975 res = "+oo"
9976 elif val == float("-inf"):
9977 res = "-oo"
9978 else:
9979 v = val.as_integer_ratio()
9980 num = v[0]
9981 den = v[1]
9982 rvs = str(num) + "/" + str(den)
9983 res = rvs + "p" + _to_int_str(exp)
9984 elif isinstance(val, bool):
9985 if val:
9986 res = "1.0"
9987 else:
9988 res = "0.0"
9989 elif _is_int(val):
9990 res = str(val)
9991 elif isinstance(val, str):
9992 inx = val.find("*(2**")
9993 if inx == -1:
9994 res = val
9995 elif val[-1] == ")":
9996 res = val[0:inx]
9997 exp = str(int(val[inx + 5:-1]) + int(exp))
9998 else:
9999 _z3_assert(False, "String does not have floating-point numeral form.")
10000 elif z3_debug():
10001 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
10002 if exp == 0:
10003 return res
10004 else:
10005 return res + "p" + exp
10006
10007

Referenced by FPVal().

◆ _to_func_decl_array()

def _to_func_decl_array (   args)
protected

Definition at line 515 of file z3py.py.

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

◆ _to_func_decl_ref()

def _to_func_decl_ref (   a,
  ctx 
)
protected

Definition at line 901 of file z3py.py.

901def _to_func_decl_ref(a, ctx):
902 return FuncDeclRef(a, ctx)
903
904

Referenced by _to_ast_ref().

◆ _to_goal()

def _to_goal (   a)
protected

Definition at line 8313 of file z3py.py.

8313def _to_goal(a):
8314 if isinstance(a, BoolRef):
8315 goal = Goal(ctx=a.ctx)
8316 goal.add(a)
8317 return goal
8318 else:
8319 return a
8320
8321

Referenced by Probe.__call__(), and Tactic.apply().

◆ _to_int_str()

def _to_int_str (   val)
protected

Definition at line 3168 of file z3py.py.

3168def _to_int_str(val):
3169 if isinstance(val, float):
3170 return str(int(val))
3171 elif isinstance(val, bool):
3172 if val:
3173 return "1"
3174 else:
3175 return "0"
3176 else:
3177 return str(val)
3178
3179

Referenced by _to_float_str(), BitVecVal(), FiniteDomainVal(), and IntVal().

◆ _to_param_value()

def _to_param_value (   val)
protected

Definition at line 168 of file z3py.py.

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

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

◆ _to_pattern()

def _to_pattern (   arg)
protected

Definition at line 1971 of file z3py.py.

1971def _to_pattern(arg):
1972 if is_pattern(arg):
1973 return arg
1974 else:
1975 return MultiPattern(arg)
1976

Referenced by _mk_quantifier().

◆ _to_probe()

def _to_probe (   p,
  ctx = None 
)
protected

Definition at line 8696 of file z3py.py.

8696def _to_probe(p, ctx=None):
8697 if is_probe(p):
8698 return p
8699 else:
8700 return Probe(p, ctx)
8701
8702

Referenced by Probe.__eq__(), Probe.__ge__(), Probe.__gt__(), Probe.__le__(), Probe.__lt__(), _probe_nary(), Cond(), FailIf(), and When().

◆ _to_ref_array()

def _to_ref_array (   ref,
  args 
)
protected

Definition at line 531 of file z3py.py.

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

◆ _to_sort_ref()

def _to_sort_ref (   s,
  ctx 
)
protected

Definition at line 660 of file z3py.py.

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

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

◆ _to_tactic()

def _to_tactic (   t,
  ctx = None 
)
protected

Definition at line 8322 of file z3py.py.

8322def _to_tactic(t, ctx=None):
8323 if isinstance(t, Tactic):
8324 return t
8325 else:
8326 return Tactic(t, ctx)
8327
8328

Referenced by _and_then(), _or_else(), Cond(), ParOr(), ParThen(), Repeat(), TryFor(), When(), With(), and WithParams().

◆ _valid_accessor()

def _valid_accessor (   acc)
protected

Datatypes.

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

Definition at line 5029 of file z3py.py.

5029def _valid_accessor(acc):
5030 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5031 if not isinstance(acc, tuple):
5032 return False
5033 if len(acc) != 2:
5034 return False
5035 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5036
5037

Referenced by Datatype.declare_core().

◆ _z3_assert()

def _z3_assert (   cond,
  msg 
)
protected

Definition at line 105 of file z3py.py.

105def _z3_assert(cond, msg):
106 if not cond:
107 raise Z3Exception(msg)
108
109

Referenced by Probe.__call__(), QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), ParamDescrsRef.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _and_then(), _check_bv_args(), _check_fp_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _dict2darray(), _dict2sarray(), _mk_bin(), _mk_fp_bin(), _mk_fp_bin_norm(), _mk_fp_bin_pred(), _mk_fp_tern(), _mk_fp_unary(), _mk_fp_unary_pred(), _mk_quantifier(), _or_else(), _pb_args_coeffs(), _probe_nary(), _prove_html(), _py2expr(), _solve_using_html(), _to_float_str(), _to_sort_ref(), _z3_check_cint_overflow(), DatatypeSortRef.accessor(), And(), AndThen(), Tactic.apply(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), RatNumRef.as_long(), Solver.assert_and_track(), Optimize.assert_and_track(), AtLeast(), AtMost(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), BoolSortRef.cast(), Concat(), Solver.consequences(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FiniteDomainVal(), fpBVToFP(), fpFP(), fpFPToFP(), fpInfinity(), fpMinusInfinity(), fpMinusZero(), fpNaN(), fpPlusInfinity(), fpPlusZero(), fpRealToFP(), fpSignedToFP(), fpToFPUnsigned(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), FPVal(), fpZero(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), Intersect(), IsInt(), K(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), OrElse(), ParOr(), ParThen(), QuantifierRef.pattern(), PropagateFunction(), prove(), Fixedpoint.query_from_lvl(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_default_rounding_mode(), set_param(), SignExt(), simplify(), solve_using(), substitute(), substitute_funs(), substitute_vars(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Solver.translate(), Union(), Update(), ParamsRef.validate(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().

◆ _z3_check_cint_overflow()

def _z3_check_cint_overflow (   n,
  name 
)
protected

Definition at line 110 of file z3py.py.

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

Referenced by _pb_args_coeffs(), PbEq(), PbGe(), and PbLe().

◆ Abs()

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

Definition at line 8980 of file z3py.py.

8980def Abs(arg):
8981 """Create the absolute value of an arithmetic expression"""
8982 return If(arg > 0, arg, -arg)
8983
8984

◆ AllChar()

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

Definition at line 11346 of file z3py.py.

11346def AllChar(regex_sort, ctx=None):
11347 """Create a regular expression that accepts all single character strings
11348 """
11349 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11350
11351# Special Relations
11352
11353
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()

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

1845def And(*args):
1846 """Create a Z3 and-expression or and-probe.
1847
1848 >>> p, q, r = Bools('p q r')
1849 >>> And(p, q, r)
1850 And(p, q, r)
1851 >>> P = BoolVector('p', 5)
1852 >>> And(P)
1853 And(p__0, p__1, p__2, p__3, p__4)
1854 """
1855 last_arg = None
1856 if len(args) > 0:
1857 last_arg = args[len(args) - 1]
1858 if isinstance(last_arg, Context):
1859 ctx = args[len(args) - 1]
1860 args = args[:len(args) - 1]
1861 elif len(args) == 1 and isinstance(args[0], AstVector):
1862 ctx = args[0].ctx
1863 args = [a for a in args[0]]
1864 else:
1865 ctx = None
1866 args = _get_args(args)
1867 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1868 if z3_debug():
1869 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1870 if _has_probe(args):
1871 return _probe_and(args, ctx)
1872 else:
1873 args = _coerce_expr_list(args, ctx)
1874 _args, sz = _to_ast_array(args)
1875 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1876
1877
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 Tactic.__call__(), Fixedpoint.add_rule(), And(), AndThen(), Tactic.apply(), Goal.as_expr(), ApplyResult.as_expr(), Bool(), Bools(), BoolVector(), Distinct(), is_and(), is_bool(), is_implies(), is_or(), Lambda(), ParThen(), prove(), Fixedpoint.query(), Fixedpoint.query_from_lvl(), Repeat(), simplify(), Then(), and Fixedpoint.update_rule().

◆ AndThen()

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

8345def AndThen(*ts, **ks):
8346 """Return a tactic that applies the tactics in `*ts` in sequence.
8347
8348 >>> x, y = Ints('x y')
8349 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8350 >>> t(And(x == 0, y > x + 1))
8351 [[Not(y <= 1)]]
8352 >>> t(And(x == 0, y > x + 1)).as_expr()
8353 Not(y <= 1)
8354 """
8355 if z3_debug():
8356 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8357 ctx = ks.get("ctx", None)
8358 num = len(ts)
8359 r = ts[0]
8360 for i in range(num - 1):
8361 r = _and_then(r, ts[i + 1], ctx)
8362 return r
8363
8364

Referenced by AndThen(), and Then().

◆ append_log()

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

Definition at line 119 of file z3py.py.

119def append_log(s):
120 """Append user-defined string to interaction log. """
122
123
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.

◆ args2params()

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

5458def args2params(arguments, keywords, ctx=None):
5459 """Convert python arguments into a Z3_params object.
5460 A ':' is added to the keywords, and '_' is replaced with '-'
5461
5462 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5463 (params model true relevancy 2 elim_and true)
5464 """
5465 if z3_debug():
5466 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5467 prev = None
5468 r = ParamsRef(ctx)
5469 for a in arguments:
5470 if prev is None:
5471 prev = a
5472 else:
5473 r.set(prev, a)
5474 prev = None
5475 for k in keywords:
5476 v = keywords[k]
5477 r.set(k, v)
5478 return r
5479
5480

Referenced by Tactic.apply(), args2params(), Solver.set(), Fixedpoint.set(), Optimize.set(), simplify(), Simplifier.using_params(), and With().

◆ Array()

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

4725def Array(name, *sorts):
4726 """Return an array constant named `name` with the given domain and range sorts.
4727
4728 >>> a = Array('a', IntSort(), IntSort())
4729 >>> a.sort()
4730 Array(Int, Int)
4731 >>> a[0]
4732 a[0]
4733 """
4734 s = ArraySort(sorts)
4735 ctx = s.ctx
4736 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4737
4738
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.

Referenced by ArrayRef.__getitem__(), Array(), ArraySort(), ArrayRef.domain(), get_map_func(), is_array(), is_const_array(), is_K(), is_map(), is_select(), is_store(), K(), Lambda(), Map(), ArrayRef.range(), Select(), ArrayRef.sort(), ExprRef.sort_kind(), Store(), and Update().

◆ ArraySort()

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

4692def ArraySort(*sig):
4693 """Return the Z3 array sort with the given domain and range sorts.
4694
4695 >>> A = ArraySort(IntSort(), BoolSort())
4696 >>> A
4697 Array(Int, Bool)
4698 >>> A.domain()
4699 Int
4700 >>> A.range()
4701 Bool
4702 >>> AA = ArraySort(IntSort(), A)
4703 >>> AA
4704 Array(Int, Array(Int, Bool))
4705 """
4706 sig = _get_args(sig)
4707 if z3_debug():
4708 _z3_assert(len(sig) > 1, "At least two arguments expected")
4709 arity = len(sig) - 1
4710 r = sig[arity]
4711 d = sig[0]
4712 if z3_debug():
4713 for s in sig:
4714 _z3_assert(is_sort(s), "Z3 sort expected")
4715 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4716 ctx = d.ctx
4717 if len(sig) == 2:
4718 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4719 dom = (Sort * arity)()
4720 for i in range(arity):
4721 dom[i] = sig[i].ast
4722 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4723
4724
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const *domain, Z3_sort range)
Create an array type with N arguments.
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.

Referenced by Array(), ArraySort(), ArraySortRef.domain(), SortRef.kind(), SortRef.name(), ArraySortRef.range(), and SetSort().

◆ AtLeast()

def AtLeast ( args)
Create an at-most Pseudo-Boolean k constraint.

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

Definition at line 9003 of file z3py.py.

9003def AtLeast(*args):
9004 """Create an at-most Pseudo-Boolean k constraint.
9005
9006 >>> a, b, c = Bools('a b c')
9007 >>> f = AtLeast(a, b, c, 2)
9008 """
9009 args = _get_args(args)
9010 if z3_debug():
9011 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9012 ctx = _ctx_from_ast_arg_list(args)
9013 if z3_debug():
9014 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9015 args1 = _coerce_expr_list(args[:-1], ctx)
9016 k = args[-1]
9017 _args, sz = _to_ast_array(args1)
9018 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9019
9020
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.

Referenced by AtLeast().

◆ AtMost()

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

8985def AtMost(*args):
8986 """Create an at-most Pseudo-Boolean k constraint.
8987
8988 >>> a, b, c = Bools('a b c')
8989 >>> f = AtMost(a, b, c, 2)
8990 """
8991 args = _get_args(args)
8992 if z3_debug():
8993 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8994 ctx = _ctx_from_ast_arg_list(args)
8995 if z3_debug():
8996 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8997 args1 = _coerce_expr_list(args[:-1], ctx)
8998 k = args[-1]
8999 _args, sz = _to_ast_array(args1)
9000 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9001
9002
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.

Referenced by AtMost().

◆ BitVec()

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

4029def BitVec(name, bv, ctx=None):
4030 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4031 If `ctx=None`, then the global context is used.
4032
4033 >>> x = BitVec('x', 16)
4034 >>> is_bv(x)
4035 True
4036 >>> x.size()
4037 16
4038 >>> x.sort()
4039 BitVec(16)
4040 >>> word = BitVecSort(16)
4041 >>> x2 = BitVec('x', word)
4042 >>> eq(x, x2)
4043 True
4044 """
4045 if isinstance(bv, BitVecSortRef):
4046 ctx = bv.ctx
4047 else:
4048 ctx = _get_ctx(ctx)
4049 bv = BitVecSort(bv, ctx)
4050 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4051
4052

Referenced by BitVecRef.__add__(), BitVecRef.__and__(), BitVecRef.__div__(), BitVecRef.__invert__(), BitVecRef.__mod__(), BitVecRef.__mul__(), BitVecRef.__neg__(), BitVecRef.__or__(), BitVecRef.__pos__(), BitVecRef.__radd__(), BitVecRef.__rand__(), BitVecRef.__rdiv__(), BitVecRef.__rlshift__(), BitVecRef.__rmod__(), BitVecRef.__rmul__(), BitVecRef.__ror__(), BitVecRef.__rrshift__(), BitVecRef.__rsub__(), BitVecRef.__rxor__(), BitVecRef.__sub__(), BitVecRef.__xor__(), BitVec(), BitVecs(), BitVecSort(), BV2Int(), Extract(), is_bv(), is_bv_value(), RepeatBitVec(), SignExt(), BitVecRef.size(), BitVecRef.sort(), SRem(), UDiv(), URem(), and ZeroExt().

◆ BitVecs()

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

4053def BitVecs(names, bv, ctx=None):
4054 """Return a tuple of bit-vector constants of size bv.
4055
4056 >>> x, y, z = BitVecs('x y z', 16)
4057 >>> x.size()
4058 16
4059 >>> x.sort()
4060 BitVec(16)
4061 >>> Sum(x, y, z)
4062 0 + x + y + z
4063 >>> Product(x, y, z)
4064 1*x*y*z
4065 >>> simplify(Product(x, y, z))
4066 x*y*z
4067 """
4068 ctx = _get_ctx(ctx)
4069 if isinstance(names, str):
4070 names = names.split(" ")
4071 return [BitVec(name, bv, ctx) for name in names]
4072
4073

Referenced by BitVecRef.__ge__(), BitVecRef.__gt__(), BitVecRef.__le__(), BitVecRef.__lshift__(), BitVecRef.__lt__(), BitVecRef.__rshift__(), BitVecs(), LShR(), RotateLeft(), RotateRight(), UGE(), UGT(), ULE(), and ULT().

◆ BitVecSort()

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

3997def BitVecSort(sz, ctx=None):
3998 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3999
4000 >>> Byte = BitVecSort(8)
4001 >>> Word = BitVecSort(16)
4002 >>> Byte
4003 BitVec(8)
4004 >>> x = Const('x', Byte)
4005 >>> eq(x, BitVec('x', 8))
4006 True
4007 """
4008 ctx = _get_ctx(ctx)
4009 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4010
4011
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(), BitVecSort(), BitVecVal(), BitVecSortRef.cast(), fpSignedToFP(), fpToFP(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), is_bv_sort(), BitVecSortRef.size(), and BitVecRef.sort().

◆ BitVecVal()

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

4012def BitVecVal(val, bv, ctx=None):
4013 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4014
4015 >>> v = BitVecVal(10, 32)
4016 >>> v
4017 10
4018 >>> print("0x%.8x" % v.as_long())
4019 0x0000000a
4020 """
4021 if is_bv_sort(bv):
4022 ctx = bv.ctx
4023 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4024 else:
4025 ctx = _get_ctx(ctx)
4026 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4027
4028
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.

Referenced by BitVecRef.__lshift__(), BitVecRef.__rshift__(), BitVecNumRef.as_long(), BitVecNumRef.as_signed_long(), BitVecVal(), Concat(), fpBVToFP(), fpFP(), fpSignedToFP(), fpToFP(), fpUnsignedToFP(), is_bv_value(), LShR(), RepeatBitVec(), SignExt(), and ZeroExt().

◆ Bool()

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

1724def Bool(name, ctx=None):
1725 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1726
1727 >>> p = Bool('p')
1728 >>> q = Bool('q')
1729 >>> And(p, q)
1730 And(p, q)
1731 """
1732 ctx = _get_ctx(ctx)
1733 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1734
1735

Referenced by SortRef.__eq__(), SortRef.__ne__(), Fixedpoint.add_rule(), Solver.assert_and_track(), Optimize.assert_and_track(), Bool(), Bools(), BoolVector(), is_bool(), is_false(), is_not(), is_true(), and Not().

◆ Bools()

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

1736def Bools(names, ctx=None):
1737 """Return a tuple of Boolean constants.
1738
1739 `names` is a single string containing all names separated by blank spaces.
1740 If `ctx=None`, then the global context is used.
1741
1742 >>> p, q, r = Bools('p q r')
1743 >>> And(p, Or(q, r))
1744 And(p, Or(q, r))
1745 """
1746 ctx = _get_ctx(ctx)
1747 if isinstance(names, str):
1748 names = names.split(" ")
1749 return [Bool(name, ctx) for name in names]
1750
1751

Referenced by And(), AtLeast(), AtMost(), Bools(), Solver.consequences(), Implies(), is_and(), is_implies(), is_or(), Or(), PbEq(), PbGe(), PbLe(), prove(), Solver.unsat_core(), and Xor().

◆ BoolSort()

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

1687def BoolSort(ctx=None):
1688 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1689
1690 >>> BoolSort()
1691 Bool
1692 >>> p = Const('p', BoolSort())
1693 >>> is_bool(p)
1694 True
1695 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1696 >>> r(0, 1)
1697 r(0, 1)
1698 >>> is_bool(r(0, 1))
1699 True
1700 """
1701 ctx = _get_ctx(ctx)
1702 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1703
1704
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.

Referenced by FuncDeclRef.__call__(), SortRef.__eq__(), ArrayRef.__getitem__(), SortRef.__ne__(), FuncDeclRef.arity(), ArraySort(), Goal.assert_exprs(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), Bool(), BoolSort(), BoolSortRef.cast(), Solver.check(), ArraySortRef.domain(), ArrayRef.domain(), FuncDeclRef.domain(), FreshBool(), If(), Implies(), IntSort(), is_arith_sort(), is_ast(), SortRef.kind(), SortRef.name(), Not(), FuncDeclRef.range(), ArraySortRef.range(), ArrayRef.range(), SetSort(), QuantifierRef.sort(), ArrayRef.sort(), Var(), and Xor().

◆ BoolVal()

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

1705def BoolVal(val, ctx=None):
1706 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1707
1708 >>> BoolVal(True)
1709 True
1710 >>> is_true(BoolVal(True))
1711 True
1712 >>> is_true(True)
1713 False
1714 >>> is_false(BoolVal(False))
1715 True
1716 """
1717 ctx = _get_ctx(ctx)
1718 if val:
1719 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1720 else:
1721 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1722
1723
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.

Referenced by _mk_quantifier(), _py2expr(), Goal.as_expr(), ApplyResult.as_expr(), BoolVal(), BoolSortRef.cast(), UserPropagateBase.conflict(), is_false(), Re(), and Solver.to_smt2().

◆ BoolVector()

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

1752def BoolVector(prefix, sz, ctx=None):
1753 """Return a list of Boolean constants of size `sz`.
1754
1755 The constants are named using the given prefix.
1756 If `ctx=None`, then the global context is used.
1757
1758 >>> P = BoolVector('p', 3)
1759 >>> P
1760 [p__0, p__1, p__2]
1761 >>> And(P)
1762 And(p__0, p__1, p__2)
1763 """
1764 return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1765
1766

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

◆ BV2Int()

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

3965def BV2Int(a, is_signed=False):
3966 """Return the Z3 expression BV2Int(a).
3967
3968 >>> b = BitVec('b', 3)
3969 >>> BV2Int(b).sort()
3970 Int
3971 >>> x = Int('x')
3972 >>> x > BV2Int(b)
3973 x > BV2Int(b)
3974 >>> x > BV2Int(b, is_signed=False)
3975 x > BV2Int(b)
3976 >>> x > BV2Int(b, is_signed=True)
3977 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3978 >>> solve(x > BV2Int(b), b == 1, x < 3)
3979 [x = 2, b = 1]
3980 """
3981 if z3_debug():
3982 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3983 ctx = a.ctx
3984 # investigate problem with bv2int
3985 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3986
3987
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...

Referenced by BV2Int().

◆ BVAddNoOverflow()

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

Definition at line 4451 of file z3py.py.

4451def BVAddNoOverflow(a, b, signed):
4452 """A predicate the determines that bit-vector addition does not overflow"""
4453 _check_bv_args(a, b)
4454 a, b = _coerce_exprs(a, b)
4455 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4456
4457
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()

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

Definition at line 4458 of file z3py.py.

4458def BVAddNoUnderflow(a, b):
4459 """A predicate the determines that signed bit-vector addition does not underflow"""
4460 _check_bv_args(a, b)
4461 a, b = _coerce_exprs(a, b)
4462 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4463
4464
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()

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

Definition at line 4493 of file z3py.py.

4493def BVMulNoOverflow(a, b, signed):
4494 """A predicate the determines that bit-vector multiplication does not overflow"""
4495 _check_bv_args(a, b)
4496 a, b = _coerce_exprs(a, b)
4497 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4498
4499
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()

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

Definition at line 4500 of file z3py.py.

4500def BVMulNoUnderflow(a, b):
4501 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4502 _check_bv_args(a, b)
4503 a, b = _coerce_exprs(a, b)
4504 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4505
4506
Z3_ast Z3_API Z3_mk_bvmul_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed multiplication of t1 and t2 does not underflo...

◆ BVRedAnd()

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

Definition at line 4437 of file z3py.py.

4437def BVRedAnd(a):
4438 """Return the reduction-and expression of `a`."""
4439 if z3_debug():
4440 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4441 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4442
4443
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()

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

Definition at line 4444 of file z3py.py.

4444def BVRedOr(a):
4445 """Return the reduction-or expression of `a`."""
4446 if z3_debug():
4447 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4448 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4449
4450
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()

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

Definition at line 4479 of file z3py.py.

4479def BVSDivNoOverflow(a, b):
4480 """A predicate the determines that bit-vector signed division does not overflow"""
4481 _check_bv_args(a, b)
4482 a, b = _coerce_exprs(a, b)
4483 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4484
4485
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()

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

Definition at line 4486 of file z3py.py.

4486def BVSNegNoOverflow(a):
4487 """A predicate the determines that bit-vector unary negation does not overflow"""
4488 if z3_debug():
4489 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4490 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4491
4492
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()

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

Definition at line 4465 of file z3py.py.

4465def BVSubNoOverflow(a, b):
4466 """A predicate the determines that bit-vector subtraction does not overflow"""
4467 _check_bv_args(a, b)
4468 a, b = _coerce_exprs(a, b)
4469 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4470
4471
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()

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

Definition at line 4472 of file z3py.py.

4472def BVSubNoUnderflow(a, b, signed):
4473 """A predicate the determines that bit-vector subtraction does not underflow"""
4474 _check_bv_args(a, b)
4475 a, b = _coerce_exprs(a, b)
4476 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4477
4478
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.

◆ Cbrt()

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

3416def Cbrt(a, ctx=None):
3417 """ Return a Z3 expression which represents the cubic root of a.
3418
3419 >>> x = Real('x')
3420 >>> Cbrt(x)
3421 x**(1/3)
3422 """
3423 if not is_expr(a):
3424 ctx = _get_ctx(ctx)
3425 a = RealVal(a, ctx)
3426 return a ** "1/3"
3427

Referenced by Cbrt().

◆ CharFromBv()

def CharFromBv (   ch,
  ctx = None 
)

Definition at line 10904 of file z3py.py.

10904def CharFromBv(ch, ctx=None):
10905 if not is_expr(ch):
10906 raise Z3Expression("Bit-vector expression needed")
10907 return _to_expr_ref(Z3_mk_char_from_bv(ch.ctx_ref(), ch.as_ast()), ch.ctx)
10908
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()

def CharIsDigit (   ch,
  ctx = None 
)

Definition at line 10917 of file z3py.py.

10917def CharIsDigit(ch, ctx=None):
10918 ch = _coerce_char(ch, ctx)
10919 return ch.is_digit()
10920

◆ CharSort()

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

Definition at line 10803 of file z3py.py.

10803def CharSort(ctx=None):
10804 """Create a character sort
10805 >>> ch = CharSort()
10806 >>> print(ch)
10807 Char
10808 """
10809 ctx = _get_ctx(ctx)
10810 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
10811
10812
Z3_sort Z3_API Z3_mk_char_sort(Z3_context c)
Create a sort for unicode characters.

Referenced by CharSort().

◆ CharToBv()

def CharToBv (   ch,
  ctx = None 
)

Definition at line 10909 of file z3py.py.

10909def CharToBv(ch, ctx=None):
10910 ch = _coerce_char(ch, ctx)
10911 return ch.to_bv()
10912

◆ CharToInt()

def CharToInt (   ch,
  ctx = None 
)

Definition at line 10913 of file z3py.py.

10913def CharToInt(ch, ctx=None):
10914 ch = _coerce_char(ch, ctx)
10915 return ch.to_int()
10916

◆ CharVal()

def CharVal (   ch,
  ctx = None 
)

Definition at line 10896 of file z3py.py.

10896def CharVal(ch, ctx=None):
10897 ctx = _get_ctx(ctx)
10898 if isinstance(ch, str):
10899 ch = ord(ch)
10900 if not isinstance(ch, int):
10901 raise Z3Exception("character value should be an ordinal")
10902 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
10903
Z3_ast Z3_API Z3_mk_char(Z3_context c, unsigned ch)
Create a character literal.

Referenced by _coerce_char().

◆ Complement()

def Complement (   re)
Create the complement regular expression.

Definition at line 11298 of file z3py.py.

11298def Complement(re):
11299 """Create the complement regular expression."""
11300 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11301
11302
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.

◆ Concat()

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

4074def Concat(*args):
4075 """Create a Z3 bit-vector concatenation expression.
4076
4077 >>> v = BitVecVal(1, 4)
4078 >>> Concat(v, v+1, v)
4079 Concat(Concat(1, 1 + 1), 1)
4080 >>> simplify(Concat(v, v+1, v))
4081 289
4082 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4083 121
4084 """
4085 args = _get_args(args)
4086 sz = len(args)
4087 if z3_debug():
4088 _z3_assert(sz >= 2, "At least two arguments expected.")
4089
4090 ctx = None
4091 for a in args:
4092 if is_expr(a):
4093 ctx = a.ctx
4094 break
4095 if is_seq(args[0]) or isinstance(args[0], str):
4096 args = [_coerce_seq(s, ctx) for s in args]
4097 if z3_debug():
4098 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4099 v = (Ast * sz)()
4100 for i in range(sz):
4101 v[i] = args[i].as_ast()
4102 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4103
4104 if is_re(args[0]):
4105 if z3_debug():
4106 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4107 v = (Ast * sz)()
4108 for i in range(sz):
4109 v[i] = args[i].as_ast()
4110 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4111
4112 if z3_debug():
4113 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4114 r = args[0]
4115 for i in range(sz - 1):
4116 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4117 return r
4118
4119
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.

Referenced by SeqRef.__add__(), SeqRef.__radd__(), Concat(), Contains(), and BitVecRef.size().

◆ Cond()

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

8802def Cond(p, t1, t2, ctx=None):
8803 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8804
8805 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8806 """
8807 p = _to_probe(p, ctx)
8808 t1 = _to_tactic(t1, ctx)
8809 t2 = _to_tactic(t2, ctx)
8810 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8811
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 Cond(), and If().

◆ Const()

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

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

Definition at line 1433 of file z3py.py.

1433def Const(name, sort):
1434 """Create a constant of the given sort.
1435
1436 >>> Const('x', IntSort())
1437 x
1438 """
1439 if z3_debug():
1440 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1441 ctx = sort.ctx
1442 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1443
1444

Referenced by BitVecSort(), BoolSort(), Const(), Consts(), DeclareSort(), FPSort(), IntSort(), is_finite_domain(), is_finite_domain_value(), IsMember(), IsSubset(), RealSort(), DatatypeSortRef.recognizer(), SetAdd(), SetComplement(), SetDel(), SetDifference(), SetIntersect(), and SetUnion().

◆ Consts()

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

1445def Consts(names, sort):
1446 """Create several constants of the given sort.
1447
1448 `names` is a string containing the names of all constants to be created.
1449 Blank spaces separate the names of different constants.
1450
1451 >>> x, y, z = Consts('x y z', IntSort())
1452 >>> x + y + z
1453 x + y + z
1454 """
1455 if isinstance(names, str):
1456 names = names.split(" ")
1457 return [Const(name, sort) for name in names]
1458
1459

Referenced by Consts(), Ext(), ModelRef.get_sort(), ModelRef.get_universe(), ModelRef.num_sorts(), and ModelRef.sorts().

◆ Contains()

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

11073def Contains(a, b):
11074 """Check if 'a' contains 'b'
11075 >>> s1 = Contains("abc", "ab")
11076 >>> simplify(s1)
11077 True
11078 >>> s2 = Contains("abc", "bc")
11079 >>> simplify(s2)
11080 True
11081 >>> x, y, z = Strings('x y z')
11082 >>> s3 = Contains(Concat(x,y,z), y)
11083 >>> simplify(s3)
11084 True
11085 """
11086 ctx = _get_ctx2(a, b)
11087 a = _coerce_seq(a, ctx)
11088 b = _coerce_seq(b, ctx)
11089 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11090
11091
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.

Referenced by Contains().

◆ CreateDatatypes()

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

5150def CreateDatatypes(*ds):
5151 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5152
5153 In the following example we define a Tree-List using two mutually recursive datatypes.
5154
5155 >>> TreeList = Datatype('TreeList')
5156 >>> Tree = Datatype('Tree')
5157 >>> # Tree has two constructors: leaf and node
5158 >>> Tree.declare('leaf', ('val', IntSort()))
5159 >>> # a node contains a list of trees
5160 >>> Tree.declare('node', ('children', TreeList))
5161 >>> TreeList.declare('nil')
5162 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5163 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5164 >>> Tree.val(Tree.leaf(10))
5165 val(leaf(10))
5166 >>> simplify(Tree.val(Tree.leaf(10)))
5167 10
5168 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5169 >>> n1
5170 node(cons(leaf(10), cons(leaf(20), nil)))
5171 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5172 >>> simplify(n2 == n1)
5173 False
5174 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5175 True
5176 """
5177 ds = _get_args(ds)
5178 if z3_debug():
5179 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5180 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5181 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5182 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5183 ctx = ds[0].ctx
5184 num = len(ds)
5185 names = (Symbol * num)()
5186 out = (Sort * num)()
5187 clists = (ConstructorList * num)()
5188 to_delete = []
5189 for i in range(num):
5190 d = ds[i]
5191 names[i] = to_symbol(d.name, ctx)
5192 num_cs = len(d.constructors)
5193 cs = (Constructor * num_cs)()
5194 for j in range(num_cs):
5195 c = d.constructors[j]
5196 cname = to_symbol(c[0], ctx)
5197 rname = to_symbol(c[1], ctx)
5198 fs = c[2]
5199 num_fs = len(fs)
5200 fnames = (Symbol * num_fs)()
5201 sorts = (Sort * num_fs)()
5202 refs = (ctypes.c_uint * num_fs)()
5203 for k in range(num_fs):
5204 fname = fs[k][0]
5205 ftype = fs[k][1]
5206 fnames[k] = to_symbol(fname, ctx)
5207 if isinstance(ftype, Datatype):
5208 if z3_debug():
5209 _z3_assert(
5210 ds.count(ftype) == 1,
5211 "One and only one occurrence of each datatype is expected",
5212 )
5213 sorts[k] = None
5214 refs[k] = ds.index(ftype)
5215 else:
5216 if z3_debug():
5217 _z3_assert(is_sort(ftype), "Z3 sort expected")
5218 sorts[k] = ftype.ast
5219 refs[k] = 0
5220 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5221 to_delete.append(ScopedConstructor(cs[j], ctx))
5222 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5223 to_delete.append(ScopedConstructorList(clists[i], ctx))
5224 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5225 result = []
5226 # Create a field for every constructor, recognizer and accessor
5227 for i in range(num):
5228 dref = DatatypeSortRef(out[i], ctx)
5229 num_cs = dref.num_constructors()
5230 for j in range(num_cs):
5231 cref = dref.constructor(j)
5232 cref_name = cref.name()
5233 cref_arity = cref.arity()
5234 if cref.arity() == 0:
5235 cref = cref()
5236 setattr(dref, cref_name, cref)
5237 rref = dref.recognizer(j)
5238 setattr(dref, "is_" + cref_name, rref)
5239 for k in range(cref_arity):
5240 aref = dref.accessor(j, k)
5241 setattr(dref, aref.name(), aref)
5242 result.append(dref)
5243 return tuple(result)
5244
5245
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort_opt const sorts[], unsigned sort_refs[])
Create a constructor.
void Z3_API Z3_mk_datatypes(Z3_context c, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort sorts[], Z3_constructor_list constructor_lists[])
Create mutually recursive datatypes.
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.

Referenced by Datatype.create(), and CreateDatatypes().

◆ DatatypeSort()

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

Definition at line 5350 of file z3py.py.

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

◆ DeclareSort()

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

693def DeclareSort(name, ctx=None):
694 """Create a new uninterpreted sort named `name`.
695
696 If `ctx=None`, then the new sort is declared in the global Z3Py context.
697
698 >>> A = DeclareSort('A')
699 >>> a = Const('a', A)
700 >>> b = Const('b', A)
701 >>> a.sort() == A
702 True
703 >>> b.sort() == A
704 True
705 >>> a == b
706 a == b
707 """
708 ctx = _get_ctx(ctx)
709 return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
710
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).

Referenced by DeclareSort(), ModelRef.get_sort(), ModelRef.get_universe(), ModelRef.num_sorts(), and ModelRef.sorts().

◆ Default()

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

Definition at line 4771 of file z3py.py.

4771def Default(a):
4772 """ Return a default value for array expression.
4773 >>> b = K(IntSort(), 1)
4774 >>> prove(Default(b) == 1)
4775 proved
4776 """
4777 if z3_debug():
4778 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4779 return a.default()
4780
4781

Referenced by Default(), and is_default().

◆ describe_probes()

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

Definition at line 8723 of file z3py.py.

8723def describe_probes():
8724 """Display a (tabular) description of all available probes in Z3."""
8725 if in_html_mode():
8726 even = True
8727 print('<table border="1" cellpadding="2" cellspacing="0">')
8728 for p in probes():
8729 if even:
8730 print('<tr style="background-color:#CFCFCF">')
8731 even = False
8732 else:
8733 print("<tr>")
8734 even = True
8735 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8736 print("</table>")
8737 else:
8738 for p in probes():
8739 print("%s : %s" % (p, probe_description(p)))
8740
8741

◆ describe_tactics()

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

Definition at line 8517 of file z3py.py.

8517def describe_tactics():
8518 """Display a (tabular) description of all available tactics in Z3."""
8519 if in_html_mode():
8520 even = True
8521 print('<table border="1" cellpadding="2" cellspacing="0">')
8522 for t in tactics():
8523 if even:
8524 print('<tr style="background-color:#CFCFCF">')
8525 even = False
8526 else:
8527 print("<tr>")
8528 even = True
8529 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8530 print("</table>")
8531 else:
8532 for t in tactics():
8533 print("%s : %s" % (t, tactic_description(t)))
8534
8535

◆ deserialize()

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

1115def deserialize(st):
1116 """inverse function to the serialize method on ExprRef.
1117 It is made available to make it easier for users to serialize expressions back and forth between
1118 strings. Solvers can be serialized using the 'sexpr()' method.
1119 """
1120 s = Solver()
1121 s.from_string(st)
1122 if len(s.assertions()) != 1:
1123 raise Z3Exception("single assertion expected")
1124 fml = s.assertions()[0]
1125 if fml.num_args() != 1:
1126 raise Z3Exception("dummy function 'F' expected")
1127 return fml.arg(0)
1128

◆ Diff()

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

Definition at line 11341 of file z3py.py.

11341def Diff(a, b, ctx=None):
11342 """Create the difference regular expression
11343 """
11344 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11345
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()

def disable_trace (   msg)

Definition at line 79 of file z3py.py.

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

◆ DisjointSum()

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

5367def DisjointSum(name, sorts, ctx=None):
5368 """Create a named tagged union sort base on a set of underlying sorts
5369 Example:
5370 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5371 """
5372 sum = Datatype(name, ctx)
5373 for i in range(len(sorts)):
5374 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5375 sum = sum.create()
5376 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5377
5378

Referenced by DisjointSum().

◆ Distinct()

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

1400def Distinct(*args):
1401 """Create a Z3 distinct expression.
1402
1403 >>> x = Int('x')
1404 >>> y = Int('y')
1405 >>> Distinct(x, y)
1406 x != y
1407 >>> z = Int('z')
1408 >>> Distinct(x, y, z)
1409 Distinct(x, y, z)
1410 >>> simplify(Distinct(x, y, z))
1411 Distinct(x, y, z)
1412 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1413 And(Not(x == y), Not(x == z), Not(y == z))
1414 """
1415 args = _get_args(args)
1416 ctx = _ctx_from_ast_arg_list(args)
1417 if z3_debug():
1418 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1419 args = _coerce_expr_list(args, ctx)
1420 _args, sz = _to_ast_array(args)
1421 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1422
1423
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]).

Referenced by Distinct(), is_distinct(), and simplify().

◆ Empty()

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

11003def Empty(s):
11004 """Create the empty sequence of the given sort
11005 >>> e = Empty(StringSort())
11006 >>> e2 = StringVal("")
11007 >>> print(e.eq(e2))
11008 True
11009 >>> e3 = Empty(SeqSort(IntSort()))
11010 >>> print(e3)
11011 Empty(Seq(Int))
11012 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11013 >>> print(e4)
11014 Empty(ReSort(Seq(Int)))
11015 """
11016 if isinstance(s, SeqSortRef):
11017 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11018 if isinstance(s, ReSortRef):
11019 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11020 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11021
11022
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.

Referenced by Empty().

◆ EmptySet()

def EmptySet (   s)
Create the empty set
>>> EmptySet(IntSort())
K(Int, False)

Definition at line 4914 of file z3py.py.

4914def EmptySet(s):
4915 """Create the empty set
4916 >>> EmptySet(IntSort())
4917 K(Int, False)
4918 """
4919 ctx = s.ctx
4920 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4921
4922
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.

Referenced by EmptySet().

◆ enable_trace()

def enable_trace (   msg)

Definition at line 75 of file z3py.py.

75def enable_trace(msg):
77
78
void Z3_API Z3_enable_trace(Z3_string tag)
Enable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.

◆ ensure_prop_closures()

def ensure_prop_closures ( )

Definition at line 11456 of file z3py.py.

11456def ensure_prop_closures():
11457 global _prop_closures
11458 if _prop_closures is None:
11459 _prop_closures = PropClosures()
11460
11461

Referenced by UserPropagateBase.__init__().

◆ EnumSort()

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

5379def EnumSort(name, values, ctx=None):
5380 """Return a new enumeration sort named `name` containing the given values.
5381
5382 The result is a pair (sort, list of constants).
5383 Example:
5384 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5385 """
5386 if z3_debug():
5387 _z3_assert(isinstance(name, str), "Name must be a string")
5388 _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5389 _z3_assert(len(values) > 0, "At least one value expected")
5390 ctx = _get_ctx(ctx)
5391 num = len(values)
5392 _val_names = (Symbol * num)()
5393 for i in range(num):
5394 _val_names[i] = to_symbol(values[i])
5395 _values = (FuncDecl * num)()
5396 _testers = (FuncDecl * num)()
5397 name = to_symbol(name)
5398 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5399 V = []
5400 for i in range(num):
5401 V.append(FuncDeclRef(_values[i], ctx))
5402 V = [a() for a in V]
5403 return S, V
5404
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.

Referenced by EnumSort().

◆ eq()

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

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

Definition at line 472 of file z3py.py.

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

Referenced by BitVec(), BitVecSort(), eq(), FP(), FPSort(), FreshBool(), FreshInt(), FreshReal(), get_map_func(), main_ctx(), Select(), substitute(), and Var().

◆ Exists()

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

2236def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2237 """Create a Z3 exists formula.
2238
2239 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2240
2241
2242 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2243 >>> x = Int('x')
2244 >>> y = Int('y')
2245 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2246 >>> q
2247 Exists([x, y], f(x, y) >= x)
2248 >>> is_quantifier(q)
2249 True
2250 >>> r = Tactic('nnf')(q).as_expr()
2251 >>> is_quantifier(r)
2252 False
2253 """
2254 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2255
2256

Referenced by Fixedpoint.abstract(), Exists(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), and QuantifierRef.is_lambda().

◆ Ext()

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

4860def Ext(a, b):
4861 """Return extensionality index for one-dimensional arrays.
4862 >> a, b = Consts('a b', SetSort(IntSort()))
4863 >> Ext(a, b)
4864 Ext(a, b)
4865 """
4866 ctx = a.ctx
4867 if z3_debug():
4868 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4869 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4870
4871
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...

Referenced by Ext().

◆ Extract()

def Extract (   high,
  low,
  a 
)
Create a Z3 bit-vector extraction expression.
Extract is overloaded to also work on sequence extraction.
The functions SubString and SubSeq are redirected to Extract.
For this case, the arguments are reinterpreted as:
    high - is a sequence (string)
    low  - is an offset
    a    - is the length to be extracted

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

Definition at line 4120 of file z3py.py.

4120def Extract(high, low, a):
4121 """Create a Z3 bit-vector extraction expression.
4122 Extract is overloaded to also work on sequence extraction.
4123 The functions SubString and SubSeq are redirected to Extract.
4124 For this case, the arguments are reinterpreted as:
4125 high - is a sequence (string)
4126 low - is an offset
4127 a - is the length to be extracted
4128
4129 >>> x = BitVec('x', 8)
4130 >>> Extract(6, 2, x)
4131 Extract(6, 2, x)
4132 >>> Extract(6, 2, x).sort()
4133 BitVec(5)
4134 >>> simplify(Extract(StringVal("abcd"),2,1))
4135 "c"
4136 """
4137 if isinstance(high, str):
4138 high = StringVal(high)
4139 if is_seq(high):
4140 s = high
4141 offset, length = _coerce_exprs(low, a, s.ctx)
4142 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4143 if z3_debug():
4144 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4145 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4146 "First and second arguments must be non negative integers")
4147 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4148 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4149
4150
Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast t1)
Extract the bits high down to low from a bit-vector of size m to yield a new bit-vector of size n,...
Z3_ast Z3_API Z3_mk_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.

Referenced by Extract(), SubSeq(), and SubString().

◆ FailIf()

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

8760def FailIf(p, ctx=None):
8761 """Return a tactic that fails if the probe `p` evaluates to true.
8762 Otherwise, it returns the input goal unmodified.
8763
8764 In the following example, the tactic applies 'simplify' if and only if there are
8765 more than 2 constraints in the goal.
8766
8767 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8768 >>> x, y = Ints('x y')
8769 >>> g = Goal()
8770 >>> g.add(x > 0)
8771 >>> g.add(y > 0)
8772 >>> t(g)
8773 [[x > 0, y > 0]]
8774 >>> g.add(x == y + 1)
8775 >>> t(g)
8776 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8777 """
8778 p = _to_probe(p, ctx)
8779 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8780
8781
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.

Referenced by FailIf().

◆ FiniteDomainSort()

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

Definition at line 7708 of file z3py.py.

7708def FiniteDomainSort(name, sz, ctx=None):
7709 """Create a named finite domain sort of a given size sz"""
7710 if not isinstance(name, Symbol):
7711 name = to_symbol(name)
7712 ctx = _get_ctx(ctx)
7713 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7714
7715
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.

Referenced by FiniteDomainNumRef.as_long(), FiniteDomainNumRef.as_string(), FiniteDomainVal(), is_finite_domain(), is_finite_domain_sort(), and is_finite_domain_value().

◆ FiniteDomainVal()

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

7778def FiniteDomainVal(val, sort, ctx=None):
7779 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7780
7781 >>> s = FiniteDomainSort('S', 256)
7782 >>> FiniteDomainVal(255, s)
7783 255
7784 >>> FiniteDomainVal('100', s)
7785 100
7786 """
7787 if z3_debug():
7788 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7789 ctx = sort.ctx
7790 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7791
7792

Referenced by FiniteDomainNumRef.as_long(), FiniteDomainNumRef.as_string(), FiniteDomainVal(), and is_finite_domain_value().

◆ Float128()

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

Definition at line 9488 of file z3py.py.

9488def Float128(ctx=None):
9489 """Floating-point 128-bit (quadruple) sort."""
9490 ctx = _get_ctx(ctx)
9491 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9492
9493
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.

◆ Float16()

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

Definition at line 9452 of file z3py.py.

9452def Float16(ctx=None):
9453 """Floating-point 16-bit (half) sort."""
9454 ctx = _get_ctx(ctx)
9455 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9456
9457
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ Float32()

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

Definition at line 9464 of file z3py.py.

9464def Float32(ctx=None):
9465 """Floating-point 32-bit (single) sort."""
9466 ctx = _get_ctx(ctx)
9467 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9468
9469
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

Referenced by FPRef.__neg__(), fpBVToFP(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), fpToFP(), and fpUnsignedToFP().

◆ Float64()

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

Definition at line 9476 of file z3py.py.

9476def Float64(ctx=None):
9477 """Floating-point 64-bit (double) sort."""
9478 ctx = _get_ctx(ctx)
9479 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9480
9481
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

Referenced by fpFPToFP(), and fpToFP().

◆ FloatDouble()

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

Definition at line 9482 of file z3py.py.

9482def FloatDouble(ctx=None):
9483 """Floating-point 64-bit (double) sort."""
9484 ctx = _get_ctx(ctx)
9485 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9486
9487
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

◆ FloatHalf()

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

Definition at line 9458 of file z3py.py.

9458def FloatHalf(ctx=None):
9459 """Floating-point 16-bit (half) sort."""
9460 ctx = _get_ctx(ctx)
9461 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9462
9463
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ FloatQuadruple()

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

Definition at line 9494 of file z3py.py.

9494def FloatQuadruple(ctx=None):
9495 """Floating-point 128-bit (quadruple) sort."""
9496 ctx = _get_ctx(ctx)
9497 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9498
9499
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.

◆ FloatSingle()

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

Definition at line 9470 of file z3py.py.

9470def FloatSingle(ctx=None):
9471 """Floating-point 32-bit (single) sort."""
9472 ctx = _get_ctx(ctx)
9473 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9474
9475
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

◆ ForAll()

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

2218def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2219 """Create a Z3 forall formula.
2220
2221 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2222
2223 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2224 >>> x = Int('x')
2225 >>> y = Int('y')
2226 >>> ForAll([x, y], f(x, y) >= x)
2227 ForAll([x, y], f(x, y) >= x)
2228 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2229 ForAll([x, y], f(x, y) >= x)
2230 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2231 ForAll([x, y], f(x, y) >= x)
2232 """
2233 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2234
2235

Referenced by Fixedpoint.abstract(), QuantifierRef.body(), QuantifierRef.children(), ForAll(), get_var_index(), is_app(), is_const(), QuantifierRef.is_exists(), is_expr(), QuantifierRef.is_forall(), is_pattern(), is_quantifier(), is_var(), MultiPattern(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), QuantifierRef.pattern(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

◆ FP()

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

10120def FP(name, fpsort, ctx=None):
10121 """Return a floating-point constant named `name`.
10122 `fpsort` is the floating-point sort.
10123 If `ctx=None`, then the global context is used.
10124
10125 >>> x = FP('x', FPSort(8, 24))
10126 >>> is_fp(x)
10127 True
10128 >>> x.ebits()
10129 8
10130 >>> x.sort()
10131 FPSort(8, 24)
10132 >>> word = FPSort(8, 24)
10133 >>> x2 = FP('x', word)
10134 >>> eq(x, x2)
10135 True
10136 """
10137 if isinstance(fpsort, FPSortRef) and ctx is None:
10138 ctx = fpsort.ctx
10139 else:
10140 ctx = _get_ctx(ctx)
10141 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10142
10143

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__neg__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), FPRef.__sub__(), FP(), fpAdd(), fpDiv(), fpIsInf(), fpIsNaN(), fpMax(), fpMin(), fpMul(), fpNeg(), fpRem(), FPs(), FPSort(), fpSub(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), is_fp(), is_fp_value(), and FPRef.sort().

◆ fpAbs()

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

10163def fpAbs(a, ctx=None):
10164 """Create a Z3 floating-point absolute value expression.
10165
10166 >>> s = FPSort(8, 24)
10167 >>> rm = RNE()
10168 >>> x = FPVal(1.0, s)
10169 >>> fpAbs(x)
10170 fpAbs(1)
10171 >>> y = FPVal(-20.0, s)
10172 >>> y
10173 -1.25*(2**4)
10174 >>> fpAbs(y)
10175 fpAbs(-1.25*(2**4))
10176 >>> fpAbs(-1.25*(2**4))
10177 fpAbs(-1.25*(2**4))
10178 >>> fpAbs(x).sort()
10179 FPSort(8, 24)
10180 """
10181 ctx = _get_ctx(ctx)
10182 [a] = _coerce_fp_expr_list([a], ctx)
10183 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10184
10185
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.

Referenced by fpAbs().

◆ fpAdd()

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

10254def fpAdd(rm, a, b, ctx=None):
10255 """Create a Z3 floating-point addition expression.
10256
10257 >>> s = FPSort(8, 24)
10258 >>> rm = RNE()
10259 >>> x = FP('x', s)
10260 >>> y = FP('y', s)
10261 >>> fpAdd(rm, x, y)
10262 x + y
10263 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10264 fpAdd(RTZ(), x, y)
10265 >>> fpAdd(rm, x, y).sort()
10266 FPSort(8, 24)
10267 """
10268 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10269
10270

Referenced by FPRef.__add__(), FPRef.__radd__(), fpAdd(), and FPs().

◆ fpBVToFP()

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

10576def fpBVToFP(v, sort, ctx=None):
10577 """Create a Z3 floating-point conversion expression that represents the
10578 conversion from a bit-vector term to a floating-point term.
10579
10580 >>> x_bv = BitVecVal(0x3F800000, 32)
10581 >>> x_fp = fpBVToFP(x_bv, Float32())
10582 >>> x_fp
10583 fpToFP(1065353216)
10584 >>> simplify(x_fp)
10585 1
10586 """
10587 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10588 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10589 ctx = _get_ctx(ctx)
10590 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10591
10592
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.

Referenced by fpBVToFP().

◆ fpDiv()

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

10301def fpDiv(rm, a, b, ctx=None):
10302 """Create a Z3 floating-point division expression.
10303
10304 >>> s = FPSort(8, 24)
10305 >>> rm = RNE()
10306 >>> x = FP('x', s)
10307 >>> y = FP('y', s)
10308 >>> fpDiv(rm, x, y)
10309 x / y
10310 >>> fpDiv(rm, x, y).sort()
10311 FPSort(8, 24)
10312 """
10313 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10314
10315

Referenced by FPRef.__div__(), FPRef.__rdiv__(), and fpDiv().

◆ fpEQ()

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

10484def fpEQ(a, b, ctx=None):
10485 """Create the Z3 floating-point expression `fpEQ(other, self)`.
10486
10487 >>> x, y = FPs('x y', FPSort(8, 24))
10488 >>> fpEQ(x, y)
10489 fpEQ(x, y)
10490 >>> fpEQ(x, y).sexpr()
10491 '(fp.eq x y)'
10492 """
10493 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10494
10495

Referenced by fpEQ(), fpFP(), and fpNEQ().

◆ fpFMA()

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

Definition at line 10360 of file z3py.py.

10360def fpFMA(rm, a, b, c, ctx=None):
10361 """Create a Z3 floating-point fused multiply-add expression.
10362 """
10363 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10364
10365

◆ fpFP()

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

10508def fpFP(sgn, exp, sig, ctx=None):
10509 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10510
10511 >>> s = FPSort(8, 24)
10512 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10513 >>> print(x)
10514 fpFP(1, 127, 4194304)
10515 >>> xv = FPVal(-1.5, s)
10516 >>> print(xv)
10517 -1.5
10518 >>> slvr = Solver()
10519 >>> slvr.add(fpEQ(x, xv))
10520 >>> slvr.check()
10521 sat
10522 >>> xv = FPVal(+1.5, s)
10523 >>> print(xv)
10524 1.5
10525 >>> slvr = Solver()
10526 >>> slvr.add(fpEQ(x, xv))
10527 >>> slvr.check()
10528 unsat
10529 """
10530 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10531 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10532 ctx = _get_ctx(ctx)
10533 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10534 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10535
10536
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.

Referenced by fpFP().

◆ fpFPToFP()

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

10593def fpFPToFP(rm, v, sort, ctx=None):
10594 """Create a Z3 floating-point conversion expression that represents the
10595 conversion from a floating-point term to a floating-point term of different precision.
10596
10597 >>> x_sgl = FPVal(1.0, Float32())
10598 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10599 >>> x_dbl
10600 fpToFP(RNE(), 1)
10601 >>> simplify(x_dbl)
10602 1
10603 >>> x_dbl.sort()
10604 FPSort(11, 53)
10605 """
10606 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10607 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10608 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10609 ctx = _get_ctx(ctx)
10610 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10611
10612
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.

Referenced by fpFPToFP().

◆ fpGEQ()

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

10472def fpGEQ(a, b, ctx=None):
10473 """Create the Z3 floating-point expression `other >= self`.
10474
10475 >>> x, y = FPs('x y', FPSort(8, 24))
10476 >>> fpGEQ(x, y)
10477 x >= y
10478 >>> (x >= y).sexpr()
10479 '(fp.geq x y)'
10480 """
10481 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10482
10483

Referenced by FPRef.__ge__(), and fpGEQ().

◆ fpGT()

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

10460def fpGT(a, b, ctx=None):
10461 """Create the Z3 floating-point expression `other > self`.
10462
10463 >>> x, y = FPs('x y', FPSort(8, 24))
10464 >>> fpGT(x, y)
10465 x > y
10466 >>> (x > y).sexpr()
10467 '(fp.gt x y)'
10468 """
10469 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10470
10471

Referenced by FPRef.__gt__(), and fpGT().

◆ fpInfinity()

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

Definition at line 10048 of file z3py.py.

10048def fpInfinity(s, negative):
10049 """Create a Z3 floating-point +oo or -oo term."""
10050 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10051 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10052 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10053
10054
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()

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

10390def fpIsInf(a, ctx=None):
10391 """Create a Z3 floating-point isInfinite expression.
10392
10393 >>> s = FPSort(8, 24)
10394 >>> x = FP('x', s)
10395 >>> fpIsInf(x)
10396 fpIsInf(x)
10397 """
10398 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10399
10400

Referenced by fpIsInf().

◆ fpIsNaN()

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

10378def fpIsNaN(a, ctx=None):
10379 """Create a Z3 floating-point isNaN expression.
10380
10381 >>> s = FPSort(8, 24)
10382 >>> x = FP('x', s)
10383 >>> y = FP('y', s)
10384 >>> fpIsNaN(x)
10385 fpIsNaN(x)
10386 """
10387 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10388
10389

Referenced by fpIsNaN().

◆ fpIsNegative()

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

Definition at line 10419 of file z3py.py.

10419def fpIsNegative(a, ctx=None):
10420 """Create a Z3 floating-point isNegative expression.
10421 """
10422 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10423
10424

◆ fpIsNormal()

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

Definition at line 10407 of file z3py.py.

10407def fpIsNormal(a, ctx=None):
10408 """Create a Z3 floating-point isNormal expression.
10409 """
10410 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10411
10412

◆ fpIsPositive()

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

Definition at line 10425 of file z3py.py.

10425def fpIsPositive(a, ctx=None):
10426 """Create a Z3 floating-point isPositive expression.
10427 """
10428 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10429
10430

◆ fpIsSubnormal()

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

Definition at line 10413 of file z3py.py.

10413def fpIsSubnormal(a, ctx=None):
10414 """Create a Z3 floating-point isSubnormal expression.
10415 """
10416 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10417
10418

◆ fpIsZero()

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

Definition at line 10401 of file z3py.py.

10401def fpIsZero(a, ctx=None):
10402 """Create a Z3 floating-point isZero expression.
10403 """
10404 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10405
10406

◆ fpLEQ()

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

10448def fpLEQ(a, b, ctx=None):
10449 """Create the Z3 floating-point expression `other <= self`.
10450
10451 >>> x, y = FPs('x y', FPSort(8, 24))
10452 >>> fpLEQ(x, y)
10453 x <= y
10454 >>> (x <= y).sexpr()
10455 '(fp.leq x y)'
10456 """
10457 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10458
10459

Referenced by FPRef.__le__(), and fpLEQ().

◆ fpLT()

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

10436def fpLT(a, b, ctx=None):
10437 """Create the Z3 floating-point expression `other < self`.
10438
10439 >>> x, y = FPs('x y', FPSort(8, 24))
10440 >>> fpLT(x, y)
10441 x < y
10442 >>> (x < y).sexpr()
10443 '(fp.lt x y)'
10444 """
10445 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10446
10447

Referenced by FPRef.__lt__(), and fpLT().

◆ fpMax()

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

10345def fpMax(a, b, ctx=None):
10346 """Create a Z3 floating-point maximum expression.
10347
10348 >>> s = FPSort(8, 24)
10349 >>> rm = RNE()
10350 >>> x = FP('x', s)
10351 >>> y = FP('y', s)
10352 >>> fpMax(x, y)
10353 fpMax(x, y)
10354 >>> fpMax(x, y).sort()
10355 FPSort(8, 24)
10356 """
10357 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10358
10359

Referenced by fpMax().

◆ fpMin()

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

10330def fpMin(a, b, ctx=None):
10331 """Create a Z3 floating-point minimum expression.
10332
10333 >>> s = FPSort(8, 24)
10334 >>> rm = RNE()
10335 >>> x = FP('x', s)
10336 >>> y = FP('y', s)
10337 >>> fpMin(x, y)
10338 fpMin(x, y)
10339 >>> fpMin(x, y).sort()
10340 FPSort(8, 24)
10341 """
10342 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10343
10344

Referenced by fpMin().

◆ fpMinusInfinity()

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

Definition at line 10042 of file z3py.py.

10042def fpMinusInfinity(s):
10043 """Create a Z3 floating-point -oo term."""
10044 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10045 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10046
10047

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 10061 of file z3py.py.

10061def fpMinusZero(s):
10062 """Create a Z3 floating-point -0.0 term."""
10063 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10064 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10065
10066
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.

Referenced by FPVal().

◆ fpMul()

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

10286def fpMul(rm, a, b, ctx=None):
10287 """Create a Z3 floating-point multiplication expression.
10288
10289 >>> s = FPSort(8, 24)
10290 >>> rm = RNE()
10291 >>> x = FP('x', s)
10292 >>> y = FP('y', s)
10293 >>> fpMul(rm, x, y)
10294 x * y
10295 >>> fpMul(rm, x, y).sort()
10296 FPSort(8, 24)
10297 """
10298 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10299
10300

Referenced by FPRef.__mul__(), FPRef.__rmul__(), fpMul(), and FPs().

◆ fpNaN()

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

10008def fpNaN(s):
10009 """Create a Z3 floating-point NaN term.
10010
10011 >>> s = FPSort(8, 24)
10012 >>> set_fpa_pretty(True)
10013 >>> fpNaN(s)
10014 NaN
10015 >>> pb = get_fpa_pretty()
10016 >>> set_fpa_pretty(False)
10017 >>> fpNaN(s)
10018 fpNaN(FPSort(8, 24))
10019 >>> set_fpa_pretty(pb)
10020 """
10021 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10022 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10023
10024
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.

Referenced by fpNaN(), and FPVal().

◆ fpNeg()

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

10186def fpNeg(a, ctx=None):
10187 """Create a Z3 floating-point addition expression.
10188
10189 >>> s = FPSort(8, 24)
10190 >>> rm = RNE()
10191 >>> x = FP('x', s)
10192 >>> fpNeg(x)
10193 -x
10194 >>> fpNeg(x).sort()
10195 FPSort(8, 24)
10196 """
10197 ctx = _get_ctx(ctx)
10198 [a] = _coerce_fp_expr_list([a], ctx)
10199 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10200
10201
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.

Referenced by FPRef.__neg__(), and fpNeg().

◆ fpNEQ()

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

10496def fpNEQ(a, b, ctx=None):
10497 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10498
10499 >>> x, y = FPs('x y', FPSort(8, 24))
10500 >>> fpNEQ(x, y)
10501 Not(fpEQ(x, y))
10502 >>> (x != y).sexpr()
10503 '(distinct x y)'
10504 """
10505 return Not(fpEQ(a, b, ctx))
10506
10507

Referenced by fpNEQ().

◆ fpPlusInfinity()

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

10025def fpPlusInfinity(s):
10026 """Create a Z3 floating-point +oo term.
10027
10028 >>> s = FPSort(8, 24)
10029 >>> pb = get_fpa_pretty()
10030 >>> set_fpa_pretty(True)
10031 >>> fpPlusInfinity(s)
10032 +oo
10033 >>> set_fpa_pretty(False)
10034 >>> fpPlusInfinity(s)
10035 fpPlusInfinity(FPSort(8, 24))
10036 >>> set_fpa_pretty(pb)
10037 """
10038 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10039 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10040
10041

Referenced by fpPlusInfinity(), and FPVal().

◆ fpPlusZero()

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

Definition at line 10055 of file z3py.py.

10055def fpPlusZero(s):
10056 """Create a Z3 floating-point +0.0 term."""
10057 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10058 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10059
10060

Referenced by FPVal().

◆ fpRealToFP()

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

10613def fpRealToFP(rm, v, sort, ctx=None):
10614 """Create a Z3 floating-point conversion expression that represents the
10615 conversion from a real term to a floating-point term.
10616
10617 >>> x_r = RealVal(1.5)
10618 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10619 >>> x_fp
10620 fpToFP(RNE(), 3/2)
10621 >>> simplify(x_fp)
10622 1.5
10623 """
10624 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10625 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10626 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10627 ctx = _get_ctx(ctx)
10628 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10629
10630
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.

Referenced by fpRealToFP().

◆ fpRem()

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

10316def fpRem(a, b, ctx=None):
10317 """Create a Z3 floating-point remainder expression.
10318
10319 >>> s = FPSort(8, 24)
10320 >>> x = FP('x', s)
10321 >>> y = FP('y', s)
10322 >>> fpRem(x, y)
10323 fpRem(x, y)
10324 >>> fpRem(x, y).sort()
10325 FPSort(8, 24)
10326 """
10327 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10328
10329

Referenced by FPRef.__mod__(), FPRef.__rmod__(), and fpRem().

◆ fpRoundToIntegral()

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

Definition at line 10372 of file z3py.py.

10372def fpRoundToIntegral(rm, a, ctx=None):
10373 """Create a Z3 floating-point roundToIntegral expression.
10374 """
10375 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10376
10377

◆ FPs()

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

10144def FPs(names, fpsort, ctx=None):
10145 """Return an array of floating-point constants.
10146
10147 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10148 >>> x.sort()
10149 FPSort(8, 24)
10150 >>> x.sbits()
10151 24
10152 >>> x.ebits()
10153 8
10154 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10155 x + y * z
10156 """
10157 ctx = _get_ctx(ctx)
10158 if isinstance(names, str):
10159 names = names.split(" ")
10160 return [FP(name, fpsort, ctx) for name in names]
10161
10162

Referenced by fpEQ(), fpGEQ(), fpGT(), fpLEQ(), fpLT(), fpNEQ(), and FPs().

◆ fpSignedToFP()

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

10631def fpSignedToFP(rm, v, sort, ctx=None):
10632 """Create a Z3 floating-point conversion expression that represents the
10633 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10634
10635 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10636 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10637 >>> x_fp
10638 fpToFP(RNE(), 4294967291)
10639 >>> simplify(x_fp)
10640 -1.25*(2**2)
10641 """
10642 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10643 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10644 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10645 ctx = _get_ctx(ctx)
10646 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10647
10648
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.

Referenced by fpSignedToFP().

◆ FPSort()

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

9949def FPSort(ebits, sbits, ctx=None):
9950 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9951
9952 >>> Single = FPSort(8, 24)
9953 >>> Double = FPSort(11, 53)
9954 >>> Single
9955 FPSort(8, 24)
9956 >>> x = Const('x', Single)
9957 >>> eq(x, FP('x', FPSort(8, 24)))
9958 True
9959 """
9960 ctx = _get_ctx(ctx)
9961 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9962
9963
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), FPRef.__sub__(), FPSortRef.cast(), FPSortRef.ebits(), FPRef.ebits(), FPNumRef.exponent(), FP(), fpAbs(), fpAdd(), fpDiv(), fpEQ(), fpFP(), fpFPToFP(), fpGEQ(), fpGT(), fpIsInf(), fpIsNaN(), fpLEQ(), fpLT(), fpMax(), fpMin(), fpMul(), fpNaN(), fpNeg(), fpNEQ(), fpPlusInfinity(), fpRem(), FPs(), FPSort(), fpSub(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), FPVal(), get_default_fp_sort(), is_fp(), is_fp_value(), is_fprm_sort(), FPNumRef.isNegative(), FPSortRef.sbits(), FPRef.sbits(), FPNumRef.sign_as_bv(), FPNumRef.significand(), FPNumRef.significand_as_bv(), and FPRef.sort().

◆ fpSqrt()

def fpSqrt (   rm,
  a,
  ctx = None 
)
Create a Z3 floating-point square root expression.

Definition at line 10366 of file z3py.py.

10366def fpSqrt(rm, a, ctx=None):
10367 """Create a Z3 floating-point square root expression.
10368 """
10369 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10370
10371

◆ fpSub()

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

10271def fpSub(rm, a, b, ctx=None):
10272 """Create a Z3 floating-point subtraction expression.
10273
10274 >>> s = FPSort(8, 24)
10275 >>> rm = RNE()
10276 >>> x = FP('x', s)
10277 >>> y = FP('y', s)
10278 >>> fpSub(rm, x, y)
10279 x - y
10280 >>> fpSub(rm, x, y).sort()
10281 FPSort(8, 24)
10282 """
10283 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10284
10285

Referenced by FPRef.__rsub__(), FPRef.__sub__(), and fpSub().

◆ fpToFP()

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

10537def fpToFP(a1, a2=None, a3=None, ctx=None):
10538 """Create a Z3 floating-point conversion expression from other term sorts
10539 to floating-point.
10540
10541 From a bit-vector term in IEEE 754-2008 format:
10542 >>> x = FPVal(1.0, Float32())
10543 >>> x_bv = fpToIEEEBV(x)
10544 >>> simplify(fpToFP(x_bv, Float32()))
10545 1
10546
10547 From a floating-point term with different precision:
10548 >>> x = FPVal(1.0, Float32())
10549 >>> x_db = fpToFP(RNE(), x, Float64())
10550 >>> x_db.sort()
10551 FPSort(11, 53)
10552
10553 From a real term:
10554 >>> x_r = RealVal(1.5)
10555 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10556 1.5
10557
10558 From a signed bit-vector term:
10559 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10560 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10561 -1.25*(2**2)
10562 """
10563 ctx = _get_ctx(ctx)
10564 if is_bv(a1) and is_fp_sort(a2):
10565 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10566 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10567 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10568 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10569 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10570 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10571 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10572 else:
10573 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10574
10575

Referenced by fpBVToFP(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), and fpToFP().

◆ fpToFPUnsigned()

def fpToFPUnsigned (   rm,
  x,
  s,
  ctx = None 
)
Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression.

Definition at line 10667 of file z3py.py.

10667def fpToFPUnsigned(rm, x, s, ctx=None):
10668 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10669 if z3_debug():
10670 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10671 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10672 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10673 ctx = _get_ctx(ctx)
10674 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10675
10676
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.

Referenced by fpUnsignedToFP().

◆ fpToIEEEBV()

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

10741def fpToIEEEBV(x, ctx=None):
10742 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10743
10744 The size of the resulting bit-vector is automatically determined.
10745
10746 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10747 knows only one NaN and it will always produce the same bit-vector representation of
10748 that NaN.
10749
10750 >>> x = FP('x', FPSort(8, 24))
10751 >>> y = fpToIEEEBV(x)
10752 >>> print(is_fp(x))
10753 True
10754 >>> print(is_bv(y))
10755 True
10756 >>> print(is_fp(y))
10757 False
10758 >>> print(is_bv(x))
10759 False
10760 """
10761 if z3_debug():
10762 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10763 ctx = _get_ctx(ctx)
10764 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10765
10766
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.

Referenced by fpToFP(), and fpToIEEEBV().

◆ fpToReal()

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

10721def fpToReal(x, ctx=None):
10722 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10723
10724 >>> x = FP('x', FPSort(8, 24))
10725 >>> y = fpToReal(x)
10726 >>> print(is_fp(x))
10727 True
10728 >>> print(is_real(y))
10729 True
10730 >>> print(is_fp(y))
10731 False
10732 >>> print(is_real(x))
10733 False
10734 """
10735 if z3_debug():
10736 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10737 ctx = _get_ctx(ctx)
10738 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10739
10740
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.

Referenced by fpToReal().

◆ fpToSBV()

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

10677def fpToSBV(rm, x, s, ctx=None):
10678 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10679
10680 >>> x = FP('x', FPSort(8, 24))
10681 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10682 >>> print(is_fp(x))
10683 True
10684 >>> print(is_bv(y))
10685 True
10686 >>> print(is_fp(y))
10687 False
10688 >>> print(is_bv(x))
10689 False
10690 """
10691 if z3_debug():
10692 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10693 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10694 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10695 ctx = _get_ctx(ctx)
10696 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10697
10698
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.

Referenced by fpToSBV().

◆ fpToUBV()

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

10699def fpToUBV(rm, x, s, ctx=None):
10700 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10701
10702 >>> x = FP('x', FPSort(8, 24))
10703 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10704 >>> print(is_fp(x))
10705 True
10706 >>> print(is_bv(y))
10707 True
10708 >>> print(is_fp(y))
10709 False
10710 >>> print(is_bv(x))
10711 False
10712 """
10713 if z3_debug():
10714 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10715 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10716 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10717 ctx = _get_ctx(ctx)
10718 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10719
10720
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.

Referenced by fpToUBV().

◆ fpUnsignedToFP()

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

10649def fpUnsignedToFP(rm, v, sort, ctx=None):
10650 """Create a Z3 floating-point conversion expression that represents the
10651 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10652
10653 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10654 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10655 >>> x_fp
10656 fpToFPUnsigned(RNE(), 4294967291)
10657 >>> simplify(x_fp)
10658 1*(2**32)
10659 """
10660 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10661 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10662 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10663 ctx = _get_ctx(ctx)
10664 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10665
10666

Referenced by fpUnsignedToFP().

◆ FPVal()

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

10074def FPVal(sig, exp=None, fps=None, ctx=None):
10075 """Return a floating-point value of value `val` and sort `fps`.
10076 If `ctx=None`, then the global context is used.
10077
10078 >>> v = FPVal(20.0, FPSort(8, 24))
10079 >>> v
10080 1.25*(2**4)
10081 >>> print("0x%.8x" % v.exponent_as_long(False))
10082 0x00000004
10083 >>> v = FPVal(2.25, FPSort(8, 24))
10084 >>> v
10085 1.125*(2**1)
10086 >>> v = FPVal(-2.25, FPSort(8, 24))
10087 >>> v
10088 -1.125*(2**1)
10089 >>> FPVal(-0.0, FPSort(8, 24))
10090 -0.0
10091 >>> FPVal(0.0, FPSort(8, 24))
10092 +0.0
10093 >>> FPVal(+0.0, FPSort(8, 24))
10094 +0.0
10095 """
10096 ctx = _get_ctx(ctx)
10097 if is_fp_sort(exp):
10098 fps = exp
10099 exp = None
10100 elif fps is None:
10101 fps = _dflt_fps(ctx)
10102 _z3_assert(is_fp_sort(fps), "sort mismatch")
10103 if exp is None:
10104 exp = 0
10105 val = _to_float_str(sig)
10106 if val == "NaN" or val == "nan":
10107 return fpNaN(fps)
10108 elif val == "-0.0":
10109 return fpMinusZero(fps)
10110 elif val == "0.0" or val == "+0.0":
10111 return fpPlusZero(fps)
10112 elif val == "+oo" or val == "+inf" or val == "+Inf":
10113 return fpPlusInfinity(fps)
10114 elif val == "-oo" or val == "-inf" or val == "-Inf":
10115 return fpMinusInfinity(fps)
10116 else:
10117 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10118
10119

Referenced by _coerce_fp_expr_list(), FPNumRef.exponent(), fpAbs(), fpFP(), fpFPToFP(), fpToFP(), FPVal(), is_expr(), is_fp_value(), FPNumRef.isNegative(), FPNumRef.sign_as_bv(), FPNumRef.significand(), and FPNumRef.significand_as_bv().

◆ fpZero()

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

Definition at line 10067 of file z3py.py.

10067def fpZero(s, negative):
10068 """Create a Z3 floating-point +0.0 or -0.0 term."""
10069 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10070 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10071 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10072
10073

◆ FreshBool()

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

1767def FreshBool(prefix="b", ctx=None):
1768 """Return a fresh Boolean constant in the given context using the given prefix.
1769
1770 If `ctx=None`, then the global context is used.
1771
1772 >>> b1 = FreshBool()
1773 >>> b2 = FreshBool()
1774 >>> eq(b1, b2)
1775 False
1776 """
1777 ctx = _get_ctx(ctx)
1778 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1779
1780
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.

Referenced by FreshBool().

◆ FreshConst()

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

Definition at line 1460 of file z3py.py.

1460def FreshConst(sort, prefix="c"):
1461 """Create a fresh constant of a specified sort"""
1462 ctx = _get_ctx(sort.ctx)
1463 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1464
1465

◆ FreshFunction()

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

Definition at line 882 of file z3py.py.

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

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

3279def FreshInt(prefix="x", ctx=None):
3280 """Return a fresh integer constant in the given context using the given prefix.
3281
3282 >>> x = FreshInt()
3283 >>> y = FreshInt()
3284 >>> eq(x, y)
3285 False
3286 >>> x.sort()
3287 Int
3288 """
3289 ctx = _get_ctx(ctx)
3290 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3291
3292

Referenced by FreshInt().

◆ FreshReal()

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

3336def FreshReal(prefix="b", ctx=None):
3337 """Return a fresh real constant in the given context using the given prefix.
3338
3339 >>> x = FreshReal()
3340 >>> y = FreshReal()
3341 >>> eq(x, y)
3342 False
3343 >>> x.sort()
3344 Real
3345 """
3346 ctx = _get_ctx(ctx)
3347 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3348
3349

Referenced by FreshReal().

◆ Full()

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

11023def Full(s):
11024 """Create the regular expression that accepts the universal language
11025 >>> e = Full(ReSort(SeqSort(IntSort())))
11026 >>> print(e)
11027 Full(ReSort(Seq(Int)))
11028 >>> e1 = Full(ReSort(StringSort()))
11029 >>> print(e1)
11030 Full(ReSort(String))
11031 """
11032 if isinstance(s, ReSortRef):
11033 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11034 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11035
11036
11037
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.

Referenced by Full().

◆ FullSet()

def FullSet (   s)
Create the full set
>>> FullSet(IntSort())
K(Int, True)

Definition at line 4923 of file z3py.py.

4923def FullSet(s):
4924 """Create the full set
4925 >>> FullSet(IntSort())
4926 K(Int, True)
4927 """
4928 ctx = s.ctx
4929 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4930
4931
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.

Referenced by FullSet().

◆ Function()

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

859def Function(name, *sig):
860 """Create a new Z3 uninterpreted function with the given sorts.
861
862 >>> f = Function('f', IntSort(), IntSort())
863 >>> f(f(0))
864 f(f(0))
865 """
866 sig = _get_args(sig)
867 if z3_debug():
868 _z3_assert(len(sig) > 0, "At least two arguments expected")
869 arity = len(sig) - 1
870 rng = sig[arity]
871 if z3_debug():
872 _z3_assert(is_sort(rng), "Z3 sort expected")
873 dom = (Sort * arity)()
874 for i in range(arity):
875 if z3_debug():
876 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
877 dom[i] = sig[i].ast
878 ctx = rng.ctx
879 return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
880
881
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.

Referenced by FuncDeclRef.__call__(), ModelRef.__getitem__(), ModelRef.__len__(), ExprRef.arg(), FuncEntry.arg_value(), FuncDeclRef.arity(), FuncInterp.arity(), FuncEntry.as_list(), FuncInterp.as_list(), QuantifierRef.body(), BoolSort(), ExprRef.children(), QuantifierRef.children(), ExprRef.decl(), ModelRef.decls(), FuncDeclRef.domain(), FuncInterp.else_value(), FuncInterp.entry(), Exists(), ForAll(), Function(), ModelRef.get_interp(), get_map_func(), get_var_index(), is_ast(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), is_func_decl(), QuantifierRef.is_lambda(), is_map(), is_pattern(), is_quantifier(), is_var(), Lambda(), Map(), MultiPattern(), FuncDeclRef.name(), ExprRef.num_args(), FuncEntry.num_args(), FuncInterp.num_entries(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), parse_smt2_string(), QuantifierRef.pattern(), FuncDeclRef.range(), substitute(), substitute_vars(), FuncEntry.value(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

◆ get_as_array_func()

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

Definition at line 6691 of file z3py.py.

6691def get_as_array_func(n):
6692 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6693 if z3_debug():
6694 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6695 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6696
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()

def get_ctx (   ctx)

Definition at line 267 of file z3py.py.

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

◆ get_default_fp_sort()

def get_default_fp_sort (   ctx = None)

Definition at line 9371 of file z3py.py.

9371def get_default_fp_sort(ctx=None):
9372 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9373
9374

Referenced by _dflt_fps().

◆ get_default_rounding_mode()

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

Definition at line 9338 of file z3py.py.

9338def get_default_rounding_mode(ctx=None):
9339 """Retrieves the global default rounding mode."""
9340 global _dflt_rounding_mode
9341 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9342 return RTZ(ctx)
9343 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9344 return RTN(ctx)
9345 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9346 return RTP(ctx)
9347 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9348 return RNE(ctx)
9349 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9350 return RNA(ctx)
9351
9352

Referenced by _dflt_rm().

◆ get_full_version()

def get_full_version ( )

Definition at line 101 of file z3py.py.

101def get_full_version():
102 return Z3_get_full_version()
103
104
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.

◆ get_map_func()

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

4668def get_map_func(a):
4669 """Return the function declaration associated with a Z3 map array expression.
4670
4671 >>> f = Function('f', IntSort(), IntSort())
4672 >>> b = Array('b', IntSort(), IntSort())
4673 >>> a = Map(f, b)
4674 >>> eq(f, get_map_func(a))
4675 True
4676 >>> get_map_func(a)
4677 f
4678 >>> get_map_func(a)(0)
4679 f(0)
4680 """
4681 if z3_debug():
4682 _z3_assert(is_map(a), "Z3 array map expression expected.")
4683 return FuncDeclRef(
4685 a.ctx_ref(),
4686 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4687 ),
4688 ctx=a.ctx,
4689 )
4690
4691
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.

Referenced by get_map_func().

◆ get_param()

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

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

Definition at line 307 of file z3py.py.

307def get_param(name):
308 """Return the value of a Z3 global (or module) parameter
309
310 >>> get_param('nlsat.reorder')
311 'true'
312 """
313 ptr = (ctypes.c_char_p * 1)()
314 if Z3_global_param_get(str(name), ptr):
315 r = z3core._to_pystr(ptr[0])
316 return r
317 raise Z3Exception("failed to retrieve value for '%s'" % name)
318
bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.

Referenced by get_param().

◆ get_var_index()

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

1331def get_var_index(a):
1332 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1333
1334 >>> x = Int('x')
1335 >>> y = Int('y')
1336 >>> is_var(x)
1337 False
1338 >>> is_const(x)
1339 True
1340 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1341 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1342 >>> q = ForAll([x, y], f(x, y) == x + y)
1343 >>> q.body()
1344 f(Var(1), Var(0)) == Var(1) + Var(0)
1345 >>> b = q.body()
1346 >>> b.arg(0)
1347 f(Var(1), Var(0))
1348 >>> v1 = b.arg(0).arg(0)
1349 >>> v2 = b.arg(0).arg(1)
1350 >>> v1
1351 Var(1)
1352 >>> v2
1353 Var(0)
1354 >>> get_var_index(v1)
1355 1
1356 >>> get_var_index(v2)
1357 0
1358 """
1359 if z3_debug():
1360 _z3_assert(is_var(a), "Z3 bound variable expected")
1361 return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1362
1363
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.

Referenced by get_var_index().

◆ get_version()

def get_version ( )

Definition at line 92 of file z3py.py.

92def get_version():
93 major = ctypes.c_uint(0)
94 minor = ctypes.c_uint(0)
95 build = ctypes.c_uint(0)
96 rev = ctypes.c_uint(0)
97 Z3_get_version(major, minor, build, rev)
98 return (major.value, minor.value, build.value, rev.value)
99
100
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.

◆ get_version_string()

def get_version_string ( )

Definition at line 83 of file z3py.py.

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

◆ help_simplify()

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

Definition at line 8844 of file z3py.py.

8844def help_simplify():
8845 """Return a string describing all options available for Z3 `simplify` procedure."""
8846 print(Z3_simplify_get_help(main_ctx().ref()))
8847
8848
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.

◆ If()

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

1377def If(a, b, c, ctx=None):
1378 """Create a Z3 if-then-else expression.
1379
1380 >>> x = Int('x')
1381 >>> y = Int('y')
1382 >>> max = If(x > y, x, y)
1383 >>> max
1384 If(x > y, x, y)
1385 >>> simplify(max)
1386 If(x <= y, y, x)
1387 """
1388 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1389 return Cond(a, b, c, ctx)
1390 else:
1391 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1392 s = BoolSort(ctx)
1393 a = s.cast(a)
1394 b, c = _coerce_exprs(b, c, ctx)
1395 if z3_debug():
1396 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1397 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1398
1399
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.__mul__(), ArithRef.__mul__(), Abs(), BV2Int(), If(), Lambda(), and RecAddDefinition().

◆ Implies()

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

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

Definition at line 1781 of file z3py.py.

1781def Implies(a, b, ctx=None):
1782 """Create a Z3 implies expression.
1783
1784 >>> p, q = Bools('p q')
1785 >>> Implies(p, q)
1786 Implies(p, q)
1787 """
1788 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1789 s = BoolSort(ctx)
1790 a = s.cast(a)
1791 b = s.cast(b)
1792 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1793
1794
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.

Referenced by Fixedpoint.add_rule(), Solver.consequences(), Implies(), is_implies(), Store(), Solver.unsat_core(), Update(), and Fixedpoint.update_rule().

◆ IndexOf()

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

11107def IndexOf(s, substr, offset=None):
11108 """Retrieve the index of substring within a string starting at a specified offset.
11109 >>> simplify(IndexOf("abcabc", "bc", 0))
11110 1
11111 >>> simplify(IndexOf("abcabc", "bc", 2))
11112 4
11113 """
11114 if offset is None:
11115 offset = IntVal(0)
11116 ctx = None
11117 if is_expr(offset):
11118 ctx = offset.ctx
11119 ctx = _get_ctx2(s, substr, ctx)
11120 s = _coerce_seq(s, ctx)
11121 substr = _coerce_seq(substr, ctx)
11122 if _is_int(offset):
11123 offset = IntVal(offset, ctx)
11124 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11125
11126
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...

Referenced by IndexOf().

◆ InRe()

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

11220def InRe(s, re):
11221 """Create regular expression membership test
11222 >>> re = Union(Re("a"),Re("b"))
11223 >>> print (simplify(InRe("a", re)))
11224 True
11225 >>> print (simplify(InRe("b", re)))
11226 True
11227 >>> print (simplify(InRe("c", re)))
11228 False
11229 """
11230 s = _coerce_seq(s, re.ctx)
11231 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11232
11233
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.

Referenced by InRe(), Loop(), Option(), Plus(), Range(), Star(), and Union().

◆ Int()

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

3240def Int(name, ctx=None):
3241 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3242
3243 >>> x = Int('x')
3244 >>> is_int(x)
3245 True
3246 >>> is_int(x + 1)
3247 True
3248 """
3249 ctx = _get_ctx(ctx)
3250 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3251
3252

Referenced by ArithRef.__add__(), FuncDeclRef.__call__(), Probe.__call__(), AstVector.__contains__(), AstMap.__contains__(), ArithRef.__div__(), ExprRef.__eq__(), Probe.__eq__(), Probe.__ge__(), Statistics.__getattr__(), ArrayRef.__getitem__(), AstVector.__getitem__(), ModelRef.__getitem__(), Statistics.__getitem__(), AstMap.__getitem__(), Probe.__gt__(), Probe.__le__(), AstVector.__len__(), AstMap.__len__(), ModelRef.__len__(), Statistics.__len__(), Probe.__lt__(), ArithRef.__mod__(), ExprRef.__ne__(), Probe.__ne__(), ArithRef.__neg__(), ArithRef.__pos__(), ArithRef.__radd__(), ArithRef.__rdiv__(), ArithRef.__rmod__(), ArithRef.__rsub__(), AstVector.__setitem__(), AstMap.__setitem__(), ArithRef.__sub__(), Goal.add(), Solver.add(), Goal.append(), Solver.append(), ExprRef.arg(), Goal.as_expr(), ApplyResult.as_expr(), Solver.assert_and_track(), Optimize.assert_and_track(), Goal.assert_exprs(), Solver.assert_exprs(), Solver.assertions(), QuantifierRef.body(), BV2Int(), SortRef.cast(), Solver.check(), ExprRef.children(), QuantifierRef.children(), ExprRef.decl(), ModelRef.decls(), Distinct(), eq(), AstRef.eq(), AstMap.erase(), ModelRef.eval(), ModelRef.evaluate(), Exists(), ForAll(), ModelRef.get_interp(), Statistics.get_key_value(), get_var_index(), AstRef.hash(), If(), Goal.insert(), Solver.insert(), Int(), Ints(), IntVector(), is_app(), is_app_of(), is_arith(), is_arith_sort(), is_ast(), is_bv(), is_const(), QuantifierRef.is_exists(), is_expr(), is_finite_domain(), QuantifierRef.is_forall(), is_fp(), is_int(), ArithSortRef.is_int(), ArithRef.is_int(), is_int_value(), QuantifierRef.is_lambda(), is_pattern(), is_probe(), is_quantifier(), is_real(), ArithSortRef.is_real(), is_select(), is_sort(), is_to_real(), is_var(), K(), AstMap.keys(), Statistics.keys(), FuncDeclRef.kind(), Solver.model(), MultiPattern(), ExprRef.num_args(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), OrElse(), ParOr(), QuantifierRef.pattern(), Solver.pop(), Solver.push(), AstVector.push(), Solver.reason_unknown(), RecAddDefinition(), AstMap.reset(), Solver.reset(), AstVector.resize(), Select(), AstRef.sexpr(), Solver.sexpr(), SimpleSolver(), simplify(), Goal.simplify(), solve(), SolverFor(), ExprRef.sort(), ArithRef.sort(), Solver.statistics(), Store(), substitute(), substitute_vars(), ToReal(), AstVector.translate(), AstRef.translate(), Goal.translate(), Update(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

◆ Int2BV()

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

3988def Int2BV(a, num_bits):
3989 """Return the z3 expression Int2BV(a, num_bits).
3990 It is a bit-vector of width num_bits and represents the
3991 modulo of a by 2^num_bits
3992 """
3993 ctx = a.ctx
3994 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3995
3996
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()

def Intersect ( args)
Create intersection of regular expressions.
>>> re = Intersect(Re("a"), Re("b"), Re("c"))

Definition at line 11254 of file z3py.py.

11254def Intersect(*args):
11255 """Create intersection of regular expressions.
11256 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11257 """
11258 args = _get_args(args)
11259 sz = len(args)
11260 if z3_debug():
11261 _z3_assert(sz > 0, "At least one argument expected.")
11262 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11263 if sz == 1:
11264 return args[0]
11265 ctx = args[0].ctx
11266 v = (Ast * sz)()
11267 for i in range(sz):
11268 v[i] = args[i].as_ast()
11269 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11270
11271
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.

Referenced by Intersect().

◆ Ints()

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

3253def Ints(names, ctx=None):
3254 """Return a tuple of Integer constants.
3255
3256 >>> x, y, z = Ints('x y z')
3257 >>> Sum(x, y, z)
3258 x + y + z
3259 """
3260 ctx = _get_ctx(ctx)
3261 if isinstance(names, str):
3262 names = names.split(" ")
3263 return [Int(name, ctx) for name in names]
3264
3265

Referenced by Tactic.__call__(), ArithRef.__ge__(), Goal.__getitem__(), ApplyResult.__getitem__(), ArithRef.__gt__(), ArithRef.__le__(), Goal.__len__(), ApplyResult.__len__(), ArithRef.__lt__(), AndThen(), Tactic.apply(), Goal.convert_model(), Goal.depth(), FailIf(), Goal.get(), Goal.inconsistent(), Ints(), is_add(), is_distinct(), is_div(), is_eq(), is_ge(), is_gt(), is_idiv(), is_le(), is_lt(), is_mod(), is_mul(), is_sub(), Lambda(), parse_smt2_string(), ParThen(), Goal.prec(), Product(), Repeat(), Goal.size(), Store(), Sum(), Then(), Solver.unsat_core(), Update(), When(), With(), and WithParams().

◆ IntSort()

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

3134def IntSort(ctx=None):
3135 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3136
3137 >>> IntSort()
3138 Int
3139 >>> x = Const('x', IntSort())
3140 >>> is_int(x)
3141 True
3142 >>> x.sort() == IntSort()
3143 True
3144 >>> x.sort() == BoolSort()
3145 False
3146 """
3147 ctx = _get_ctx(ctx)
3148 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3149
3150
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.

Referenced by FuncDeclRef.__call__(), SortRef.__eq__(), ArrayRef.__getitem__(), ModelRef.__getitem__(), ModelRef.__len__(), SortRef.__ne__(), DatatypeSortRef.accessor(), ExprRef.arg(), FuncEntry.arg_value(), FuncDeclRef.arity(), FuncInterp.arity(), Array(), ArraySort(), FuncEntry.as_list(), FuncInterp.as_list(), QuantifierRef.body(), BoolSort(), ArithSortRef.cast(), ExprRef.children(), QuantifierRef.children(), Const(), DatatypeSortRef.constructor(), Consts(), Datatype.create(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), ModelRef.decls(), Default(), DisjointSum(), ArraySortRef.domain(), ArrayRef.domain(), FuncDeclRef.domain(), FuncInterp.else_value(), Empty(), EmptySet(), FuncInterp.entry(), Exists(), Ext(), ForAll(), FreshInt(), Full(), FullSet(), Function(), ModelRef.get_interp(), get_map_func(), get_var_index(), Int(), IntSort(), IntVal(), is_app(), is_arith_sort(), is_array(), is_ast(), is_bv_sort(), is_const_array(), is_default(), QuantifierRef.is_exists(), is_expr(), is_finite_domain_sort(), QuantifierRef.is_forall(), is_func_decl(), is_K(), QuantifierRef.is_lambda(), is_map(), is_pattern(), is_quantifier(), is_select(), is_sort(), is_store(), SeqSortRef.is_string(), is_var(), IsMember(), IsSubset(), K(), SortRef.kind(), Lambda(), Map(), MultiPattern(), SortRef.name(), FuncDeclRef.name(), ExprRef.num_args(), FuncEntry.num_args(), DatatypeSortRef.num_constructors(), FuncInterp.num_entries(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), parse_smt2_string(), QuantifierRef.pattern(), FuncDeclRef.range(), ArraySortRef.range(), ArrayRef.range(), RecAddDefinition(), DatatypeSortRef.recognizer(), Select(), SeqSort(), SetAdd(), SetComplement(), SetDel(), SetDifference(), SetIntersect(), SetUnion(), ArrayRef.sort(), ExprRef.sort_kind(), Store(), SortRef.subsort(), substitute(), substitute_vars(), TupleSort(), Update(), FuncEntry.value(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

◆ IntToStr()

def IntToStr (   s)
Convert integer expression to string

Definition at line 11162 of file z3py.py.

11162def IntToStr(s):
11163 """Convert integer expression to string"""
11164 if not is_expr(s):
11165 s = _py2expr(s)
11166 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11167
11168
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.

Referenced by StrToInt().

◆ IntVal()

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

3180def IntVal(val, ctx=None):
3181 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3182
3183 >>> IntVal(1)
3184 1
3185 >>> IntVal("100")
3186 100
3187 """
3188 ctx = _get_ctx(ctx)
3189 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3190
3191

Referenced by SeqRef.__getitem__(), AstMap.__len__(), ArithRef.__mod__(), BoolRef.__mul__(), ArithRef.__pow__(), ArithRef.__rpow__(), AstMap.__setitem__(), _py2expr(), IntNumRef.as_binary_string(), IntNumRef.as_long(), IntNumRef.as_string(), SeqRef.at(), IndexOf(), IntVal(), is_app(), is_arith(), is_ast(), is_const(), is_expr(), is_int(), is_int_value(), is_rational_value(), is_seq(), AstMap.keys(), AstMap.reset(), SeqSort(), and substitute().

◆ IntVector()

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

3266def IntVector(prefix, sz, ctx=None):
3267 """Return a list of integer constants of size `sz`.
3268
3269 >>> X = IntVector('x', 3)
3270 >>> X
3271 [x__0, x__1, x__2]
3272 >>> Sum(X)
3273 x__0 + x__1 + x__2
3274 """
3275 ctx = _get_ctx(ctx)
3276 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3277
3278

Referenced by IntVector(), Product(), and Sum().

◆ is_add()

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

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

Definition at line 2788 of file z3py.py.

2788def is_add(a):
2789 """Return `True` if `a` is an expression of the form b + c.
2790
2791 >>> x, y = Ints('x y')
2792 >>> is_add(x + y)
2793 True
2794 >>> is_add(x - y)
2795 False
2796 """
2797 return is_app_of(a, Z3_OP_ADD)
2798
2799

Referenced by is_add().

◆ is_algebraic_value()

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

2774def is_algebraic_value(a):
2775 """Return `True` if `a` is an algebraic value of sort Real.
2776
2777 >>> is_algebraic_value(RealVal("3/5"))
2778 False
2779 >>> n = simplify(Sqrt(2))
2780 >>> n
2781 1.4142135623?
2782 >>> is_algebraic_value(n)
2783 True
2784 """
2785 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2786
2787

Referenced by is_algebraic_value().

◆ is_and()

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

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

Definition at line 1617 of file z3py.py.

1617def is_and(a):
1618 """Return `True` if `a` is a Z3 and expression.
1619
1620 >>> p, q = Bools('p q')
1621 >>> is_and(And(p, q))
1622 True
1623 >>> is_and(Or(p, q))
1624 False
1625 """
1626 return is_app_of(a, Z3_OP_AND)
1627
1628

Referenced by is_and().

◆ is_app()

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

1261def is_app(a):
1262 """Return `True` if `a` is a Z3 function application.
1263
1264 Note that, constants are function applications with 0 arguments.
1265
1266 >>> a = Int('a')
1267 >>> is_app(a)
1268 True
1269 >>> is_app(a + 1)
1270 True
1271 >>> is_app(IntSort())
1272 False
1273 >>> is_app(1)
1274 False
1275 >>> is_app(IntVal(1))
1276 True
1277 >>> x = Int('x')
1278 >>> is_app(ForAll(x, x >= 0))
1279 False
1280 """
1281 if not isinstance(a, ExprRef):
1282 return False
1283 k = _ast_kind(a.ctx, a)
1284 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1285
1286

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

◆ is_app_of()

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

1364def is_app_of(a, k):
1365 """Return `True` if `a` is an application of the given kind `k`.
1366
1367 >>> x = Int('x')
1368 >>> n = x + 1
1369 >>> is_app_of(n, Z3_OP_ADD)
1370 True
1371 >>> is_app_of(n, Z3_OP_MUL)
1372 False
1373 """
1374 return is_app(a) and a.decl().kind() == k
1375
1376

Referenced by is_add(), is_and(), is_app_of(), 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()

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

2661def is_arith(a):
2662 """Return `True` if `a` is an arithmetical expression.
2663
2664 >>> x = Int('x')
2665 >>> is_arith(x)
2666 True
2667 >>> is_arith(x + 1)
2668 True
2669 >>> is_arith(1)
2670 False
2671 >>> is_arith(IntVal(1))
2672 True
2673 >>> y = Real('y')
2674 >>> is_arith(y)
2675 True
2676 >>> is_arith(y + 1)
2677 True
2678 """
2679 return isinstance(a, ArithRef)
2680
2681

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

◆ is_arith_sort()

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

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

Definition at line 2360 of file z3py.py.

2360def is_arith_sort(s):
2361 """Return `True` if s is an arithmetical sort (type).
2362
2363 >>> is_arith_sort(IntSort())
2364 True
2365 >>> is_arith_sort(RealSort())
2366 True
2367 >>> is_arith_sort(BoolSort())
2368 False
2369 >>> n = Int('x') + 1
2370 >>> is_arith_sort(n.sort())
2371 True
2372 """
2373 return isinstance(s, ArithSortRef)
2374
2375

Referenced by is_arith_sort(), and ArithSortRef.subsort().

◆ is_array()

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

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

Definition at line 4603 of file z3py.py.

4603def is_array(a):
4604 """Return `True` if `a` is a Z3 array expression.
4605
4606 >>> a = Array('a', IntSort(), IntSort())
4607 >>> is_array(a)
4608 True
4609 >>> is_array(Store(a, 0, 1))
4610 True
4611 >>> is_array(a[0])
4612 False
4613 """
4614 return isinstance(a, ArrayRef)
4615
4616

Referenced by Ext(), is_array(), and Map().

◆ is_array_sort()

def is_array_sort (   a)

Definition at line 4599 of file z3py.py.

4599def is_array_sort(a):
4600 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4601
4602

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

◆ is_as_array()

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

Definition at line 6686 of file z3py.py.

6686def is_as_array(n):
6687 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6688 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6689
6690
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()

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

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

Definition at line 451 of file z3py.py.

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

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

◆ is_bool()

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

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

Definition at line 1567 of file z3py.py.

1567def is_bool(a):
1568 """Return `True` if `a` is a Z3 Boolean expression.
1569
1570 >>> p = Bool('p')
1571 >>> is_bool(p)
1572 True
1573 >>> q = Bool('q')
1574 >>> is_bool(And(p, q))
1575 True
1576 >>> x = Real('x')
1577 >>> is_bool(x)
1578 False
1579 >>> is_bool(x == 0)
1580 True
1581 """
1582 return isinstance(a, BoolRef)
1583
1584

Referenced by _mk_quantifier(), _prove_html(), BoolSort(), is_bool(), and prove().

◆ is_bv()

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

3936def is_bv(a):
3937 """Return `True` if `a` is a Z3 bit-vector expression.
3938
3939 >>> b = BitVec('b', 32)
3940 >>> is_bv(b)
3941 True
3942 >>> is_bv(b + 10)
3943 True
3944 >>> is_bv(Int('x'))
3945 False
3946 """
3947 return isinstance(a, BitVecRef)
3948
3949

Referenced by _check_bv_args(), BitVec(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), Concat(), Extract(), fpBVToFP(), fpFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpToIEEEBV(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), is_bv(), is_bv_value(), Product(), RepeatBitVec(), SignExt(), Sum(), and ZeroExt().

◆ is_bv_sort()

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

3468def is_bv_sort(s):
3469 """Return True if `s` is a Z3 bit-vector sort.
3470
3471 >>> is_bv_sort(BitVecSort(32))
3472 True
3473 >>> is_bv_sort(IntSort())
3474 False
3475 """
3476 return isinstance(s, BitVecSortRef)
3477
3478

Referenced by BitVecVal(), fpToSBV(), fpToUBV(), is_bv_sort(), and BitVecSortRef.subsort().

◆ is_bv_value()

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

3950def is_bv_value(a):
3951 """Return `True` if `a` is a Z3 bit-vector numeral value.
3952
3953 >>> b = BitVec('b', 32)
3954 >>> is_bv_value(b)
3955 False
3956 >>> b = BitVecVal(10, 32)
3957 >>> b
3958 10
3959 >>> is_bv_value(b)
3960 True
3961 """
3962 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3963
3964

Referenced by is_bv_value().

◆ is_const()

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

1287def is_const(a):
1288 """Return `True` if `a` is Z3 constant/variable expression.
1289
1290 >>> a = Int('a')
1291 >>> is_const(a)
1292 True
1293 >>> is_const(a + 1)
1294 False
1295 >>> is_const(1)
1296 False
1297 >>> is_const(IntVal(1))
1298 True
1299 >>> x = Int('x')
1300 >>> is_const(ForAll(x, x >= 0))
1301 False
1302 """
1303 return is_app(a) and a.num_args() == 0
1304
1305

Referenced by ModelRef.__getitem__(), _dict2darray(), _mk_quantifier(), Solver.assert_and_track(), Optimize.assert_and_track(), ModelRef.get_interp(), get_var_index(), is_const(), and is_var().

◆ is_const_array()

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

4617def is_const_array(a):
4618 """Return `True` if `a` is a Z3 constant array.
4619
4620 >>> a = K(IntSort(), 10)
4621 >>> is_const_array(a)
4622 True
4623 >>> a = Array('a', IntSort(), IntSort())
4624 >>> is_const_array(a)
4625 False
4626 """
4627 return is_app_of(a, Z3_OP_CONST_ARRAY)
4628
4629

Referenced by is_const_array().

◆ is_default()

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

4659def is_default(a):
4660 """Return `True` if `a` is a Z3 default array expression.
4661 >>> d = Default(K(IntSort(), 10))
4662 >>> is_default(d)
4663 True
4664 """
4665 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4666
4667

Referenced by is_default().

◆ is_distinct()

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

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

Definition at line 1675 of file z3py.py.

1675def is_distinct(a):
1676 """Return `True` if `a` is a Z3 distinct expression.
1677
1678 >>> x, y, z = Ints('x y z')
1679 >>> is_distinct(x == y)
1680 False
1681 >>> is_distinct(Distinct(x, y, z))
1682 True
1683 """
1684 return is_app_of(a, Z3_OP_DISTINCT)
1685
1686

Referenced by is_distinct().

◆ is_div()

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

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

Definition at line 2824 of file z3py.py.

2824def is_div(a):
2825 """Return `True` if `a` is an expression of the form b / c.
2826
2827 >>> x, y = Reals('x y')
2828 >>> is_div(x / y)
2829 True
2830 >>> is_div(x + y)
2831 False
2832 >>> x, y = Ints('x y')
2833 >>> is_div(x / y)
2834 False
2835 >>> is_idiv(x / y)
2836 True
2837 """
2838 return is_app_of(a, Z3_OP_DIV)
2839
2840

Referenced by is_div().

◆ is_eq()

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

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

Definition at line 1665 of file z3py.py.

1665def is_eq(a):
1666 """Return `True` if `a` is a Z3 equality expression.
1667
1668 >>> x, y = Ints('x y')
1669 >>> is_eq(x == y)
1670 True
1671 """
1672 return is_app_of(a, Z3_OP_EQ)
1673
1674

Referenced by AstRef.__bool__(), and is_eq().

◆ is_expr()

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

1238def is_expr(a):
1239 """Return `True` if `a` is a Z3 expression.
1240
1241 >>> a = Int('a')
1242 >>> is_expr(a)
1243 True
1244 >>> is_expr(a + 1)
1245 True
1246 >>> is_expr(IntSort())
1247 False
1248 >>> is_expr(1)
1249 False
1250 >>> is_expr(IntVal(1))
1251 True
1252 >>> x = Int('x')
1253 >>> is_expr(ForAll(x, x >= 0))
1254 True
1255 >>> is_expr(FPVal(1.0))
1256 True
1257 """
1258 return isinstance(a, ExprRef)
1259
1260

Referenced by _coerce_char(), _coerce_expr_list(), _coerce_expr_merge(), _coerce_exprs(), _coerce_seq(), _get_ctx2(), _mk_quantifier(), _py2expr(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), Cbrt(), CharFromBv(), Concat(), IndexOf(), IntToStr(), is_expr(), is_sort(), is_var(), K(), MultiPattern(), Replace(), simplify(), Sqrt(), StrFromCode(), StrToCode(), substitute(), substitute_funs(), substitute_vars(), and ModelRef.update_value().

◆ is_false()

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

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

Definition at line 1603 of file z3py.py.

1603def is_false(a):
1604 """Return `True` if `a` is the Z3 false expression.
1605
1606 >>> p = Bool('p')
1607 >>> is_false(p)
1608 False
1609 >>> is_false(False)
1610 False
1611 >>> is_false(BoolVal(False))
1612 True
1613 """
1614 return is_app_of(a, Z3_OP_FALSE)
1615
1616

Referenced by AstRef.__bool__(), BoolVal(), and is_false().

◆ is_finite_domain()

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

7739def is_finite_domain(a):
7740 """Return `True` if `a` is a Z3 finite-domain expression.
7741
7742 >>> s = FiniteDomainSort('S', 100)
7743 >>> b = Const('b', s)
7744 >>> is_finite_domain(b)
7745 True
7746 >>> is_finite_domain(Int('x'))
7747 False
7748 """
7749 return isinstance(a, FiniteDomainRef)
7750
7751

Referenced by is_finite_domain(), and is_finite_domain_value().

◆ is_finite_domain_sort()

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

7716def is_finite_domain_sort(s):
7717 """Return True if `s` is a Z3 finite-domain sort.
7718
7719 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7720 True
7721 >>> is_finite_domain_sort(IntSort())
7722 False
7723 """
7724 return isinstance(s, FiniteDomainSortRef)
7725
7726

Referenced by FiniteDomainVal(), and is_finite_domain_sort().

◆ is_finite_domain_value()

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

7793def is_finite_domain_value(a):
7794 """Return `True` if `a` is a Z3 finite-domain value.
7795
7796 >>> s = FiniteDomainSort('S', 100)
7797 >>> b = Const('b', s)
7798 >>> is_finite_domain_value(b)
7799 False
7800 >>> b = FiniteDomainVal(10, s)
7801 >>> b
7802 10
7803 >>> is_finite_domain_value(b)
7804 True
7805 """
7806 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7807
7808

Referenced by is_finite_domain_value().

◆ is_fp()

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

9920def is_fp(a):
9921 """Return `True` if `a` is a Z3 floating-point expression.
9922
9923 >>> b = FP('b', FPSort(8, 24))
9924 >>> is_fp(b)
9925 True
9926 >>> is_fp(b + 1.0)
9927 True
9928 >>> is_fp(Int('x'))
9929 False
9930 """
9931 return isinstance(a, FPRef)
9932
9933

Referenced by _check_fp_args(), _coerce_fp_expr_list(), _mk_fp_bin(), _mk_fp_bin_norm(), _mk_fp_bin_pred(), _mk_fp_tern(), _mk_fp_unary(), _mk_fp_unary_pred(), FP(), fpFPToFP(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), is_fp(), and is_fp_value().

◆ is_fp_sort()

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

9504def is_fp_sort(s):
9505 """Return True if `s` is a Z3 floating-point sort.
9506
9507 >>> is_fp_sort(FPSort(8, 24))
9508 True
9509 >>> is_fp_sort(IntSort())
9510 False
9511 """
9512 return isinstance(s, FPSortRef)
9513
9514

Referenced by fpBVToFP(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpUnsignedToFP(), and FPVal().

◆ is_fp_value()

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

9934def is_fp_value(a):
9935 """Return `True` if `a` is a Z3 floating-point numeral value.
9936
9937 >>> b = FP('b', FPSort(8, 24))
9938 >>> is_fp_value(b)
9939 False
9940 >>> b = FPVal(1.0, FPSort(8, 24))
9941 >>> b
9942 1
9943 >>> is_fp_value(b)
9944 True
9945 """
9946 return is_fp(a) and _is_numeral(a.ctx, a.ast)
9947
9948

Referenced by is_fp_value().

◆ is_fprm()

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

9764def is_fprm(a):
9765 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9766
9767 >>> rm = RNE()
9768 >>> is_fprm(rm)
9769 True
9770 >>> rm = 1.0
9771 >>> is_fprm(rm)
9772 False
9773 """
9774 return isinstance(a, FPRMRef)
9775
9776

Referenced by _mk_fp_bin(), _mk_fp_tern(), _mk_fp_unary(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), is_fprm(), and is_fprm_value().

◆ is_fprm_sort()

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

9515def is_fprm_sort(s):
9516 """Return True if `s` is a Z3 floating-point rounding mode sort.
9517
9518 >>> is_fprm_sort(FPSort(8, 24))
9519 False
9520 >>> is_fprm_sort(RNE().sort())
9521 True
9522 """
9523 return isinstance(s, FPRMSortRef)
9524
9525# FP Expressions
9526
9527

Referenced by is_fprm_sort().

◆ is_fprm_value()

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

Definition at line 9777 of file z3py.py.

9777def is_fprm_value(a):
9778 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9779 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9780
9781# FP Numerals
9782
9783

Referenced by set_default_rounding_mode().

◆ is_func_decl()

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

846def is_func_decl(a):
847 """Return `True` if `a` is a Z3 function declaration.
848
849 >>> f = Function('f', IntSort(), IntSort())
850 >>> is_func_decl(f)
851 True
852 >>> x = Real('x')
853 >>> is_func_decl(x)
854 False
855 """
856 return isinstance(a, FuncDeclRef)
857
858

Referenced by _dict2darray(), is_func_decl(), Map(), substitute_funs(), and ModelRef.update_value().

◆ is_ge()

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

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

Definition at line 2889 of file z3py.py.

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

Referenced by is_ge().

◆ is_gt()

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

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

Definition at line 2901 of file z3py.py.

2901def is_gt(a):
2902 """Return `True` if `a` is an expression of the form b > c.
2903
2904 >>> x, y = Ints('x y')
2905 >>> is_gt(x > y)
2906 True
2907 >>> is_gt(x == y)
2908 False
2909 """
2910 return is_app_of(a, Z3_OP_GT)
2911
2912

Referenced by is_gt().

◆ is_idiv()

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

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

Definition at line 2841 of file z3py.py.

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

Referenced by is_div(), and is_idiv().

◆ is_implies()

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

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

Definition at line 1641 of file z3py.py.

1641def is_implies(a):
1642 """Return `True` if `a` is a Z3 implication expression.
1643
1644 >>> p, q = Bools('p q')
1645 >>> is_implies(Implies(p, q))
1646 True
1647 >>> is_implies(And(p, q))
1648 False
1649 """
1650 return is_app_of(a, Z3_OP_IMPLIES)
1651
1652

Referenced by is_implies().

◆ is_int()

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

2682def is_int(a):
2683 """Return `True` if `a` is an integer expression.
2684
2685 >>> x = Int('x')
2686 >>> is_int(x + 1)
2687 True
2688 >>> is_int(1)
2689 False
2690 >>> is_int(IntVal(1))
2691 True
2692 >>> y = Real('y')
2693 >>> is_int(y)
2694 False
2695 >>> is_int(y + 1)
2696 False
2697 """
2698 return is_arith(a) and a.is_int()
2699
2700

Referenced by Int(), IntSort(), is_int(), and RealSort().

◆ is_int_value()

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

2728def is_int_value(a):
2729 """Return `True` if `a` is an integer value of sort Int.
2730
2731 >>> is_int_value(IntVal(1))
2732 True
2733 >>> is_int_value(1)
2734 False
2735 >>> is_int_value(Int('x'))
2736 False
2737 >>> n = Int('x') + 1
2738 >>> n
2739 x + 1
2740 >>> n.arg(1)
2741 1
2742 >>> is_int_value(n.arg(1))
2743 True
2744 >>> is_int_value(RealVal("1/3"))
2745 False
2746 >>> is_int_value(RealVal(1))
2747 False
2748 """
2749 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2750
2751

Referenced by is_int_value().

◆ is_is_int()

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

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

Definition at line 2913 of file z3py.py.

2913def is_is_int(a):
2914 """Return `True` if `a` is an expression of the form IsInt(b).
2915
2916 >>> x = Real('x')
2917 >>> is_is_int(IsInt(x))
2918 True
2919 >>> is_is_int(x)
2920 False
2921 """
2922 return is_app_of(a, Z3_OP_IS_INT)
2923
2924

Referenced by is_is_int().

◆ is_K()

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

4630def is_K(a):
4631 """Return `True` if `a` is a Z3 constant array.
4632
4633 >>> a = K(IntSort(), 10)
4634 >>> is_K(a)
4635 True
4636 >>> a = Array('a', IntSort(), IntSort())
4637 >>> is_K(a)
4638 False
4639 """
4640 return is_app_of(a, Z3_OP_CONST_ARRAY)
4641
4642

Referenced by is_K().

◆ is_le()

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

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

Definition at line 2865 of file z3py.py.

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

Referenced by is_le().

◆ is_lt()

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

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

Definition at line 2877 of file z3py.py.

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

Referenced by is_lt().

◆ is_map()

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

4643def is_map(a):
4644 """Return `True` if `a` is a Z3 map array expression.
4645
4646 >>> f = Function('f', IntSort(), IntSort())
4647 >>> b = Array('b', IntSort(), IntSort())
4648 >>> a = Map(f, b)
4649 >>> a
4650 Map(f, b)
4651 >>> is_map(a)
4652 True
4653 >>> is_map(b)
4654 False
4655 """
4656 return is_app_of(a, Z3_OP_ARRAY_MAP)
4657
4658

Referenced by get_map_func(), and is_map().

◆ is_mod()

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

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

Definition at line 2853 of file z3py.py.

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

Referenced by is_mod().

◆ is_mul()

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

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

Definition at line 2800 of file z3py.py.

2800def is_mul(a):
2801 """Return `True` if `a` is an expression of the form b * c.
2802
2803 >>> x, y = Ints('x y')
2804 >>> is_mul(x * y)
2805 True
2806 >>> is_mul(x - y)
2807 False
2808 """
2809 return is_app_of(a, Z3_OP_MUL)
2810
2811

Referenced by is_mul().

◆ is_not()

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

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

Definition at line 1653 of file z3py.py.

1653def is_not(a):
1654 """Return `True` if `a` is a Z3 not expression.
1655
1656 >>> p = Bool('p')
1657 >>> is_not(p)
1658 False
1659 >>> is_not(Not(p))
1660 True
1661 """
1662 return is_app_of(a, Z3_OP_NOT)
1663
1664

Referenced by is_not(), and mk_not().

◆ is_or()

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

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

Definition at line 1629 of file z3py.py.

1629def is_or(a):
1630 """Return `True` if `a` is a Z3 or expression.
1631
1632 >>> p, q = Bools('p q')
1633 >>> is_or(Or(p, q))
1634 True
1635 >>> is_or(And(p, q))
1636 False
1637 """
1638 return is_app_of(a, Z3_OP_OR)
1639
1640

Referenced by is_or().

◆ is_pattern()

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

1929def is_pattern(a):
1930 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1931
1932 >>> f = Function('f', IntSort(), IntSort())
1933 >>> x = Int('x')
1934 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1935 >>> q
1936 ForAll(x, f(x) == 0)
1937 >>> q.num_patterns()
1938 1
1939 >>> is_pattern(q.pattern(0))
1940 True
1941 >>> q.pattern(0)
1942 f(Var(0))
1943 """
1944 return isinstance(a, PatternRef)
1945
1946

Referenced by _mk_quantifier(), _to_pattern(), is_pattern(), and MultiPattern().

◆ is_probe()

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

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

Definition at line 8685 of file z3py.py.

8685def is_probe(p):
8686 """Return `True` if `p` is a Z3 probe.
8687
8688 >>> is_probe(Int('x'))
8689 False
8690 >>> is_probe(Probe('memory'))
8691 True
8692 """
8693 return isinstance(p, Probe)
8694
8695

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

◆ is_quantifier()

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

2169def is_quantifier(a):
2170 """Return `True` if `a` is a Z3 quantifier.
2171
2172 >>> f = Function('f', IntSort(), IntSort())
2173 >>> x = Int('x')
2174 >>> q = ForAll(x, f(x) == 0)
2175 >>> is_quantifier(q)
2176 True
2177 >>> is_quantifier(f(x))
2178 False
2179 """
2180 return isinstance(a, QuantifierRef)
2181
2182

Referenced by Exists(), and is_quantifier().

◆ is_rational_value()

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

2752def is_rational_value(a):
2753 """Return `True` if `a` is rational value of sort Real.
2754
2755 >>> is_rational_value(RealVal(1))
2756 True
2757 >>> is_rational_value(RealVal("3/5"))
2758 True
2759 >>> is_rational_value(IntVal(1))
2760 False
2761 >>> is_rational_value(1)
2762 False
2763 >>> n = Real('x') + 1
2764 >>> n.arg(1)
2765 1
2766 >>> is_rational_value(n.arg(1))
2767 True
2768 >>> is_rational_value(Real('x'))
2769 False
2770 """
2771 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2772
2773

Referenced by RatNumRef.denominator(), is_rational_value(), and RatNumRef.numerator().

◆ is_re()

def is_re (   s)

Definition at line 11216 of file z3py.py.

11216def is_re(s):
11217 return isinstance(s, ReRef)
11218
11219

Referenced by Concat(), Intersect(), and Union().

◆ is_real()

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

2701def is_real(a):
2702 """Return `True` if `a` is a real expression.
2703
2704 >>> x = Int('x')
2705 >>> is_real(x + 1)
2706 False
2707 >>> y = Real('y')
2708 >>> is_real(y)
2709 True
2710 >>> is_real(y + 1)
2711 True
2712 >>> is_real(1)
2713 False
2714 >>> is_real(RealVal(1))
2715 True
2716 """
2717 return is_arith(a) and a.is_real()
2718
2719

Referenced by fpRealToFP(), fpToFP(), fpToReal(), is_real(), Real(), and RealSort().

◆ is_select()

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

4878def is_select(a):
4879 """Return `True` if `a` is a Z3 array select application.
4880
4881 >>> a = Array('a', IntSort(), IntSort())
4882 >>> is_select(a)
4883 False
4884 >>> i = Int('i')
4885 >>> is_select(a[i])
4886 True
4887 """
4888 return is_app_of(a, Z3_OP_SELECT)
4889
4890

Referenced by is_select().

◆ is_seq()

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

10942def is_seq(a):
10943 """Return `True` if `a` is a Z3 sequence expression.
10944 >>> print (is_seq(Unit(IntVal(0))))
10945 True
10946 >>> print (is_seq(StringVal("abc")))
10947 True
10948 """
10949 return isinstance(a, SeqRef)
10950
10951

Referenced by _coerce_seq(), Concat(), Extract(), and is_seq().

◆ is_sort()

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

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

Definition at line 647 of file z3py.py.

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

Referenced by _dict2sarray(), _valid_accessor(), ArraySort(), CreateDatatypes(), FreshFunction(), Function(), is_sort(), K(), PropagateFunction(), RecFunction(), and Var().

◆ is_store()

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

4891def is_store(a):
4892 """Return `True` if `a` is a Z3 array store application.
4893
4894 >>> a = Array('a', IntSort(), IntSort())
4895 >>> is_store(a)
4896 False
4897 >>> is_store(Store(a, 0, 1))
4898 True
4899 """
4900 return is_app_of(a, Z3_OP_STORE)
4901

Referenced by is_store().

◆ is_string()

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

Definition at line 10952 of file z3py.py.

10952def is_string(a):
10953 """Return `True` if `a` is a Z3 string expression.
10954 >>> print (is_string(StringVal("ab")))
10955 True
10956 """
10957 return isinstance(a, SeqRef) and a.is_string()
10958
10959

Referenced by is_string().

◆ is_string_value()

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

Definition at line 10960 of file z3py.py.

10960def is_string_value(a):
10961 """return 'True' if 'a' is a Z3 string constant expression.
10962 >>> print (is_string_value(StringVal("a")))
10963 True
10964 >>> print (is_string_value(StringVal("a") + StringVal("b")))
10965 False
10966 """
10967 return isinstance(a, SeqRef) and a.is_string_value()
10968

Referenced by is_string_value().

◆ is_sub()

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

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

Definition at line 2812 of file z3py.py.

2812def is_sub(a):
2813 """Return `True` if `a` is an expression of the form b - c.
2814
2815 >>> x, y = Ints('x y')
2816 >>> is_sub(x - y)
2817 True
2818 >>> is_sub(x + y)
2819 False
2820 """
2821 return is_app_of(a, Z3_OP_SUB)
2822
2823

Referenced by is_sub().

◆ is_to_int()

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

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

Definition at line 2940 of file z3py.py.

2940def is_to_int(a):
2941 """Return `True` if `a` is an expression of the form ToInt(b).
2942
2943 >>> x = Real('x')
2944 >>> n = ToInt(x)
2945 >>> n
2946 ToInt(x)
2947 >>> is_to_int(n)
2948 True
2949 >>> is_to_int(x)
2950 False
2951 """
2952 return is_app_of(a, Z3_OP_TO_INT)
2953
2954

Referenced by is_to_int().

◆ is_to_real()

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

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

Definition at line 2925 of file z3py.py.

2925def is_to_real(a):
2926 """Return `True` if `a` is an expression of the form ToReal(b).
2927
2928 >>> x = Int('x')
2929 >>> n = ToReal(x)
2930 >>> n
2931 ToReal(x)
2932 >>> is_to_real(n)
2933 True
2934 >>> is_to_real(x)
2935 False
2936 """
2937 return is_app_of(a, Z3_OP_TO_REAL)
2938
2939

Referenced by is_to_real().

◆ is_true()

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

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

Definition at line 1585 of file z3py.py.

1585def is_true(a):
1586 """Return `True` if `a` is the Z3 true expression.
1587
1588 >>> p = Bool('p')
1589 >>> is_true(p)
1590 False
1591 >>> is_true(simplify(p == p))
1592 True
1593 >>> x = Real('x')
1594 >>> is_true(x == 0)
1595 False
1596 >>> # True is a Python Boolean expression
1597 >>> is_true(True)
1598 False
1599 """
1600 return is_app_of(a, Z3_OP_TRUE)
1601
1602

Referenced by AstRef.__bool__(), BoolVal(), and is_true().

◆ is_var()

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

1306def is_var(a):
1307 """Return `True` if `a` is variable.
1308
1309 Z3 uses de-Bruijn indices for representing bound variables in
1310 quantifiers.
1311
1312 >>> x = Int('x')
1313 >>> is_var(x)
1314 False
1315 >>> is_const(x)
1316 True
1317 >>> f = Function('f', IntSort(), IntSort())
1318 >>> # Z3 replaces x with bound variables when ForAll is executed.
1319 >>> q = ForAll(x, f(x) == x)
1320 >>> b = q.body()
1321 >>> b
1322 f(Var(0)) == Var(0)
1323 >>> b.arg(1)
1324 Var(0)
1325 >>> is_var(b.arg(1))
1326 True
1327 """
1328 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1329
1330

Referenced by get_var_index(), and is_var().

◆ IsInt()

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

3386def IsInt(a):
3387 """ Return the Z3 predicate IsInt(a).
3388
3389 >>> x = Real('x')
3390 >>> IsInt(x + "1/2")
3391 IsInt(x + 1/2)
3392 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3393 [x = 1/2]
3394 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3395 no solution
3396 """
3397 if z3_debug():
3398 _z3_assert(a.is_real(), "Z3 real expression expected.")
3399 ctx = a.ctx
3400 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3401
3402
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.

Referenced by is_is_int(), and IsInt().

◆ IsMember()

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

5001def IsMember(e, s):
5002 """ Check if e is a member of set s
5003 >>> a = Const('a', SetSort(IntSort()))
5004 >>> IsMember(1, a)
5005 a[1]
5006 """
5007 ctx = _ctx_from_ast_arg_list([s, e])
5008 e = _py2expr(e, ctx)
5009 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5010
5011
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.

Referenced by IsMember().

◆ IsSubset()

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

5012def IsSubset(a, b):
5013 """ Check if a is a subset of b
5014 >>> a = Const('a', SetSort(IntSort()))
5015 >>> b = Const('b', SetSort(IntSort()))
5016 >>> IsSubset(a, b)
5017 subset(a, b)
5018 """
5019 ctx = _ctx_from_ast_arg_list([a, b])
5020 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5021
5022
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.

Referenced by IsSubset().

◆ K()

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

4838def K(dom, v):
4839 """Return a Z3 constant array expression.
4840
4841 >>> a = K(IntSort(), 10)
4842 >>> a
4843 K(Int, 10)
4844 >>> a.sort()
4845 Array(Int, Int)
4846 >>> i = Int('i')
4847 >>> a[i]
4848 K(Int, 10)[i]
4849 >>> simplify(a[i])
4850 10
4851 """
4852 if z3_debug():
4853 _z3_assert(is_sort(dom), "Z3 sort expected")
4854 ctx = dom.ctx
4855 if not is_expr(v):
4856 v = _py2expr(v, ctx)
4857 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4858
4859
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.

Referenced by Default(), EmptySet(), FullSet(), ModelRef.get_interp(), is_const_array(), is_default(), is_K(), and K().

◆ Lambda()

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

2257def Lambda(vs, body):
2258 """Create a Z3 lambda expression.
2259
2260 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2261 >>> mem0 = Array('mem0', IntSort(), IntSort())
2262 >>> lo, hi, e, i = Ints('lo hi e i')
2263 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2264 >>> mem1
2265 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2266 """
2267 ctx = body.ctx
2268 if is_app(vs):
2269 vs = [vs]
2270 num_vars = len(vs)
2271 _vs = (Ast * num_vars)()
2272 for i in range(num_vars):
2273 # TODO: Check if is constant
2274 _vs[i] = vs[i].as_ast()
2275 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2276
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.

Referenced by QuantifierRef.is_lambda(), and Lambda().

◆ LastIndexOf()

def LastIndexOf (   s,
  substr 
)
Retrieve the last index of substring within a string

Definition at line 11127 of file z3py.py.

11127def LastIndexOf(s, substr):
11128 """Retrieve the last index of substring within a string"""
11129 ctx = None
11130 ctx = _get_ctx2(s, substr, ctx)
11131 s = _coerce_seq(s, ctx)
11132 substr = _coerce_seq(substr, ctx)
11133 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11134
11135
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()

def Length (   s)
Obtain the length of a sequence 's'
>>> l = Length(StringVal("abc"))
>>> simplify(l)
3

Definition at line 11136 of file z3py.py.

11136def Length(s):
11137 """Obtain the length of a sequence 's'
11138 >>> l = Length(StringVal("abc"))
11139 >>> simplify(l)
11140 3
11141 """
11142 s = _coerce_seq(s)
11143 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11144
11145
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.

Referenced by Length().

◆ LinearOrder()

def LinearOrder (   a,
  index 
)

Definition at line 11358 of file z3py.py.

11358def LinearOrder(a, index):
11359 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11360
11361
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()

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

11316def Loop(re, lo, hi=0):
11317 """Create the regular expression accepting between a lower and upper bound repetitions
11318 >>> re = Loop(Re("a"), 1, 3)
11319 >>> print(simplify(InRe("aa", re)))
11320 True
11321 >>> print(simplify(InRe("aaaa", re)))
11322 False
11323 >>> print(simplify(InRe("", re)))
11324 False
11325 """
11326 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11327
11328
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...

Referenced by Loop().

◆ LShR()

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

4291def LShR(a, b):
4292 """Create the Z3 expression logical right shift.
4293
4294 Use the operator >> for the arithmetical right shift.
4295
4296 >>> x, y = BitVecs('x y', 32)
4297 >>> LShR(x, y)
4298 LShR(x, y)
4299 >>> (x >> y).sexpr()
4300 '(bvashr x y)'
4301 >>> LShR(x, y).sexpr()
4302 '(bvlshr x y)'
4303 >>> BitVecVal(4, 3)
4304 4
4305 >>> BitVecVal(4, 3).as_signed_long()
4306 -4
4307 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4308 -2
4309 >>> simplify(BitVecVal(4, 3) >> 1)
4310 6
4311 >>> simplify(LShR(BitVecVal(4, 3), 1))
4312 2
4313 >>> simplify(BitVecVal(2, 3) >> 1)
4314 1
4315 >>> simplify(LShR(BitVecVal(2, 3), 1))
4316 1
4317 """
4318 _check_bv_args(a, b)
4319 a, b = _coerce_exprs(a, b)
4320 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4321
4322
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.

Referenced by BitVecRef.__rlshift__(), BitVecRef.__rrshift__(), BitVecRef.__rshift__(), and LShR().

◆ main_ctx()

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

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

Definition at line 239 of file z3py.py.

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

Referenced by _get_ctx(), _get_ctx2(), help_simplify(), main_ctx(), simplify_param_descrs(), and Goal.translate().

◆ Map()

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

4815def Map(f, *args):
4816 """Return a Z3 map array expression.
4817
4818 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4819 >>> a1 = Array('a1', IntSort(), IntSort())
4820 >>> a2 = Array('a2', IntSort(), IntSort())
4821 >>> b = Map(f, a1, a2)
4822 >>> b
4823 Map(f, a1, a2)
4824 >>> prove(b[0] == f(a1[0], a2[0]))
4825 proved
4826 """
4827 args = _get_args(args)
4828 if z3_debug():
4829 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4830 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4831 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4832 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4833 _args, sz = _to_ast_array(args)
4834 ctx = f.ctx
4835 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4836
4837
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.

Referenced by get_map_func(), is_map(), and Map().

◆ mk_not()

def mk_not (   a)

Definition at line 1830 of file z3py.py.

1830def mk_not(a):
1831 if is_not(a):
1832 return a.arg(0)
1833 else:
1834 return Not(a)
1835
1836

◆ Model()

def Model (   ctx = None)

Definition at line 6681 of file z3py.py.

6681def Model(ctx=None):
6682 ctx = _get_ctx(ctx)
6683 return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6684
6685
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.

Referenced by Optimize.set_on_model().

◆ MultiPattern()

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

1947def MultiPattern(*args):
1948 """Create a Z3 multi-pattern using the given expressions `*args`
1949
1950 >>> f = Function('f', IntSort(), IntSort())
1951 >>> g = Function('g', IntSort(), IntSort())
1952 >>> x = Int('x')
1953 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1954 >>> q
1955 ForAll(x, f(x) != g(x))
1956 >>> q.num_patterns()
1957 1
1958 >>> is_pattern(q.pattern(0))
1959 True
1960 >>> q.pattern(0)
1961 MultiPattern(f(Var(0)), g(Var(0)))
1962 """
1963 if z3_debug():
1964 _z3_assert(len(args) > 0, "At least one argument expected")
1965 _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
1966 ctx = args[0].ctx
1967 args, sz = _to_ast_array(args)
1968 return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
1969
1970
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(), and MultiPattern().

◆ Not()

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

1811def Not(a, ctx=None):
1812 """Create a Z3 not expression or probe.
1813
1814 >>> p = Bool('p')
1815 >>> Not(Not(p))
1816 Not(Not(p))
1817 >>> simplify(Not(Not(p)))
1818 p
1819 """
1820 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1821 if is_probe(a):
1822 # Not is also used to build probes
1823 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1824 else:
1825 s = BoolSort(ctx)
1826 a = s.cast(a)
1827 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1828
1829
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).

Referenced by _prove_html(), AndThen(), ApplyResult.as_expr(), Solver.consequences(), Goal.convert_model(), Distinct(), FailIf(), fpNEQ(), is_not(), mk_not(), Not(), prove(), simplify(), Then(), When(), and Xor().

◆ on_clause_eh()

def on_clause_eh (   ctx,
  p,
  clause 
)

Definition at line 11398 of file z3py.py.

11398def on_clause_eh(ctx, p, clause):
11399 onc = _my_hacky_class
11400 p = _to_expr_ref(to_Ast(p), onc.ctx)
11401 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11402 onc.on_clause(p, clause)
11403

◆ open_log()

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

Definition at line 114 of file z3py.py.

114def open_log(fname):
115 """Log interaction to a file. This function must be invoked immediately after init(). """
116 Z3_open_log(fname)
117
118
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.

◆ Option()

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

11285def Option(re):
11286 """Create the regular expression that optionally accepts the argument.
11287 >>> re = Option(Re("a"))
11288 >>> print(simplify(InRe("a", re)))
11289 True
11290 >>> print(simplify(InRe("", re)))
11291 True
11292 >>> print(simplify(InRe("aa", re)))
11293 False
11294 """
11295 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11296
11297
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].

Referenced by Option().

◆ Or()

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

1878def Or(*args):
1879 """Create a Z3 or-expression or or-probe.
1880
1881 >>> p, q, r = Bools('p q r')
1882 >>> Or(p, q, r)
1883 Or(p, q, r)
1884 >>> P = BoolVector('p', 5)
1885 >>> Or(P)
1886 Or(p__0, p__1, p__2, p__3, p__4)
1887 """
1888 last_arg = None
1889 if len(args) > 0:
1890 last_arg = args[len(args) - 1]
1891 if isinstance(last_arg, Context):
1892 ctx = args[len(args) - 1]
1893 args = args[:len(args) - 1]
1894 elif len(args) == 1 and isinstance(args[0], AstVector):
1895 ctx = args[0].ctx
1896 args = [a for a in args[0]]
1897 else:
1898 ctx = None
1899 args = _get_args(args)
1900 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1901 if z3_debug():
1902 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1903 if _has_probe(args):
1904 return _probe_or(args, ctx)
1905 else:
1906 args = _coerce_expr_list(args, ctx)
1907 _args, sz = _to_ast_array(args)
1908 return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1909
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 ApplyResult.__getitem__(), ApplyResult.__len__(), ApplyResult.as_expr(), Bools(), Goal.convert_model(), is_and(), is_or(), Or(), OrElse(), ParThen(), prove(), Repeat(), and simplify().

◆ OrElse()

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

8378def OrElse(*ts, **ks):
8379 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8380
8381 >>> x = Int('x')
8382 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8383 >>> # Tactic split-clause fails if there is no clause in the given goal.
8384 >>> t(x == 0)
8385 [[x == 0]]
8386 >>> t(Or(x == 0, x == 1))
8387 [[x == 0], [x == 1]]
8388 """
8389 if z3_debug():
8390 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8391 ctx = ks.get("ctx", None)
8392 num = len(ts)
8393 r = ts[0]
8394 for i in range(num - 1):
8395 r = _or_else(r, ts[i + 1], ctx)
8396 return r
8397
8398

Referenced by FailIf(), OrElse(), and Repeat().

◆ ParAndThen()

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

Definition at line 8434 of file z3py.py.

8434def ParAndThen(t1, t2, ctx=None):
8435 """Alias for ParThen(t1, t2, ctx)."""
8436 return ParThen(t1, t2, ctx)
8437
8438

◆ ParOr()

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

8399def ParOr(*ts, **ks):
8400 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8401
8402 >>> x = Int('x')
8403 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8404 >>> t(x + 1 == 2)
8405 [[x == 1]]
8406 """
8407 if z3_debug():
8408 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8409 ctx = _get_ctx(ks.get("ctx", None))
8410 ts = [_to_tactic(t, ctx) for t in ts]
8411 sz = len(ts)
8412 _args = (TacticObj * sz)()
8413 for i in range(sz):
8414 _args[i] = ts[i].tactic
8415 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8416
8417
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.

Referenced by ParOr().

◆ parse_smt2_file()

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

9314def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9315 """Parse a file in SMT 2.0 format using the given sorts and decls.
9316
9317 This function is similar to parse_smt2_string().
9318 """
9319 ctx = _get_ctx(ctx)
9320 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9321 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9322 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9323
9324
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()

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

9293def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9294 """Parse a string in SMT 2.0 format using the given sorts and decls.
9295
9296 The arguments sorts and decls are Python dictionaries used to initialize
9297 the symbol table used for the SMT 2.0 parser.
9298
9299 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9300 [x > 0, x < 10]
9301 >>> x, y = Ints('x y')
9302 >>> f = Function('f', IntSort(), IntSort())
9303 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9304 [x + f(y) > 0]
9305 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9306 [a > 0]
9307 """
9308 ctx = _get_ctx(ctx)
9309 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9310 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9311 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9312
9313
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.

Referenced by parse_smt2_file(), and parse_smt2_string().

◆ ParThen()

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

8418def ParThen(t1, t2, ctx=None):
8419 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8420 The subgoals are processed in parallel.
8421
8422 >>> x, y = Ints('x y')
8423 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8424 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8425 [[x == 1, y == 2], [x == 2, y == 3]]
8426 """
8427 t1 = _to_tactic(t1, ctx)
8428 t2 = _to_tactic(t2, ctx)
8429 if z3_debug():
8430 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8431 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8432
8433
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....

Referenced by ParAndThen(), and ParThen().

◆ PartialOrder()

def PartialOrder (   a,
  index 
)

Definition at line 11354 of file z3py.py.

11354def PartialOrder(a, index):
11355 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11356
11357
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()

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

9070def PbEq(args, k, ctx=None):
9071 """Create a Pseudo-Boolean equality k constraint.
9072
9073 >>> a, b, c = Bools('a b c')
9074 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9075 """
9076 _z3_check_cint_overflow(k, "k")
9077 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9078 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9079
9080
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.

Referenced by PbEq().

◆ PbGe()

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

9059def PbGe(args, k):
9060 """Create a Pseudo-Boolean inequality k constraint.
9061
9062 >>> a, b, c = Bools('a b c')
9063 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9064 """
9065 _z3_check_cint_overflow(k, "k")
9066 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9067 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9068
9069
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.

Referenced by PbGe().

◆ PbLe()

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

9048def PbLe(args, k):
9049 """Create a Pseudo-Boolean inequality k constraint.
9050
9051 >>> a, b, c = Bools('a b c')
9052 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9053 """
9054 _z3_check_cint_overflow(k, "k")
9055 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9056 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9057
9058
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.

Referenced by PbLe().

◆ PiecewiseLinearOrder()

def PiecewiseLinearOrder (   a,
  index 
)

Definition at line 11366 of file z3py.py.

11366def PiecewiseLinearOrder(a, index):
11367 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11368
11369
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()

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

11272def Plus(re):
11273 """Create the regular expression accepting one or more repetitions of argument.
11274 >>> re = Plus(Re("a"))
11275 >>> print(simplify(InRe("aa", re)))
11276 True
11277 >>> print(simplify(InRe("ab", re)))
11278 False
11279 >>> print(simplify(InRe("", re)))
11280 False
11281 """
11282 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11283
11284
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.

Referenced by Plus().

◆ PrefixOf()

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

11043def PrefixOf(a, b):
11044 """Check if 'a' is a prefix of 'b'
11045 >>> s1 = PrefixOf("ab", "abc")
11046 >>> simplify(s1)
11047 True
11048 >>> s2 = PrefixOf("bc", "abc")
11049 >>> simplify(s2)
11050 False
11051 """
11052 ctx = _get_ctx2(a, b)
11053 a = _coerce_seq(a, ctx)
11054 b = _coerce_seq(b, ctx)
11055 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11056
11057
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.

Referenced by PrefixOf().

◆ probe_description()

def probe_description (   name,
  ctx = None 
)
Return a short description for the probe named `name`.

>>> d = probe_description('memory')

Definition at line 8714 of file z3py.py.

8714def probe_description(name, ctx=None):
8715 """Return a short description for the probe named `name`.
8716
8717 >>> d = probe_description('memory')
8718 """
8719 ctx = _get_ctx(ctx)
8720 return Z3_probe_get_descr(ctx.ref(), name)
8721
8722
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.

Referenced by describe_probes(), and probe_description().

◆ probes()

def probes (   ctx = None)
Return a list of all available probes in Z3.

>>> l = probes()
>>> l.count('memory') == 1
True

Definition at line 8703 of file z3py.py.

8703def probes(ctx=None):
8704 """Return a list of all available probes in Z3.
8705
8706 >>> l = probes()
8707 >>> l.count('memory') == 1
8708 True
8709 """
8710 ctx = _get_ctx(ctx)
8711 return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8712
8713
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.

Referenced by describe_probes(), and probes().

◆ Product()

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

8955def Product(*args):
8956 """Create the product of the Z3 expressions.
8957
8958 >>> a, b, c = Ints('a b c')
8959 >>> Product(a, b, c)
8960 a*b*c
8961 >>> Product([a, b, c])
8962 a*b*c
8963 >>> A = IntVector('a', 5)
8964 >>> Product(A)
8965 a__0*a__1*a__2*a__3*a__4
8966 """
8967 args = _get_args(args)
8968 if len(args) == 0:
8969 return 1
8970 ctx = _ctx_from_ast_arg_list(args)
8971 if ctx is None:
8972 return _reduce(lambda a, b: a * b, args, 1)
8973 args = _coerce_expr_list(args, ctx)
8974 if is_bv(args[0]):
8975 return _reduce(lambda a, b: a * b, args, 1)
8976 else:
8977 _args, sz = _to_ast_array(args)
8978 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8979
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].

Referenced by BitVecs(), and Product().

◆ PropagateFunction()

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

11549def PropagateFunction(name, *sig):
11550 """Create a function that gets tracked by user propagator.
11551 Every term headed by this function symbol is tracked.
11552 If a term is fixed and the fixed callback is registered a
11553 callback is invoked that the term headed by this function is fixed.
11554 """
11555 sig = _get_args(sig)
11556 if z3_debug():
11557 _z3_assert(len(sig) > 0, "At least two arguments expected")
11558 arity = len(sig) - 1
11559 rng = sig[arity]
11560 if z3_debug():
11561 _z3_assert(is_sort(rng), "Z3 sort expected")
11562 dom = (Sort * arity)()
11563 for i in range(arity):
11564 if z3_debug():
11565 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11566 dom[i] = sig[i].ast
11567 ctx = rng.ctx
11568 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11569
11570
11571
Z3_func_decl Z3_API Z3_solver_propagate_declare(Z3_context c, Z3_symbol name, unsigned n, Z3_sort *domain, Z3_sort range)

◆ prove()

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

9142def prove(claim, show=False, **keywords):
9143 """Try to prove the given claim.
9144
9145 This is a simple function for creating demonstrations. It tries to prove
9146 `claim` by showing the negation is unsatisfiable.
9147
9148 >>> p, q = Bools('p q')
9149 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9150 proved
9151 """
9152 if z3_debug():
9153 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9154 s = Solver()
9155 s.set(**keywords)
9156 s.add(Not(claim))
9157 if show:
9158 print(s)
9159 r = s.check()
9160 if r == unsat:
9161 print("proved")
9162 elif r == unknown:
9163 print("failed to prove")
9164 print(s.model())
9165 else:
9166 print("counterexample")
9167 print(s.model())
9168
9169

Referenced by Default(), Map(), prove(), Store(), and Update().

◆ Q()

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

3227def Q(a, b, ctx=None):
3228 """Return a Z3 rational a/b.
3229
3230 If `ctx=None`, then the global context is used.
3231
3232 >>> Q(3,5)
3233 3/5
3234 >>> Q(3,5).sort()
3235 Real
3236 """
3237 return simplify(RatVal(a, b, ctx=ctx))
3238
3239

Referenced by RatNumRef.as_string(), RatNumRef.denominator(), RatNumRef.numerator(), and Q().

◆ Range()

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

11329def Range(lo, hi, ctx=None):
11330 """Create the range regular expression over two sequences of length 1
11331 >>> range = Range("a","z")
11332 >>> print(simplify(InRe("b", range)))
11333 True
11334 >>> print(simplify(InRe("bb", range)))
11335 False
11336 """
11337 lo = _coerce_seq(lo, ctx)
11338 hi = _coerce_seq(hi, ctx)
11339 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11340
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.

Referenced by Range().

◆ RatVal()

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

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

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

Definition at line 3211 of file z3py.py.

3211def RatVal(a, b, ctx=None):
3212 """Return a Z3 rational a/b.
3213
3214 If `ctx=None`, then the global context is used.
3215
3216 >>> RatVal(3,5)
3217 3/5
3218 >>> RatVal(3,5).sort()
3219 Real
3220 """
3221 if z3_debug():
3222 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3223 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3224 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3225
3226

Referenced by Q(), and RatVal().

◆ Re()

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

11181def Re(s, ctx=None):
11182 """The regular expression that accepts sequence 's'
11183 >>> s1 = Re("ab")
11184 >>> s2 = Re(StringVal("ab"))
11185 >>> s3 = Re(Unit(BoolVal(True)))
11186 """
11187 s = _coerce_seq(s, ctx)
11188 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11189
11190
11191# Regular expressions
11192
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.

Referenced by InRe(), Intersect(), Loop(), Option(), Plus(), Re(), Star(), and Union().

◆ Real()

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

3293def Real(name, ctx=None):
3294 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3295
3296 >>> x = Real('x')
3297 >>> is_real(x)
3298 True
3299 >>> is_real(x + 1)
3300 True
3301 """
3302 ctx = _get_ctx(ctx)
3303 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3304
3305

Referenced by FuncDeclRef.__call__(), ArithRef.__div__(), ArithRef.__ge__(), ArithRef.__gt__(), ArithRef.__le__(), ArithRef.__lt__(), ArithRef.__mul__(), ArithRef.__pow__(), ArithRef.__rdiv__(), ArithRef.__rmul__(), ArithRef.__rpow__(), Cbrt(), is_arith(), is_bool(), is_func_decl(), is_int(), ArithSortRef.is_int(), ArithRef.is_int(), is_is_int(), is_rational_value(), is_real(), ArithSortRef.is_real(), ArithRef.is_real(), is_to_int(), is_true(), IsInt(), main_ctx(), Real(), Reals(), RealVector(), Tactic.solver(), ExprRef.sort(), ArithRef.sort(), Sqrt(), ToInt(), and QuantifierRef.var_sort().

◆ Reals()

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

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

Referenced by is_div(), and Reals().

◆ RealSort()

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

3151def RealSort(ctx=None):
3152 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3153
3154 >>> RealSort()
3155 Real
3156 >>> x = Const('x', RealSort())
3157 >>> is_real(x)
3158 True
3159 >>> is_int(x)
3160 False
3161 >>> x.sort() == RealSort()
3162 True
3163 """
3164 ctx = _get_ctx(ctx)
3165 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3166
3167
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.

Referenced by FuncDeclRef.__call__(), FuncDeclRef.arity(), SortRef.cast(), ArithSortRef.cast(), FuncDeclRef.domain(), FreshReal(), is_arith_sort(), FuncDeclRef.range(), Real(), RealSort(), RealVal(), RealVar(), SortRef.subsort(), and QuantifierRef.var_sort().

◆ RealVal()

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

3192def RealVal(val, ctx=None):
3193 """Return a Z3 real value.
3194
3195 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3196 If `ctx=None`, then the global context is used.
3197
3198 >>> RealVal(1)
3199 1
3200 >>> RealVal(1).sort()
3201 Real
3202 >>> RealVal("3/5")
3203 3/5
3204 >>> RealVal("1.5")
3205 3/2
3206 """
3207 ctx = _get_ctx(ctx)
3208 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3209
3210

Referenced by _coerce_exprs(), _py2expr(), RatNumRef.as_decimal(), RatNumRef.as_fraction(), Cbrt(), RatNumRef.denominator_as_long(), fpRealToFP(), fpToFP(), is_algebraic_value(), is_int_value(), is_rational_value(), is_real(), RatNumRef.numerator(), RatNumRef.numerator_as_long(), RatVal(), RealVal(), and Sqrt().

◆ RealVar()

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

>>> RealVar(0)
Var(0)

Definition at line 1481 of file z3py.py.

1481def RealVar(idx, ctx=None):
1482 """
1483 Create a real free variable. Free variables are used to create quantified formulas.
1484 They are also used to create polynomials.
1485
1486 >>> RealVar(0)
1487 Var(0)
1488 """
1489 return Var(idx, RealSort(ctx))
1490
1491

Referenced by RealVar(), and RealVarVector().

◆ RealVarVector()

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

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

Definition at line 1492 of file z3py.py.

1492def RealVarVector(n, ctx=None):
1493 """
1494 Create a list of Real free variables.
1495 The variables have ids: 0, 1, ..., n-1
1496
1497 >>> x0, x1, x2, x3 = RealVarVector(4)
1498 >>> x2
1499 Var(2)
1500 """
1501 return [RealVar(i, ctx) for i in range(n)]
1502

Referenced by RealVarVector().

◆ RealVector()

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

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

Referenced by RealVector().

◆ RecAddDefinition()

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

923def RecAddDefinition(f, args, body):
924 """Set the body of a recursive function.
925 Recursive definitions can be simplified if they are applied to ground
926 arguments.
927 >>> ctx = Context()
928 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
929 >>> n = Int('n', ctx)
930 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
931 >>> simplify(fac(5))
932 120
933 >>> s = Solver(ctx=ctx)
934 >>> s.add(fac(n) < 3)
935 >>> s.check()
936 sat
937 >>> s.model().eval(fac(5))
938 120
939 """
940 if is_app(args):
941 args = [args]
942 ctx = body.ctx
943 args = _get_args(args)
944 n = len(args)
945 _args = (Ast * n)()
946 for i in range(n):
947 _args[i] = args[i].ast
948 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
949
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.

Referenced by RecAddDefinition().

◆ RecFunction()

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

Definition at line 905 of file z3py.py.

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

Referenced by RecAddDefinition().

◆ Repeat()

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

8467def Repeat(t, max=4294967295, ctx=None):
8468 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8469 or the maximum number of iterations `max` is reached.
8470
8471 >>> x, y = Ints('x y')
8472 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8473 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8474 >>> r = t(c)
8475 >>> for subgoal in r: print(subgoal)
8476 [x == 0, y == 0, x > y]
8477 [x == 0, y == 1, x > y]
8478 [x == 1, y == 0, x > y]
8479 [x == 1, y == 1, x > y]
8480 >>> t = Then(t, Tactic('propagate-values'))
8481 >>> t(c)
8482 [[x == 1, y == 0]]
8483 """
8484 t = _to_tactic(t, ctx)
8485 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8486
8487
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...

Referenced by Repeat().

◆ RepeatBitVec()

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

4413def RepeatBitVec(n, a):
4414 """Return an expression representing `n` copies of `a`.
4415
4416 >>> x = BitVec('x', 8)
4417 >>> n = RepeatBitVec(4, x)
4418 >>> n
4419 RepeatBitVec(4, x)
4420 >>> n.size()
4421 32
4422 >>> v0 = BitVecVal(10, 4)
4423 >>> print("%.x" % v0.as_long())
4424 a
4425 >>> v = simplify(RepeatBitVec(4, v0))
4426 >>> v.size()
4427 16
4428 >>> print("%.x" % v.as_long())
4429 aaaa
4430 """
4431 if z3_debug():
4432 _z3_assert(_is_int(n), "First argument must be an integer")
4433 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4434 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4435
4436
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.

Referenced by RepeatBitVec().

◆ Replace()

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

11092def Replace(s, src, dst):
11093 """Replace the first occurrence of 'src' by 'dst' in 's'
11094 >>> r = Replace("aaa", "a", "b")
11095 >>> simplify(r)
11096 "baa"
11097 """
11098 ctx = _get_ctx2(dst, s)
11099 if ctx is None and is_expr(src):
11100 ctx = src.ctx
11101 src = _coerce_seq(src, ctx)
11102 dst = _coerce_seq(dst, ctx)
11103 s = _coerce_seq(s, ctx)
11104 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11105
11106
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.

Referenced by Replace().

◆ reset_params()

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

Definition at line 295 of file z3py.py.

295def reset_params():
296 """Reset all global (or module) parameters.
297 """
299
300
void Z3_API Z3_global_param_reset_all(void)
Restore the value of all global (and module) parameters. This command will not affect already created...

◆ ReSort()

def ReSort (   s)

Definition at line 11200 of file z3py.py.

11200def ReSort(s):
11201 if is_ast(s):
11202 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11203 if s is None or isinstance(s, Context):
11204 ctx = _get_ctx(s)
11205 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11206 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11207
11208
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.

Referenced by Empty(), and Full().

◆ RNA()

def RNA (   ctx = None)

Definition at line 9729 of file z3py.py.

9729def RNA(ctx=None):
9730 ctx = _get_ctx(ctx)
9731 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9732
9733
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.

Referenced by get_default_rounding_mode().

◆ RNE()

def RNE (   ctx = None)

Definition at line 9719 of file z3py.py.

9719def RNE(ctx=None):
9720 ctx = _get_ctx(ctx)
9721 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9722
9723
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.

Referenced by fpAbs(), fpAdd(), fpDiv(), fpFPToFP(), fpMax(), fpMin(), fpMul(), fpNeg(), fpRealToFP(), FPs(), fpSignedToFP(), fpSub(), fpToFP(), fpUnsignedToFP(), get_default_rounding_mode(), is_fprm(), and is_fprm_sort().

◆ RotateLeft()

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

4323def RotateLeft(a, b):
4324 """Return an expression representing `a` rotated to the left `b` times.
4325
4326 >>> a, b = BitVecs('a b', 16)
4327 >>> RotateLeft(a, b)
4328 RotateLeft(a, b)
4329 >>> simplify(RotateLeft(a, 0))
4330 a
4331 >>> simplify(RotateLeft(a, 16))
4332 a
4333 """
4334 _check_bv_args(a, b)
4335 a, b = _coerce_exprs(a, b)
4336 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4337
4338
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.

Referenced by RotateLeft().

◆ RotateRight()

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

4339def RotateRight(a, b):
4340 """Return an expression representing `a` rotated to the right `b` times.
4341
4342 >>> a, b = BitVecs('a b', 16)
4343 >>> RotateRight(a, b)
4344 RotateRight(a, b)
4345 >>> simplify(RotateRight(a, 0))
4346 a
4347 >>> simplify(RotateRight(a, 16))
4348 a
4349 """
4350 _check_bv_args(a, b)
4351 a, b = _coerce_exprs(a, b)
4352 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4353
4354
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.

Referenced by RotateRight().

◆ RoundNearestTiesToAway()

def RoundNearestTiesToAway (   ctx = None)

Definition at line 9724 of file z3py.py.

9724def RoundNearestTiesToAway(ctx=None):
9725 ctx = _get_ctx(ctx)
9726 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9727
9728

◆ RoundNearestTiesToEven()

def RoundNearestTiesToEven (   ctx = None)

Definition at line 9714 of file z3py.py.

9714def RoundNearestTiesToEven(ctx=None):
9715 ctx = _get_ctx(ctx)
9716 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9717
9718

◆ RoundTowardNegative()

def RoundTowardNegative (   ctx = None)

Definition at line 9744 of file z3py.py.

9744def RoundTowardNegative(ctx=None):
9745 ctx = _get_ctx(ctx)
9746 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9747
9748
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()

def RoundTowardPositive (   ctx = None)

Definition at line 9734 of file z3py.py.

9734def RoundTowardPositive(ctx=None):
9735 ctx = _get_ctx(ctx)
9736 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9737
9738
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()

def RoundTowardZero (   ctx = None)

Definition at line 9754 of file z3py.py.

9754def RoundTowardZero(ctx=None):
9755 ctx = _get_ctx(ctx)
9756 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9757
9758
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()

def RTN (   ctx = None)

Definition at line 9749 of file z3py.py.

9749def RTN(ctx=None):
9750 ctx = _get_ctx(ctx)
9751 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9752
9753

Referenced by get_default_rounding_mode().

◆ RTP()

def RTP (   ctx = None)

Definition at line 9739 of file z3py.py.

9739def RTP(ctx=None):
9740 ctx = _get_ctx(ctx)
9741 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9742
9743

Referenced by get_default_rounding_mode().

◆ RTZ()

def RTZ (   ctx = None)

Definition at line 9759 of file z3py.py.

9759def RTZ(ctx=None):
9760 ctx = _get_ctx(ctx)
9761 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9762
9763

Referenced by fpAdd(), fpToSBV(), fpToUBV(), and get_default_rounding_mode().

◆ Select()

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

4799def Select(a, *args):
4800 """Return a Z3 select array expression.
4801
4802 >>> a = Array('a', IntSort(), IntSort())
4803 >>> i = Int('i')
4804 >>> Select(a, i)
4805 a[i]
4806 >>> eq(Select(a, i), a[i])
4807 True
4808 """
4809 args = _get_args(args)
4810 if z3_debug():
4811 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4812 return a[args]
4813
4814

Referenced by Select().

◆ SeqSort()

def SeqSort (   s)
Create a sequence sort over elements provided in the argument
>>> s = SeqSort(IntSort())
>>> s == Unit(IntVal(1)).sort()
True

Definition at line 10813 of file z3py.py.

10813def SeqSort(s):
10814 """Create a sequence sort over elements provided in the argument
10815 >>> s = SeqSort(IntSort())
10816 >>> s == Unit(IntVal(1)).sort()
10817 True
10818 """
10819 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10820
10821
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.

Referenced by Empty(), Full(), SeqSortRef.is_string(), and SeqSort().

◆ set_default_fp_sort()

def set_default_fp_sort (   ebits,
  sbits,
  ctx = None 
)

Definition at line 9375 of file z3py.py.

9375def set_default_fp_sort(ebits, sbits, ctx=None):
9376 global _dflt_fpsort_ebits
9377 global _dflt_fpsort_sbits
9378 _dflt_fpsort_ebits = ebits
9379 _dflt_fpsort_sbits = sbits
9380
9381

◆ set_default_rounding_mode()

def set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 9362 of file z3py.py.

9362def set_default_rounding_mode(rm, ctx=None):
9363 global _dflt_rounding_mode
9364 if is_fprm_value(rm):
9365 _dflt_rounding_mode = rm.decl().kind()
9366 else:
9367 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9368 _dflt_rounding_mode = rm
9369
9370

◆ set_option()

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

Definition at line 301 of file z3py.py.

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

◆ set_param()

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

>>> set_param(precision=10)

Definition at line 271 of file z3py.py.

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

Referenced by set_option(), and set_param().

◆ SetAdd()

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

Definition at line 4958 of file z3py.py.

4958def SetAdd(s, e):
4959 """ Add element e to set s
4960 >>> a = Const('a', SetSort(IntSort()))
4961 >>> SetAdd(a, 1)
4962 Store(a, 1, True)
4963 """
4964 ctx = _ctx_from_ast_arg_list([s, e])
4965 e = _py2expr(e, ctx)
4966 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4967
4968
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.

Referenced by SetAdd().

◆ SetComplement()

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

Definition at line 4980 of file z3py.py.

4980def SetComplement(s):
4981 """ The complement of set s
4982 >>> a = Const('a', SetSort(IntSort()))
4983 >>> SetComplement(a)
4984 complement(a)
4985 """
4986 ctx = s.ctx
4987 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4988
4989
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.

Referenced by SetComplement().

◆ SetDel()

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

Definition at line 4969 of file z3py.py.

4969def SetDel(s, e):
4970 """ Remove element e to set s
4971 >>> a = Const('a', SetSort(IntSort()))
4972 >>> SetDel(a, 1)
4973 Store(a, 1, False)
4974 """
4975 ctx = _ctx_from_ast_arg_list([s, e])
4976 e = _py2expr(e, ctx)
4977 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4978
4979
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.

Referenced by SetDel().

◆ SetDifference()

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

4990def SetDifference(a, b):
4991 """ The set difference of a and b
4992 >>> a = Const('a', SetSort(IntSort()))
4993 >>> b = Const('b', SetSort(IntSort()))
4994 >>> SetDifference(a, b)
4995 setminus(a, b)
4996 """
4997 ctx = _ctx_from_ast_arg_list([a, b])
4998 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4999
5000
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.

Referenced by SetDifference().

◆ SetHasSize()

def SetHasSize (   a,
  k 
)

Definition at line 4872 of file z3py.py.

4872def SetHasSize(a, k):
4873 ctx = a.ctx
4874 k = _py2expr(k, ctx)
4875 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4876
4877
Z3_ast Z3_API Z3_mk_set_has_size(Z3_context c, Z3_ast set, Z3_ast k)
Create predicate that holds if Boolean array set has k elements set to true.

◆ SetIntersect()

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

4945def SetIntersect(*args):
4946 """ Take the union of sets
4947 >>> a = Const('a', SetSort(IntSort()))
4948 >>> b = Const('b', SetSort(IntSort()))
4949 >>> SetIntersect(a, b)
4950 intersection(a, b)
4951 """
4952 args = _get_args(args)
4953 ctx = _ctx_from_ast_arg_list(args)
4954 _args, sz = _to_ast_array(args)
4955 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4956
4957
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.

Referenced by SetIntersect().

◆ SetSort()

def SetSort (   s)

Sets.

 Create a set sort over element sort s

Definition at line 4909 of file z3py.py.

4909def SetSort(s):
4910 """ Create a set sort over element sort s"""
4911 return ArraySort(s, BoolSort())
4912
4913

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

◆ SetUnion()

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

4932def SetUnion(*args):
4933 """ Take the union of sets
4934 >>> a = Const('a', SetSort(IntSort()))
4935 >>> b = Const('b', SetSort(IntSort()))
4936 >>> SetUnion(a, b)
4937 union(a, b)
4938 """
4939 args = _get_args(args)
4940 ctx = _ctx_from_ast_arg_list(args)
4941 _args, sz = _to_ast_array(args)
4942 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4943
4944
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.

Referenced by SetUnion().

◆ SignExt()

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

4355def SignExt(n, a):
4356 """Return a bit-vector expression with `n` extra sign-bits.
4357
4358 >>> x = BitVec('x', 16)
4359 >>> n = SignExt(8, x)
4360 >>> n.size()
4361 24
4362 >>> n
4363 SignExt(8, x)
4364 >>> n.sort()
4365 BitVec(24)
4366 >>> v0 = BitVecVal(2, 2)
4367 >>> v0
4368 2
4369 >>> v0.size()
4370 2
4371 >>> v = simplify(SignExt(6, v0))
4372 >>> v
4373 254
4374 >>> v.size()
4375 8
4376 >>> print("%.x" % v.as_long())
4377 fe
4378 """
4379 if z3_debug():
4380 _z3_assert(_is_int(n), "First argument must be an integer")
4381 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4382 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4383
4384
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,...

Referenced by SignExt().

◆ SimpleSolver()

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

7411def SimpleSolver(ctx=None, logFile=None):
7412 """Return a simple general purpose solver with limited amount of preprocessing.
7413
7414 >>> s = SimpleSolver()
7415 >>> x = Int('x')
7416 >>> s.add(x > 0)
7417 >>> s.check()
7418 sat
7419 """
7420 ctx = _get_ctx(ctx)
7421 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7422
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.

Referenced by Solver.reason_unknown(), SimpleSolver(), and Solver.statistics().

◆ simplify()

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

8819def simplify(a, *arguments, **keywords):
8820 """Simplify the expression `a` using the given options.
8821
8822 This function has many options. Use `help_simplify` to obtain the complete list.
8823
8824 >>> x = Int('x')
8825 >>> y = Int('y')
8826 >>> simplify(x + 1 + y + x + 1)
8827 2 + 2*x + y
8828 >>> simplify((x + 1)*(y + 1), som=True)
8829 1 + x + y + x*y
8830 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8831 And(Not(x == y), Not(x == 1), Not(y == 1))
8832 >>> simplify(And(x == 0, y == 1), elim_and=True)
8833 Not(Or(Not(x == 0), Not(y == 1)))
8834 """
8835 if z3_debug():
8836 _z3_assert(is_expr(a), "Z3 expression expected")
8837 if len(arguments) > 0 or len(keywords) > 0:
8838 p = args2params(arguments, keywords, a.ctx)
8839 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8840 else:
8841 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8842
8843
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.

Referenced by BitVecRef.__invert__(), BitVecRef.__lshift__(), ArithRef.__mod__(), ArithRef.__neg__(), BitVecRef.__neg__(), ArithRef.__pow__(), ArithRef.__rpow__(), BitVecRef.__rshift__(), AlgebraicNumRef.approx(), AlgebraicNumRef.as_decimal(), BitVecs(), Concat(), Contains(), CreateDatatypes(), Distinct(), eq(), AstRef.eq(), Extract(), fpBVToFP(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), fpToFP(), fpUnsignedToFP(), AstRef.hash(), If(), IndexOf(), InRe(), is_algebraic_value(), is_true(), K(), Length(), Loop(), LShR(), Not(), Option(), Plus(), PrefixOf(), Q(), Range(), RatVal(), RecAddDefinition(), DatatypeSortRef.recognizer(), RepeatBitVec(), Replace(), RotateLeft(), RotateRight(), SignExt(), simplify(), Star(), StrToInt(), SuffixOf(), Union(), Xor(), and ZeroExt().

◆ simplify_param_descrs()

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

Definition at line 8849 of file z3py.py.

8849def simplify_param_descrs():
8850 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8851 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8852
8853
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.

◆ solve()

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

9081def solve(*args, **keywords):
9082 """Solve the constraints `*args`.
9083
9084 This is a simple function for creating demonstrations. It creates a solver,
9085 configure it using the options in `keywords`, adds the constraints
9086 in `args`, and invokes check.
9087
9088 >>> a = Int('a')
9089 >>> solve(a > 0, a < 2)
9090 [a = 1]
9091 """
9092 show = keywords.pop("show", False)
9093 s = Solver()
9094 s.set(**keywords)
9095 s.add(*args)
9096 if show:
9097 print(s)
9098 r = s.check()
9099 if r == unsat:
9100 print("no solution")
9101 elif r == unknown:
9102 print("failed to solve")
9103 try:
9104 print(s.model())
9105 except Z3Exception:
9106 return
9107 else:
9108 print(s.model())
9109
9110

Referenced by BV2Int(), IsInt(), and solve().

◆ solve_using()

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

9111def solve_using(s, *args, **keywords):
9112 """Solve the constraints `*args` using solver `s`.
9113
9114 This is a simple function for creating demonstrations. It is similar to `solve`,
9115 but it uses the given solver `s`.
9116 It configures solver `s` using the options in `keywords`, adds the constraints
9117 in `args`, and invokes check.
9118 """
9119 show = keywords.pop("show", False)
9120 if z3_debug():
9121 _z3_assert(isinstance(s, Solver), "Solver object expected")
9122 s.set(**keywords)
9123 s.add(*args)
9124 if show:
9125 print("Problem:")
9126 print(s)
9127 r = s.check()
9128 if r == unsat:
9129 print("no solution")
9130 elif r == unknown:
9131 print("failed to solve")
9132 try:
9133 print(s.model())
9134 except Z3Exception:
9135 return
9136 else:
9137 if show:
9138 print("Solution:")
9139 print(s.model())
9140
9141

◆ SolverFor()

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

7390def SolverFor(logic, ctx=None, logFile=None):
7391 """Create a solver customized for the given logic.
7392
7393 The parameter `logic` is a string. It should be contains
7394 the name of a SMT-LIB logic.
7395 See http://www.smtlib.org/ for the name of all available logics.
7396
7397 >>> s = SolverFor("QF_LIA")
7398 >>> x = Int('x')
7399 >>> s.add(x > 0)
7400 >>> s.add(x < 2)
7401 >>> s.check()
7402 sat
7403 >>> s.model()
7404 [x = 1]
7405 """
7406 ctx = _get_ctx(ctx)
7407 logic = to_symbol(logic)
7408 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7409
7410
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...

Referenced by SolverFor().

◆ Sqrt()

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

3403def Sqrt(a, ctx=None):
3404 """ Return a Z3 expression which represents the square root of a.
3405
3406 >>> x = Real('x')
3407 >>> Sqrt(x)
3408 x**(1/2)
3409 """
3410 if not is_expr(a):
3411 ctx = _get_ctx(ctx)
3412 a = RealVal(a, ctx)
3413 return a ** "1/2"
3414
3415

Referenced by AlgebraicNumRef.approx(), AlgebraicNumRef.as_decimal(), is_algebraic_value(), and Sqrt().

◆ SRem()

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

4270def SRem(a, b):
4271 """Create the Z3 expression signed remainder.
4272
4273 Use the operator % for signed modulus, and URem() for unsigned remainder.
4274
4275 >>> x = BitVec('x', 32)
4276 >>> y = BitVec('y', 32)
4277 >>> SRem(x, y)
4278 SRem(x, y)
4279 >>> SRem(x, y).sort()
4280 BitVec(32)
4281 >>> (x % y).sexpr()
4282 '(bvsmod x y)'
4283 >>> SRem(x, y).sexpr()
4284 '(bvsrem x y)'
4285 """
4286 _check_bv_args(a, b)
4287 a, b = _coerce_exprs(a, b)
4288 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4289
4290
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).

Referenced by BitVecRef.__mod__(), BitVecRef.__rmod__(), SRem(), and URem().

◆ Star()

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

11303def Star(re):
11304 """Create the regular expression accepting zero or more repetitions of argument.
11305 >>> re = Star(Re("a"))
11306 >>> print(simplify(InRe("aa", re)))
11307 True
11308 >>> print(simplify(InRe("ab", re)))
11309 False
11310 >>> print(simplify(InRe("", re)))
11311 True
11312 """
11313 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11314
11315
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.

Referenced by Star().

◆ Store()

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

4782def Store(a, *args):
4783 """Return a Z3 store array expression.
4784
4785 >>> a = Array('a', IntSort(), IntSort())
4786 >>> i, v = Ints('i v')
4787 >>> s = Store(a, i, v)
4788 >>> s.sort()
4789 Array(Int, Int)
4790 >>> prove(s[i] == v)
4791 proved
4792 >>> j = Int('j')
4793 >>> prove(Implies(i != j, s[j] == a[j]))
4794 proved
4795 """
4796 return Update(a, args)
4797
4798

Referenced by ModelRef.get_interp(), is_array(), is_store(), SetAdd(), SetDel(), and Store().

◆ StrFromCode()

def StrFromCode (   c)
Convert code to a string

Definition at line 11175 of file z3py.py.

11175def StrFromCode(c):
11176 """Convert code to a string"""
11177 if not is_expr(c):
11178 c = _py2expr(c)
11179 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11180
Z3_ast Z3_API Z3_mk_string_from_code(Z3_context c, Z3_ast a)
Code to string conversion.

◆ String()

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

10976def String(name, ctx=None):
10977 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10978
10979 >>> x = String('x')
10980 """
10981 ctx = _get_ctx(ctx)
10982 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10983
10984

Referenced by String(), and Strings().

◆ Strings()

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

Definition at line 10985 of file z3py.py.

10985def Strings(names, ctx=None):
10986 """Return a tuple of String constants. """
10987 ctx = _get_ctx(ctx)
10988 if isinstance(names, str):
10989 names = names.split(" ")
10990 return [String(name, ctx) for name in names]
10991
10992

Referenced by Contains().

◆ StringSort()

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

Definition at line 10794 of file z3py.py.

10794def StringSort(ctx=None):
10795 """Create a string sort
10796 >>> s = StringSort()
10797 >>> print(s)
10798 String
10799 """
10800 ctx = _get_ctx(ctx)
10801 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10802

Referenced by DisjointSum(), Empty(), Full(), SeqSortRef.is_string(), String(), and TupleSort().

◆ StringVal()

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

Definition at line 10969 of file z3py.py.

10969def StringVal(s, ctx=None):
10970 """create a string expression"""
10971 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
10972 ctx = _get_ctx(ctx)
10973 return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
10974
10975
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(), _coerce_seq(), _py2expr(), Empty(), Extract(), is_seq(), is_string(), is_string_value(), Length(), and Re().

◆ StrToCode()

def StrToCode (   s)
Convert a unit length string to integer code

Definition at line 11169 of file z3py.py.

11169def StrToCode(s):
11170 """Convert a unit length string to integer code"""
11171 if not is_expr(s):
11172 s = _py2expr(s)
11173 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11174
Z3_ast Z3_API Z3_mk_string_to_code(Z3_context c, Z3_ast a)
String to code conversion.

◆ StrToInt()

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

11146def StrToInt(s):
11147 """Convert string expression to integer
11148 >>> a = StrToInt("1")
11149 >>> simplify(1 == a)
11150 True
11151 >>> b = StrToInt("2")
11152 >>> simplify(1 == b)
11153 False
11154 >>> c = StrToInt(IntToStr(2))
11155 >>> simplify(1 == c)
11156 False
11157 """
11158 s = _coerce_seq(s)
11159 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11160
11161
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.

Referenced by StrToInt().

◆ SubSeq()

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

Definition at line 10998 of file z3py.py.

10998def SubSeq(s, offset, length):
10999 """Extract substring or subsequence starting at offset"""
11000 return Extract(s, offset, length)
11001
11002

◆ substitute()

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

8854def substitute(t, *m):
8855 """Apply substitution m on t, m is a list of pairs of the form (from, to).
8856 Every occurrence in t of from is replaced with to.
8857
8858 >>> x = Int('x')
8859 >>> y = Int('y')
8860 >>> substitute(x + 1, (x, y + 1))
8861 y + 1 + 1
8862 >>> f = Function('f', IntSort(), IntSort())
8863 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8864 1 + 1
8865 """
8866 if isinstance(m, tuple):
8867 m1 = _get_args(m)
8868 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8869 m = m1
8870 if z3_debug():
8871 _z3_assert(is_expr(t), "Z3 expression expected")
8872 _z3_assert(
8873 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
8874 "Z3 invalid substitution, expression pairs expected.")
8875 _z3_assert(
8876 all([p[0].sort().eq(p[1].sort()) for p in m]),
8877 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
8878 num = len(m)
8879 _from = (Ast * num)()
8880 _to = (Ast * num)()
8881 for i in range(num):
8882 _from[i] = m[i][0].as_ast()
8883 _to[i] = m[i][1].as_ast()
8884 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8885
8886
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....

Referenced by substitute().

◆ substitute_funs()

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

8907def substitute_funs(t, *m):
8908 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
8909 Every occurrence in to of the function from is replaced with the expression to.
8910 The expression to can have free variables, that refer to the arguments of from.
8911 For examples, see
8912 """
8913 if isinstance(m, tuple):
8914 m1 = _get_args(m)
8915 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8916 m = m1
8917 if z3_debug():
8918 _z3_assert(is_expr(t), "Z3 expression expected")
8919 _z3_assert(all([isinstance(p, tuple) and is_func_decl(p[0]) and is_expr(p[1]) for p in m]), "Z3 invalid substitution, funcion pairs expected.")
8920 num = len(m)
8921 _from = (FuncDecl * num)()
8922 _to = (Ast * num)()
8923 for i in range(num):
8924 _from[i] = m[i][0].as_func_decl()
8925 _to[i] = m[i][1].as_ast()
8926 return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8927
8928
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 funcions in from with new expressions in to.

◆ substitute_vars()

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

8887def substitute_vars(t, *m):
8888 """Substitute the free variables in t with the expression in m.
8889
8890 >>> v0 = Var(0, IntSort())
8891 >>> v1 = Var(1, IntSort())
8892 >>> x = Int('x')
8893 >>> f = Function('f', IntSort(), IntSort(), IntSort())
8894 >>> # replace v0 with x+1 and v1 with x
8895 >>> substitute_vars(f(v0, v1), x + 1, x)
8896 f(x + 1, x)
8897 """
8898 if z3_debug():
8899 _z3_assert(is_expr(t), "Z3 expression expected")
8900 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8901 num = len(m)
8902 _to = (Ast * num)()
8903 for i in range(num):
8904 _to[i] = m[i].as_ast()
8905 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8906
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,...

Referenced by substitute_vars().

◆ SubString()

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

Definition at line 10993 of file z3py.py.

10993def SubString(s, offset, length):
10994 """Extract substring or subsequence starting at offset"""
10995 return Extract(s, offset, length)
10996
10997

◆ SuffixOf()

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

11058def SuffixOf(a, b):
11059 """Check if 'a' is a suffix of 'b'
11060 >>> s1 = SuffixOf("ab", "abc")
11061 >>> simplify(s1)
11062 False
11063 >>> s2 = SuffixOf("bc", "abc")
11064 >>> simplify(s2)
11065 True
11066 """
11067 ctx = _get_ctx2(a, b)
11068 a = _coerce_seq(a, ctx)
11069 b = _coerce_seq(b, ctx)
11070 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11071
11072
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.

Referenced by SuffixOf().

◆ Sum()

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

8929def Sum(*args):
8930 """Create the sum of the Z3 expressions.
8931
8932 >>> a, b, c = Ints('a b c')
8933 >>> Sum(a, b, c)
8934 a + b + c
8935 >>> Sum([a, b, c])
8936 a + b + c
8937 >>> A = IntVector('a', 5)
8938 >>> Sum(A)
8939 a__0 + a__1 + a__2 + a__3 + a__4
8940 """
8941 args = _get_args(args)
8942 if len(args) == 0:
8943 return 0
8944 ctx = _ctx_from_ast_arg_list(args)
8945 if ctx is None:
8946 return _reduce(lambda a, b: a + b, args, 0)
8947 args = _coerce_expr_list(args, ctx)
8948 if is_bv(args[0]):
8949 return _reduce(lambda a, b: a + b, args, 0)
8950 else:
8951 _args, sz = _to_ast_array(args)
8952 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8953
8954
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].

Referenced by BitVecs(), Ints(), IntVector(), Reals(), RealVector(), and Sum().

◆ tactic_description()

def tactic_description (   name,
  ctx = None 
)
Return a short description for the tactic named `name`.

>>> d = tactic_description('simplify')

Definition at line 8508 of file z3py.py.

8508def tactic_description(name, ctx=None):
8509 """Return a short description for the tactic named `name`.
8510
8511 >>> d = tactic_description('simplify')
8512 """
8513 ctx = _get_ctx(ctx)
8514 return Z3_tactic_get_descr(ctx.ref(), name)
8515
8516
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.

Referenced by describe_tactics(), and tactic_description().

◆ tactics()

def tactics (   ctx = None)
Return a list of all available tactics in Z3.

>>> l = tactics()
>>> l.count('simplify') == 1
True

Definition at line 8497 of file z3py.py.

8497def tactics(ctx=None):
8498 """Return a list of all available tactics in Z3.
8499
8500 >>> l = tactics()
8501 >>> l.count('simplify') == 1
8502 True
8503 """
8504 ctx = _get_ctx(ctx)
8505 return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8506
8507
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.

Referenced by describe_tactics(), and tactics().

◆ Then()

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

8365def Then(*ts, **ks):
8366 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8367
8368 >>> x, y = Ints('x y')
8369 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8370 >>> t(And(x == 0, y > x + 1))
8371 [[Not(y <= 1)]]
8372 >>> t(And(x == 0, y > x + 1)).as_expr()
8373 Not(y <= 1)
8374 """
8375 return AndThen(*ts, **ks)
8376
8377

Referenced by Statistics.__getattr__(), Statistics.__getitem__(), Statistics.__len__(), ApplyResult.__len__(), Goal.convert_model(), Goal.depth(), Statistics.get_key_value(), Statistics.keys(), Repeat(), Tactic.solver(), and Then().

◆ to_Ast()

def to_Ast (   ptr)

Definition at line 11377 of file z3py.py.

11377def to_Ast(ptr,):
11378 ast = Ast(ptr)
11379 super(ctypes.c_void_p, ast).__init__(ptr)
11380 return ast
11381

Referenced by on_clause_eh(), user_prop_created(), user_prop_decide(), user_prop_diseq(), user_prop_eq(), and user_prop_fixed().

◆ to_AstVectorObj()

def to_AstVectorObj (   ptr)

Definition at line 11387 of file z3py.py.

11387def to_AstVectorObj(ptr,):
11388 v = AstVectorObj(ptr)
11389 super(ctypes.c_void_p, v).__init__(ptr)
11390 return v
11391
11392# NB. my-hacky-class only works for a single instance of OnClause
11393# it should be replaced with a proper correlation between OnClause
11394# and object references that can be passed over the FFI.
11395# for UserPropagator we use a global dictionary, which isn't great code.
11396

Referenced by on_clause_eh().

◆ to_ContextObj()

def to_ContextObj (   ptr)

Definition at line 11382 of file z3py.py.

11382def to_ContextObj(ptr,):
11383 ctx = ContextObj(ptr)
11384 super(ctypes.c_void_p, ctx).__init__(ptr)
11385 return ctx
11386

Referenced by user_prop_fresh().

◆ to_symbol()

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

Definition at line 124 of file z3py.py.

124def to_symbol(s, ctx=None):
125 """Convert an integer or string into a Z3 symbol."""
126 if _is_int(s):
127 return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
128 else:
129 return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
130
131
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.

Referenced by _dict2darray(), _dict2sarray(), _mk_quantifier(), Fixedpoint.add_rule(), Optimize.add_soft(), Array(), BitVec(), Bool(), Const(), CreateDatatypes(), DatatypeSort(), DeclareSort(), EnumSort(), FiniteDomainSort(), FP(), Function(), ParamDescrsRef.get_documentation(), ParamDescrsRef.get_kind(), Int(), PropagateFunction(), Real(), RecFunction(), ParamsRef.set(), Fixedpoint.set_predicate_representation(), SolverFor(), String(), and Fixedpoint.update_rule().

◆ ToInt()

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

3368def ToInt(a):
3369 """ Return the Z3 expression ToInt(a).
3370
3371 >>> x = Real('x')
3372 >>> x.sort()
3373 Real
3374 >>> n = ToInt(x)
3375 >>> n
3376 ToInt(x)
3377 >>> n.sort()
3378 Int
3379 """
3380 if z3_debug():
3381 _z3_assert(a.is_real(), "Z3 real expression expected.")
3382 ctx = a.ctx
3383 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3384
3385
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.

Referenced by is_to_int(), and ToInt().

◆ ToReal()

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

3350def ToReal(a):
3351 """ Return the Z3 expression ToReal(a).
3352
3353 >>> x = Int('x')
3354 >>> x.sort()
3355 Int
3356 >>> n = ToReal(x)
3357 >>> n
3358 ToReal(x)
3359 >>> n.sort()
3360 Real
3361 """
3362 if z3_debug():
3363 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3364 ctx = a.ctx
3365 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3366
3367
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.

Referenced by FuncDeclRef.__call__(), ArithRef.__ge__(), ArithRef.__gt__(), ArithRef.__le__(), ArithRef.__lt__(), SortRef.cast(), is_to_real(), and ToReal().

◆ TransitiveClosure()

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

11370def TransitiveClosure(f):
11371 """Given a binary relation R, such that the two arguments have the same sort
11372 create the transitive closure relation R+.
11373 The transitive closure R+ is a new relation.
11374 """
11375 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11376
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.

◆ TreeOrder()

def TreeOrder (   a,
  index 
)

Definition at line 11362 of file z3py.py.

11362def TreeOrder(a, index):
11363 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11364
11365
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()

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

8488def TryFor(t, ms, ctx=None):
8489 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8490
8491 If `t` does not terminate in `ms` milliseconds, then it fails.
8492 """
8493 t = _to_tactic(t, ctx)
8494 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8495
8496
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()

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

5355def TupleSort(name, sorts, ctx=None):
5356 """Create a named tuple sort base on a set of underlying sorts
5357 Example:
5358 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5359 """
5360 tuple = Datatype(name, ctx)
5361 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5362 tuple.declare(name, *projects)
5363 tuple = tuple.create()
5364 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5365
5366

Referenced by TupleSort().

◆ UDiv()

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

4228def UDiv(a, b):
4229 """Create the Z3 expression (unsigned) division `self / other`.
4230
4231 Use the operator / for signed division.
4232
4233 >>> x = BitVec('x', 32)
4234 >>> y = BitVec('y', 32)
4235 >>> UDiv(x, y)
4236 UDiv(x, y)
4237 >>> UDiv(x, y).sort()
4238 BitVec(32)
4239 >>> (x / y).sexpr()
4240 '(bvsdiv x y)'
4241 >>> UDiv(x, y).sexpr()
4242 '(bvudiv x y)'
4243 """
4244 _check_bv_args(a, b)
4245 a, b = _coerce_exprs(a, b)
4246 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4247
4248
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.

Referenced by BitVecRef.__div__(), BitVecRef.__rdiv__(), and UDiv().

◆ UGE()

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

4192def UGE(a, b):
4193 """Create the Z3 expression (unsigned) `other >= self`.
4194
4195 Use the operator >= for signed greater than or equal to.
4196
4197 >>> x, y = BitVecs('x y', 32)
4198 >>> UGE(x, y)
4199 UGE(x, y)
4200 >>> (x >= y).sexpr()
4201 '(bvsge x y)'
4202 >>> UGE(x, y).sexpr()
4203 '(bvuge x y)'
4204 """
4205 _check_bv_args(a, b)
4206 a, b = _coerce_exprs(a, b)
4207 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4208
4209
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.

Referenced by BitVecRef.__ge__(), and UGE().

◆ UGT()

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

4210def UGT(a, b):
4211 """Create the Z3 expression (unsigned) `other > self`.
4212
4213 Use the operator > for signed greater than.
4214
4215 >>> x, y = BitVecs('x y', 32)
4216 >>> UGT(x, y)
4217 UGT(x, y)
4218 >>> (x > y).sexpr()
4219 '(bvsgt x y)'
4220 >>> UGT(x, y).sexpr()
4221 '(bvugt x y)'
4222 """
4223 _check_bv_args(a, b)
4224 a, b = _coerce_exprs(a, b)
4225 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4226
4227
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.

Referenced by BitVecRef.__gt__(), and UGT().

◆ ULE()

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

4156def ULE(a, b):
4157 """Create the Z3 expression (unsigned) `other <= self`.
4158
4159 Use the operator <= for signed less than or equal to.
4160
4161 >>> x, y = BitVecs('x y', 32)
4162 >>> ULE(x, y)
4163 ULE(x, y)
4164 >>> (x <= y).sexpr()
4165 '(bvsle x y)'
4166 >>> ULE(x, y).sexpr()
4167 '(bvule x y)'
4168 """
4169 _check_bv_args(a, b)
4170 a, b = _coerce_exprs(a, b)
4171 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4172
4173
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.

Referenced by BitVecRef.__le__(), and ULE().

◆ ULT()

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

4174def ULT(a, b):
4175 """Create the Z3 expression (unsigned) `other < self`.
4176
4177 Use the operator < for signed less than.
4178
4179 >>> x, y = BitVecs('x y', 32)
4180 >>> ULT(x, y)
4181 ULT(x, y)
4182 >>> (x < y).sexpr()
4183 '(bvslt x y)'
4184 >>> ULT(x, y).sexpr()
4185 '(bvult x y)'
4186 """
4187 _check_bv_args(a, b)
4188 a, b = _coerce_exprs(a, b)
4189 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4190
4191
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.

Referenced by BitVecRef.__lt__(), and ULT().

◆ Union()

def Union ( args)
Create union of regular expressions.
>>> re = Union(Re("a"), Re("b"), Re("c"))
>>> print (simplify(InRe("d", re)))
False

Definition at line 11234 of file z3py.py.

11234def Union(*args):
11235 """Create union of regular expressions.
11236 >>> re = Union(Re("a"), Re("b"), Re("c"))
11237 >>> print (simplify(InRe("d", re)))
11238 False
11239 """
11240 args = _get_args(args)
11241 sz = len(args)
11242 if z3_debug():
11243 _z3_assert(sz > 0, "At least one argument expected.")
11244 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11245 if sz == 1:
11246 return args[0]
11247 ctx = args[0].ctx
11248 v = (Ast * sz)()
11249 for i in range(sz):
11250 v[i] = args[i].as_ast()
11251 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11252
11253
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.

Referenced by ReRef.__add__(), InRe(), and Union().

◆ Unit()

def Unit (   a)
Create a singleton sequence

Definition at line 11038 of file z3py.py.

11038def Unit(a):
11039 """Create a singleton sequence"""
11040 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11041
11042
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.

Referenced by is_seq(), Re(), and SeqSort().

◆ Update()

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

4739def Update(a, *args):
4740 """Return a Z3 store array expression.
4741
4742 >>> a = Array('a', IntSort(), IntSort())
4743 >>> i, v = Ints('i v')
4744 >>> s = Update(a, i, v)
4745 >>> s.sort()
4746 Array(Int, Int)
4747 >>> prove(s[i] == v)
4748 proved
4749 >>> j = Int('j')
4750 >>> prove(Implies(i != j, s[j] == a[j]))
4751 proved
4752 """
4753 if z3_debug():
4754 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4755 args = _get_args(args)
4756 ctx = a.ctx
4757 if len(args) <= 1:
4758 raise Z3Exception("array update requires index and value arguments")
4759 if len(args) == 2:
4760 i = args[0]
4761 v = args[1]
4762 i = a.sort().domain().cast(i)
4763 v = a.sort().range().cast(v)
4764 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4765 v = a.sort().range().cast(args[-1])
4766 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4767 _args, sz = _to_ast_array(idxs)
4768 return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4769
4770
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs, Z3_ast v)
n-ary Array update.

Referenced by Store(), and Update().

◆ URem()

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

4249def URem(a, b):
4250 """Create the Z3 expression (unsigned) remainder `self % other`.
4251
4252 Use the operator % for signed modulus, and SRem() for signed remainder.
4253
4254 >>> x = BitVec('x', 32)
4255 >>> y = BitVec('y', 32)
4256 >>> URem(x, y)
4257 URem(x, y)
4258 >>> URem(x, y).sort()
4259 BitVec(32)
4260 >>> (x % y).sexpr()
4261 '(bvsmod x y)'
4262 >>> URem(x, y).sexpr()
4263 '(bvurem x y)'
4264 """
4265 _check_bv_args(a, b)
4266 a, b = _coerce_exprs(a, b)
4267 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4268
4269
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.

Referenced by BitVecRef.__mod__(), BitVecRef.__rmod__(), SRem(), and URem().

◆ user_prop_created()

def user_prop_created (   ctx,
  cb,
  id 
)

Definition at line 11496 of file z3py.py.

11496def user_prop_created(ctx, cb, id):
11497 prop = _prop_closures.get(ctx)
11498 prop.cb = cb
11499 id = _to_expr_ref(to_Ast(id), prop.ctx())
11500 prop.created(id)
11501 prop.cb = None
11502

◆ user_prop_decide()

def user_prop_decide (   ctx,
  cb,
  t_ref,
  idx_ref,
  phase_ref 
)

Definition at line 11527 of file z3py.py.

11527def user_prop_decide(ctx, cb, t_ref, idx_ref, phase_ref):
11528 prop = _prop_closures.get(ctx)
11529 prop.cb = cb
11530 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11531 t, idx, phase = prop.decide(t, idx, phase)
11532 t_ref = t
11533 idx_ref = idx
11534 phase_ref = phase
11535 prop.cb = None
11536
11537

◆ user_prop_diseq()

def user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11517 of file z3py.py.

11517def user_prop_diseq(ctx, cb, x, y):
11518 prop = _prop_closures.get(ctx)
11519 prop.cb = cb
11520 x = _to_expr_ref(to_Ast(x), prop.ctx())
11521 y = _to_expr_ref(to_Ast(y), prop.ctx())
11522 prop.diseq(x, y)
11523 prop.cb = None
11524
11525# TODO The decision callback is not fully implemented.
11526# It needs to handle the ast*, unsigned* idx, and Z3_lbool*

◆ user_prop_eq()

def user_prop_eq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11509 of file z3py.py.

11509def user_prop_eq(ctx, cb, x, y):
11510 prop = _prop_closures.get(ctx)
11511 prop.cb = cb
11512 x = _to_expr_ref(to_Ast(x), prop.ctx())
11513 y = _to_expr_ref(to_Ast(y), prop.ctx())
11514 prop.eq(x, y)
11515 prop.cb = None
11516

◆ user_prop_final()

def user_prop_final (   ctx,
  cb 
)

Definition at line 11503 of file z3py.py.

11503def user_prop_final(ctx, cb):
11504 prop = _prop_closures.get(ctx)
11505 prop.cb = cb
11506 prop.final()
11507 prop.cb = None
11508

◆ user_prop_fixed()

def user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 11488 of file z3py.py.

11488def user_prop_fixed(ctx, cb, id, value):
11489 prop = _prop_closures.get(ctx)
11490 prop.cb = cb
11491 id = _to_expr_ref(to_Ast(id), prop.ctx())
11492 value = _to_expr_ref(to_Ast(value), prop.ctx())
11493 prop.fixed(id, value)
11494 prop.cb = None
11495

◆ user_prop_fresh()

def user_prop_fresh (   ctx,
  _new_ctx 
)

Definition at line 11474 of file z3py.py.

11474def user_prop_fresh(ctx, _new_ctx):
11475 _prop_closures.set_threaded()
11476 prop = _prop_closures.get(ctx)
11477 nctx = Context()
11478 Z3_del_context(nctx.ctx)
11479 new_ctx = to_ContextObj(_new_ctx)
11480 nctx.ctx = new_ctx
11481 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11482 nctx.owner = False
11483 new_prop = prop.fresh(nctx)
11484 _prop_closures.set(new_prop.id, new_prop)
11485 return new_prop.id
11486
11487
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.

◆ user_prop_pop()

def user_prop_pop (   ctx,
  cb,
  num_scopes 
)

Definition at line 11468 of file z3py.py.

11468def user_prop_pop(ctx, cb, num_scopes):
11469 prop = _prop_closures.get(ctx)
11470 prop.cb = cb
11471 prop.pop(num_scopes)
11472
11473

◆ user_prop_push()

def user_prop_push (   ctx,
  cb 
)

Definition at line 11462 of file z3py.py.

11462def user_prop_push(ctx, cb):
11463 prop = _prop_closures.get(ctx)
11464 prop.cb = cb
11465 prop.push()
11466
11467

◆ Var()

def Var (   idx,
  s 
)
Create a Z3 free variable. Free variables are used to create quantified formulas.
A free variable with index n is bound when it occurs within the scope of n+1 quantified
declarations.

>>> Var(0, IntSort())
Var(0)
>>> eq(Var(0, IntSort()), Var(0, BoolSort()))
False

Definition at line 1466 of file z3py.py.

1466def Var(idx, s):
1467 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1468 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1469 declarations.
1470
1471 >>> Var(0, IntSort())
1472 Var(0)
1473 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1474 False
1475 """
1476 if z3_debug():
1477 _z3_assert(is_sort(s), "Z3 sort expected")
1478 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1479
1480
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a variable.

Referenced by QuantifierRef.body(), QuantifierRef.children(), get_var_index(), is_pattern(), is_var(), MultiPattern(), QuantifierRef.pattern(), RealVar(), RealVarVector(), substitute_vars(), and Var().

◆ When()

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

8782def When(p, t, ctx=None):
8783 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8784 Otherwise, it returns the input goal unmodified.
8785
8786 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8787 >>> x, y = Ints('x y')
8788 >>> g = Goal()
8789 >>> g.add(x > 0)
8790 >>> g.add(y > 0)
8791 >>> t(g)
8792 [[x > 0, y > 0]]
8793 >>> g.add(x == y + 1)
8794 >>> t(g)
8795 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8796 """
8797 p = _to_probe(p, ctx)
8798 t = _to_tactic(t, ctx)
8799 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8800
8801
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...

Referenced by When().

◆ With()

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

8439def With(t, *args, **keys):
8440 """Return a tactic that applies tactic `t` using the given configuration options.
8441
8442 >>> x, y = Ints('x y')
8443 >>> t = With(Tactic('simplify'), som=True)
8444 >>> t((x + 1)*(y + 2) == 0)
8445 [[2*x + y + x*y == -2]]
8446 """
8447 ctx = keys.pop("ctx", None)
8448 t = _to_tactic(t, ctx)
8449 p = args2params(args, keys, t.ctx)
8450 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8451
8452
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.

Referenced by Goal.prec(), and With().

◆ WithParams()

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

8453def WithParams(t, p):
8454 """Return a tactic that applies tactic `t` using the given configuration options.
8455
8456 >>> x, y = Ints('x y')
8457 >>> p = ParamsRef()
8458 >>> p.set("som", True)
8459 >>> t = WithParams(Tactic('simplify'), p)
8460 >>> t((x + 1)*(y + 2) == 0)
8461 [[2*x + y + x*y == -2]]
8462 """
8463 t = _to_tactic(t, None)
8464 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8465
8466

Referenced by WithParams().

◆ Xor()

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

1795def Xor(a, b, ctx=None):
1796 """Create a Z3 Xor expression.
1797
1798 >>> p, q = Bools('p q')
1799 >>> Xor(p, q)
1800 Xor(p, q)
1801 >>> simplify(Xor(p, q))
1802 Not(p == q)
1803 """
1804 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1805 s = BoolSort(ctx)
1806 a = s.cast(a)
1807 b = s.cast(b)
1808 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1809
1810
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 Xor().

◆ z3_debug()

def z3_debug ( )

Definition at line 62 of file z3py.py.

62def z3_debug():
63 global Z3_DEBUG
64 return Z3_DEBUG
65
66

Referenced by Probe.__call__(), QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), _and_then(), _check_bv_args(), _check_fp_args(), _coerce_expr_merge(), _ctx_from_ast_arg_list(), _dict2darray(), _dict2sarray(), _mk_bin(), _mk_fp_bin(), _mk_fp_bin_norm(), _mk_fp_bin_pred(), _mk_fp_tern(), _mk_fp_unary(), _mk_fp_unary_pred(), _mk_quantifier(), _or_else(), _pb_args_coeffs(), _probe_nary(), _prove_html(), _py2expr(), _solve_using_html(), _to_float_str(), _to_sort_ref(), DatatypeSortRef.accessor(), And(), AndThen(), Tactic.apply(), ExprRef.arg(), args2params(), ArraySort(), IntNumRef.as_long(), AtLeast(), AtMost(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), Distinct(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FiniteDomainVal(), fpToFPUnsigned(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), Intersect(), IsInt(), K(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), OrElse(), ParOr(), ParThen(), QuantifierRef.pattern(), PropagateFunction(), prove(), RatVal(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), simplify(), solve_using(), substitute(), substitute_funs(), substitute_vars(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Solver.translate(), Union(), Update(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().

◆ z3_error_handler()

def z3_error_handler (   c,
  e 
)

Definition at line 174 of file z3py.py.

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

◆ ZeroExt()

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

4385def ZeroExt(n, a):
4386 """Return a bit-vector expression with `n` extra zero-bits.
4387
4388 >>> x = BitVec('x', 16)
4389 >>> n = ZeroExt(8, x)
4390 >>> n.size()
4391 24
4392 >>> n
4393 ZeroExt(8, x)
4394 >>> n.sort()
4395 BitVec(24)
4396 >>> v0 = BitVecVal(2, 2)
4397 >>> v0
4398 2
4399 >>> v0.size()
4400 2
4401 >>> v = simplify(ZeroExt(6, v0))
4402 >>> v
4403 2
4404 >>> v.size()
4405 8
4406 """
4407 if z3_debug():
4408 _z3_assert(_is_int(n), "First argument must be an integer")
4409 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4410 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4411
4412
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,...

Referenced by ZeroExt().

Variable Documentation

◆ _dflt_fpsort_ebits

int _dflt_fpsort_ebits = 11
protected

Definition at line 9334 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

Definition at line 9335 of file z3py.py.

◆ _dflt_rounding_mode

Floating-Point Arithmetic.

Definition at line 9333 of file z3py.py.

◆ _main_ctx

None _main_ctx = None
protected

Definition at line 236 of file z3py.py.

◆ _my_hacky_class

None _my_hacky_class = None
protected

Definition at line 11397 of file z3py.py.

◆ _on_clause_eh

Z3_on_clause_eh _on_clause_eh = Z3_on_clause_eh(on_clause_eh)
protected

Definition at line 11404 of file z3py.py.

◆ _on_model_eh

on_model_eh_type _on_model_eh = on_model_eh_type(_global_on_model)
protected

Definition at line 7855 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 7847 of file z3py.py.

◆ _prop_closures

None _prop_closures = None
protected

Definition at line 11453 of file z3py.py.

◆ _ROUNDING_MODES

frozenset _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 9353 of file z3py.py.

◆ _user_prop_created

Z3_created_eh _user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11542 of file z3py.py.

◆ _user_prop_decide

Z3_decide_eh _user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11546 of file z3py.py.

◆ _user_prop_diseq

Z3_eq_eh _user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11545 of file z3py.py.

◆ _user_prop_eq

Z3_eq_eh _user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11544 of file z3py.py.

◆ _user_prop_final

Z3_final_eh _user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11543 of file z3py.py.

◆ _user_prop_fixed

Z3_fixed_eh _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11541 of file z3py.py.

◆ _user_prop_fresh

Z3_fresh_eh _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11540 of file z3py.py.

◆ _user_prop_pop

Z3_pop_eh _user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11539 of file z3py.py.

◆ _user_prop_push

Z3_push_eh _user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11538 of file z3py.py.

◆ else

else :

Definition at line 70 of file z3py.py.

◆ sat

Definition at line 6884 of file z3py.py.

◆ unknown

Definition at line 6886 of file z3py.py.

◆ unsat

Definition at line 6885 of file z3py.py.

◆ Z3_DEBUG

__debug__ Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.