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

8281def _and_then(t1, t2, ctx=None):
8282 t1 = _to_tactic(t1, ctx)
8283 t2 = _to_tactic(t2, ctx)
8284 if z3_debug():
8285 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8286 return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8287
8288
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 4598 of file z3py.py.

4598def _array_select(ar, arg):
4599 if isinstance(arg, tuple):
4600 args = [ar.sort().domain_n(i).cast(arg[i]) for i in range(len(arg))]
4601 _args, sz = _to_ast_array(args)
4602 return _to_expr_ref(Z3_mk_select_n(ar.ctx_ref(), ar.as_ast(), sz, _args), ar.ctx)
4603 arg = ar.sort().domain().cast(arg)
4604 return _to_expr_ref(Z3_mk_select(ar.ctx_ref(), ar.as_ast(), arg.as_ast()), ar.ctx)
4605
4606
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 4159 of file z3py.py.

4159def _check_bv_args(a, b):
4160 if z3_debug():
4161 _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
4162
4163

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

10383def _check_fp_args(a, b):
10384 if z3_debug():
10385 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10386
10387

◆ _coerce_char()

def _coerce_char (   ch,
  ctx = None 
)
protected

Definition at line 10823 of file z3py.py.

10823def _coerce_char(ch, ctx=None):
10824 if isinstance(ch, str):
10825 ctx = _get_ctx(ctx)
10826 ch = CharVal(ch, ctx)
10827 if not is_expr(ch):
10828 raise Z3Exception("Character expression expected")
10829 return ch
10830

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

◆ _coerce_expr_list()

def _coerce_expr_list (   alist,
  ctx = None 
)
protected

Definition at line 1230 of file z3py.py.

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

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

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

Referenced by _coerce_exprs().

◆ _coerce_exprs()

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

Definition at line 1202 of file z3py.py.

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

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

9342def _coerce_fp_expr_list(alist, ctx):
9343 first_fp_sort = None
9344 for a in alist:
9345 if is_fp(a):
9346 if first_fp_sort is None:
9347 first_fp_sort = a.sort()
9348 elif first_fp_sort == a.sort():
9349 pass # OK, same as before
9350 else:
9351 # we saw at least 2 different float sorts; something will
9352 # throw a sort mismatch later, for now assume None.
9353 first_fp_sort = None
9354 break
9355
9356 r = []
9357 for i in range(len(alist)):
9358 a = alist[i]
9359 is_repr = isinstance(a, str) and a.contains("2**(") and a.endswith(")")
9360 if is_repr or _is_int(a) or isinstance(a, (float, bool)):
9361 r.append(FPVal(a, None, first_fp_sort, ctx))
9362 else:
9363 r.append(a)
9364 return _coerce_expr_list(r, ctx)
9365
9366
9367# FP Sorts
9368

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

10873def _coerce_seq(s, ctx=None):
10874 if isinstance(s, str):
10875 ctx = _get_ctx(ctx)
10876 s = StringVal(s, ctx)
10877 if not is_expr(s):
10878 raise Z3Exception("Non-expression passed as a sequence")
10879 if not is_seq(s):
10880 raise Z3Exception("Non-sequence passed as a sequence")
10881 return s
10882
10883

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

9338def _dflt_fps(ctx=None):
9339 return get_default_fp_sort(ctx)
9340
9341

Referenced by FPVal().

◆ _dflt_rm()

def _dflt_rm (   ctx = None)
protected

Definition at line 9334 of file z3py.py.

9334def _dflt_rm(ctx=None):
9335 return get_default_rounding_mode(ctx)
9336
9337

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

9207def _dict2darray(decls, ctx):
9208 sz = len(decls)
9209 _names = (Symbol * sz)()
9210 _decls = (FuncDecl * sz)()
9211 i = 0
9212 for k in decls:
9213 v = decls[k]
9214 if z3_debug():
9215 _z3_assert(isinstance(k, str), "String expected")
9216 _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
9217 _names[i] = to_symbol(k, ctx)
9218 if is_const(v):
9219 _decls[i] = v.decl().ast
9220 else:
9221 _decls[i] = v.ast
9222 i = i + 1
9223 return sz, _names, _decls
9224

Referenced by parse_smt2_file(), and parse_smt2_string().

◆ _dict2sarray()

def _dict2sarray (   sorts,
  ctx 
)
protected

Definition at line 9191 of file z3py.py.

9191def _dict2sarray(sorts, ctx):
9192 sz = len(sorts)
9193 _names = (Symbol * sz)()
9194 _sorts = (Sort * sz)()
9195 i = 0
9196 for k in sorts:
9197 v = sorts[k]
9198 if z3_debug():
9199 _z3_assert(isinstance(k, str), "String expected")
9200 _z3_assert(is_sort(v), "Z3 sort expected")
9201 _names[i] = to_symbol(k, ctx)
9202 _sorts[i] = v.ast
9203 i = i + 1
9204 return sz, _names, _sorts
9205
9206

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

10884def _get_ctx2(a, b, ctx=None):
10885 if is_expr(a):
10886 return a.ctx
10887 if is_expr(b):
10888 return b.ctx
10889 if ctx is None:
10890 ctx = main_ctx()
10891 return ctx
10892
10893

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

◆ _global_on_model()

def _global_on_model (   ctx)
protected

Definition at line 7858 of file z3py.py.

7858def _global_on_model(ctx):
7859 (fn, mdl) = _on_models[ctx]
7860 fn(mdl)
7861
7862

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

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

Referenced by And(), and Or().

◆ _is_algebraic()

def _is_algebraic (   ctx,
  a 
)
protected

Definition at line 2728 of file z3py.py.

2728def _is_algebraic(ctx, a):
2729 return Z3_is_algebraic_number(ctx.ref(), a)
2730
2731
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 2724 of file z3py.py.

2724def _is_numeral(ctx, a):
2725 return Z3_is_numeral_ast(ctx.ref(), a)
2726
2727
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 1428 of file z3py.py.

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

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

10171def _mk_fp_bin(f, rm, a, b, ctx):
10172 ctx = _get_ctx(ctx)
10173 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10174 if z3_debug():
10175 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10176 _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
10177 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
10178
10179

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

◆ _mk_fp_bin_norm()

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

Definition at line 10180 of file z3py.py.

10180def _mk_fp_bin_norm(f, a, b, ctx):
10181 ctx = _get_ctx(ctx)
10182 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10183 if z3_debug():
10184 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10185 return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10186
10187

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

◆ _mk_fp_bin_pred()

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

Definition at line 10188 of file z3py.py.

10188def _mk_fp_bin_pred(f, a, b, ctx):
10189 ctx = _get_ctx(ctx)
10190 [a, b] = _coerce_fp_expr_list([a, b], ctx)
10191 if z3_debug():
10192 _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
10193 return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
10194
10195

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

10196def _mk_fp_tern(f, rm, a, b, c, ctx):
10197 ctx = _get_ctx(ctx)
10198 [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
10199 if z3_debug():
10200 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10201 _z3_assert(is_fp(a) or is_fp(b) or is_fp(
10202 c), "Second, third or fourth argument must be a Z3 floating-point expression")
10203 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
10204
10205

Referenced by fpFMA().

◆ _mk_fp_unary()

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

Definition at line 10154 of file z3py.py.

10154def _mk_fp_unary(f, rm, a, ctx):
10155 ctx = _get_ctx(ctx)
10156 [a] = _coerce_fp_expr_list([a], ctx)
10157 if z3_debug():
10158 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10159 _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
10160 return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
10161
10162

Referenced by fpRoundToIntegral(), and fpSqrt().

◆ _mk_fp_unary_pred()

def _mk_fp_unary_pred (   f,
  a,
  ctx 
)
protected

Definition at line 10163 of file z3py.py.

10163def _mk_fp_unary_pred(f, a, ctx):
10164 ctx = _get_ctx(ctx)
10165 [a] = _coerce_fp_expr_list([a], ctx)
10166 if z3_debug():
10167 _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
10168 return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
10169
10170

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

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

8289def _or_else(t1, t2, ctx=None):
8290 t1 = _to_tactic(t1, ctx)
8291 t2 = _to_tactic(t2, ctx)
8292 if z3_debug():
8293 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8294 return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8295
8296
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 8980 of file z3py.py.

8980def _pb_args_coeffs(args, default_ctx=None):
8981 args = _get_args_ast_list(args)
8982 if len(args) == 0:
8983 return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
8984 args = [_reorder_pb_arg(arg) for arg in args]
8985 args, coeffs = zip(*args)
8986 if z3_debug():
8987 _z3_assert(len(args) > 0, "Non empty list of arguments expected")
8988 ctx = _ctx_from_ast_arg_list(args)
8989 if z3_debug():
8990 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8991 args = _coerce_expr_list(args, ctx)
8992 _args, sz = _to_ast_array(args)
8993 _coeffs = (ctypes.c_int * len(coeffs))()
8994 for i in range(len(coeffs)):
8995 _z3_check_cint_overflow(coeffs[i], "coefficient")
8996 _coeffs[i] = coeffs[i]
8997 return ctx, sz, _args, _coeffs, args
8998
8999

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

◆ _probe_and()

def _probe_and (   args,
  ctx 
)
protected

Definition at line 8704 of file z3py.py.

8704def _probe_and(args, ctx):
8705 return _probe_nary(Z3_probe_and, args, ctx)
8706
8707

Referenced by And().

◆ _probe_nary()

def _probe_nary (   f,
  args,
  ctx 
)
protected

Definition at line 8694 of file z3py.py.

8694def _probe_nary(f, args, ctx):
8695 if z3_debug():
8696 _z3_assert(len(args) > 0, "At least one argument expected")
8697 num = len(args)
8698 r = _to_probe(args[0], ctx)
8699 for i in range(num - 1):
8700 r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i + 1], ctx).probe), ctx)
8701 return r
8702
8703

Referenced by _probe_and(), and _probe_or().

◆ _probe_or()

def _probe_or (   args,
  ctx 
)
protected

Definition at line 8708 of file z3py.py.

8708def _probe_or(args, ctx):
8709 return _probe_nary(Z3_probe_or, args, ctx)
8710
8711

Referenced by Or().

◆ _prove_html()

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

Definition at line 9171 of file z3py.py.

9171def _prove_html(claim, show=False, **keywords):
9172 """Version of function `prove` that renders HTML."""
9173 if z3_debug():
9174 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9175 s = Solver()
9176 s.set(**keywords)
9177 s.add(Not(claim))
9178 if show:
9179 print(s)
9180 r = s.check()
9181 if r == unsat:
9182 print("<b>proved</b>")
9183 elif r == unknown:
9184 print("<b>failed to prove</b>")
9185 print(s.model())
9186 else:
9187 print("<b>counterexample</b>")
9188 print(s.model())
9189
9190

◆ _py2expr()

def _py2expr (   a,
  ctx = None 
)
protected

Definition at line 3123 of file z3py.py.

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

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

1223def _reduce(func, sequence, initial):
1224 result = initial
1225 for element in sequence:
1226 result = func(result, element)
1227 return result
1228
1229

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

◆ _reorder_pb_arg()

def _reorder_pb_arg (   arg)
protected

Definition at line 8973 of file z3py.py.

8973def _reorder_pb_arg(arg):
8974 a, b = arg
8975 if not _is_int(b) and _is_int(a):
8976 return b, a
8977 return arg
8978
8979

Referenced by _pb_args_coeffs().

◆ _solve_html()

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

Definition at line 9122 of file z3py.py.

9122def _solve_html(*args, **keywords):
9123 """Version of function `solve` that renders HTML output."""
9124 show = keywords.pop("show", False)
9125 s = Solver()
9126 s.set(**keywords)
9127 s.add(*args)
9128 if show:
9129 print("<b>Problem:</b>")
9130 print(s)
9131 r = s.check()
9132 if r == unsat:
9133 print("<b>no solution</b>")
9134 elif r == unknown:
9135 print("<b>failed to solve</b>")
9136 try:
9137 print(s.model())
9138 except Z3Exception:
9139 return
9140 else:
9141 if show:
9142 print("<b>Solution:</b>")
9143 print(s.model())
9144
9145

◆ _solve_using_html()

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

Definition at line 9146 of file z3py.py.

9146def _solve_using_html(s, *args, **keywords):
9147 """Version of function `solve_using` that renders HTML."""
9148 show = keywords.pop("show", False)
9149 if z3_debug():
9150 _z3_assert(isinstance(s, Solver), "Solver object expected")
9151 s.set(**keywords)
9152 s.add(*args)
9153 if show:
9154 print("<b>Problem:</b>")
9155 print(s)
9156 r = s.check()
9157 if r == unsat:
9158 print("<b>no solution</b>")
9159 elif r == unknown:
9160 print("<b>failed to solve</b>")
9161 try:
9162 print(s.model())
9163 except Z3Exception:
9164 return
9165 else:
9166 if show:
9167 print("<b>Solution:</b>")
9168 print(s.model())
9169
9170

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

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

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

9916def _to_float_str(val, exp=0):
9917 if isinstance(val, float):
9918 if math.isnan(val):
9919 res = "NaN"
9920 elif val == 0.0:
9921 sone = math.copysign(1.0, val)
9922 if sone < 0.0:
9923 return "-0.0"
9924 else:
9925 return "+0.0"
9926 elif val == float("+inf"):
9927 res = "+oo"
9928 elif val == float("-inf"):
9929 res = "-oo"
9930 else:
9931 v = val.as_integer_ratio()
9932 num = v[0]
9933 den = v[1]
9934 rvs = str(num) + "/" + str(den)
9935 res = rvs + "p" + _to_int_str(exp)
9936 elif isinstance(val, bool):
9937 if val:
9938 res = "1.0"
9939 else:
9940 res = "0.0"
9941 elif _is_int(val):
9942 res = str(val)
9943 elif isinstance(val, str):
9944 inx = val.find("*(2**")
9945 if inx == -1:
9946 res = val
9947 elif val[-1] == ")":
9948 res = val[0:inx]
9949 exp = str(int(val[inx + 5:-1]) + int(exp))
9950 else:
9951 _z3_assert(False, "String does not have floating-point numeral form.")
9952 elif z3_debug():
9953 _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
9954 if exp == 0:
9955 return res
9956 else:
9957 return res + "p" + exp
9958
9959

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

905def _to_func_decl_ref(a, ctx):
906 return FuncDeclRef(a, ctx)
907
908

Referenced by _to_ast_ref().

◆ _to_goal()

def _to_goal (   a)
protected

Definition at line 8265 of file z3py.py.

8265def _to_goal(a):
8266 if isinstance(a, BoolRef):
8267 goal = Goal(ctx=a.ctx)
8268 goal.add(a)
8269 return goal
8270 else:
8271 return a
8272
8273

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

◆ _to_int_str()

def _to_int_str (   val)
protected

Definition at line 3172 of file z3py.py.

3172def _to_int_str(val):
3173 if isinstance(val, float):
3174 return str(int(val))
3175 elif isinstance(val, bool):
3176 if val:
3177 return "1"
3178 else:
3179 return "0"
3180 elif _is_int(val):
3181 return str(val)
3182 elif isinstance(val, str):
3183 return val
3184 if z3_debug():
3185 _z3_assert(False, "Python value cannot be used as a Z3 integer")
3186
3187

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

1975def _to_pattern(arg):
1976 if is_pattern(arg):
1977 return arg
1978 else:
1979 return MultiPattern(arg)
1980

Referenced by _mk_quantifier().

◆ _to_probe()

def _to_probe (   p,
  ctx = None 
)
protected

Definition at line 8648 of file z3py.py.

8648def _to_probe(p, ctx=None):
8649 if is_probe(p):
8650 return p
8651 else:
8652 return Probe(p, ctx)
8653
8654

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

8274def _to_tactic(t, ctx=None):
8275 if isinstance(t, Tactic):
8276 return t
8277 else:
8278 return Tactic(t, ctx)
8279
8280

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

5037def _valid_accessor(acc):
5038 """Return `True` if acc is pair of the form (String, Datatype or Sort). """
5039 if not isinstance(acc, tuple):
5040 return False
5041 if len(acc) != 2:
5042 return False
5043 return isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
5044
5045

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 FuncDeclRef.__call__(), 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_int_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(), FuncDeclRef.domain(), 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 8932 of file z3py.py.

8932def Abs(arg):
8933 """Create the absolute value of an arithmetic expression"""
8934 return If(arg > 0, arg, -arg)
8935
8936

◆ AllChar()

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

Definition at line 11298 of file z3py.py.

11298def AllChar(regex_sort, ctx=None):
11299 """Create a regular expression that accepts all single character strings
11300 """
11301 return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11302
11303# Special Relations
11304
11305
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 1849 of file z3py.py.

1849def And(*args):
1850 """Create a Z3 and-expression or and-probe.
1851
1852 >>> p, q, r = Bools('p q r')
1853 >>> And(p, q, r)
1854 And(p, q, r)
1855 >>> P = BoolVector('p', 5)
1856 >>> And(P)
1857 And(p__0, p__1, p__2, p__3, p__4)
1858 """
1859 last_arg = None
1860 if len(args) > 0:
1861 last_arg = args[len(args) - 1]
1862 if isinstance(last_arg, Context):
1863 ctx = args[len(args) - 1]
1864 args = args[:len(args) - 1]
1865 elif len(args) == 1 and isinstance(args[0], AstVector):
1866 ctx = args[0].ctx
1867 args = [a for a in args[0]]
1868 else:
1869 ctx = None
1870 args = _get_args(args)
1871 ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1872 if z3_debug():
1873 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1874 if _has_probe(args):
1875 return _probe_and(args, ctx)
1876 else:
1877 args = _coerce_expr_list(args, ctx)
1878 _args, sz = _to_ast_array(args)
1879 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1880
1881
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 8297 of file z3py.py.

8297def AndThen(*ts, **ks):
8298 """Return a tactic that applies the tactics in `*ts` in sequence.
8299
8300 >>> x, y = Ints('x y')
8301 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8302 >>> t(And(x == 0, y > x + 1))
8303 [[Not(y <= 1)]]
8304 >>> t(And(x == 0, y > x + 1)).as_expr()
8305 Not(y <= 1)
8306 """
8307 if z3_debug():
8308 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8309 ctx = ks.get("ctx", None)
8310 num = len(ts)
8311 r = ts[0]
8312 for i in range(num - 1):
8313 r = _and_then(r, ts[i + 1], ctx)
8314 return r
8315
8316

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

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

Referenced by Tactic.apply(), args2params(), Solver.set(), Fixedpoint.set(), Optimize.set(), simplify(), 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 4733 of file z3py.py.

4733def Array(name, *sorts):
4734 """Return an array constant named `name` with the given domain and range sorts.
4735
4736 >>> a = Array('a', IntSort(), IntSort())
4737 >>> a.sort()
4738 Array(Int, Int)
4739 >>> a[0]
4740 a[0]
4741 """
4742 s = ArraySort(sorts)
4743 ctx = s.ctx
4744 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4745
4746
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 4700 of file z3py.py.

4700def ArraySort(*sig):
4701 """Return the Z3 array sort with the given domain and range sorts.
4702
4703 >>> A = ArraySort(IntSort(), BoolSort())
4704 >>> A
4705 Array(Int, Bool)
4706 >>> A.domain()
4707 Int
4708 >>> A.range()
4709 Bool
4710 >>> AA = ArraySort(IntSort(), A)
4711 >>> AA
4712 Array(Int, Array(Int, Bool))
4713 """
4714 sig = _get_args(sig)
4715 if z3_debug():
4716 _z3_assert(len(sig) > 1, "At least two arguments expected")
4717 arity = len(sig) - 1
4718 r = sig[arity]
4719 d = sig[0]
4720 if z3_debug():
4721 for s in sig:
4722 _z3_assert(is_sort(s), "Z3 sort expected")
4723 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4724 ctx = d.ctx
4725 if len(sig) == 2:
4726 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4727 dom = (Sort * arity)()
4728 for i in range(arity):
4729 dom[i] = sig[i].ast
4730 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4731
4732
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 8955 of file z3py.py.

8955def AtLeast(*args):
8956 """Create an at-most Pseudo-Boolean k constraint.
8957
8958 >>> a, b, c = Bools('a b c')
8959 >>> f = AtLeast(a, b, c, 2)
8960 """
8961 args = _get_args(args)
8962 if z3_debug():
8963 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8964 ctx = _ctx_from_ast_arg_list(args)
8965 if z3_debug():
8966 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8967 args1 = _coerce_expr_list(args[:-1], ctx)
8968 k = args[-1]
8969 _args, sz = _to_ast_array(args1)
8970 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8971
8972
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 8937 of file z3py.py.

8937def AtMost(*args):
8938 """Create an at-most Pseudo-Boolean k constraint.
8939
8940 >>> a, b, c = Bools('a b c')
8941 >>> f = AtMost(a, b, c, 2)
8942 """
8943 args = _get_args(args)
8944 if z3_debug():
8945 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8946 ctx = _ctx_from_ast_arg_list(args)
8947 if z3_debug():
8948 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8949 args1 = _coerce_expr_list(args[:-1], ctx)
8950 k = args[-1]
8951 _args, sz = _to_ast_array(args1)
8952 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8953
8954
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 4037 of file z3py.py.

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

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

4061def BitVecs(names, bv, ctx=None):
4062 """Return a tuple of bit-vector constants of size bv.
4063
4064 >>> x, y, z = BitVecs('x y z', 16)
4065 >>> x.size()
4066 16
4067 >>> x.sort()
4068 BitVec(16)
4069 >>> Sum(x, y, z)
4070 0 + x + y + z
4071 >>> Product(x, y, z)
4072 1*x*y*z
4073 >>> simplify(Product(x, y, z))
4074 x*y*z
4075 """
4076 ctx = _get_ctx(ctx)
4077 if isinstance(names, str):
4078 names = names.split(" ")
4079 return [BitVec(name, bv, ctx) for name in names]
4080
4081

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

4005def BitVecSort(sz, ctx=None):
4006 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4007
4008 >>> Byte = BitVecSort(8)
4009 >>> Word = BitVecSort(16)
4010 >>> Byte
4011 BitVec(8)
4012 >>> x = Const('x', Byte)
4013 >>> eq(x, BitVec('x', 8))
4014 True
4015 """
4016 ctx = _get_ctx(ctx)
4017 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4018
4019
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 4020 of file z3py.py.

4020def BitVecVal(val, bv, ctx=None):
4021 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4022
4023 >>> v = BitVecVal(10, 32)
4024 >>> v
4025 10
4026 >>> print("0x%.8x" % v.as_long())
4027 0x0000000a
4028 """
4029 if is_bv_sort(bv):
4030 ctx = bv.ctx
4031 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4032 else:
4033 ctx = _get_ctx(ctx)
4034 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4035
4036
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 1728 of file z3py.py.

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

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

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

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

1691def BoolSort(ctx=None):
1692 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1693
1694 >>> BoolSort()
1695 Bool
1696 >>> p = Const('p', BoolSort())
1697 >>> is_bool(p)
1698 True
1699 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1700 >>> r(0, 1)
1701 r(0, 1)
1702 >>> is_bool(r(0, 1))
1703 True
1704 """
1705 ctx = _get_ctx(ctx)
1706 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1707
1708
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 1709 of file z3py.py.

1709def BoolVal(val, ctx=None):
1710 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1711
1712 >>> BoolVal(True)
1713 True
1714 >>> is_true(BoolVal(True))
1715 True
1716 >>> is_true(True)
1717 False
1718 >>> is_false(BoolVal(False))
1719 True
1720 """
1721 ctx = _get_ctx(ctx)
1722 if val:
1723 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1724 else:
1725 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1726
1727
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 1756 of file z3py.py.

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

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

3973def BV2Int(a, is_signed=False):
3974 """Return the Z3 expression BV2Int(a).
3975
3976 >>> b = BitVec('b', 3)
3977 >>> BV2Int(b).sort()
3978 Int
3979 >>> x = Int('x')
3980 >>> x > BV2Int(b)
3981 x > BV2Int(b)
3982 >>> x > BV2Int(b, is_signed=False)
3983 x > BV2Int(b)
3984 >>> x > BV2Int(b, is_signed=True)
3985 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3986 >>> solve(x > BV2Int(b), b == 1, x < 3)
3987 [x = 2, b = 1]
3988 """
3989 if z3_debug():
3990 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3991 ctx = a.ctx
3992 # investigate problem with bv2int
3993 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3994
3995
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 4459 of file z3py.py.

4459def BVAddNoOverflow(a, b, signed):
4460 """A predicate the determines that bit-vector addition does not overflow"""
4461 _check_bv_args(a, b)
4462 a, b = _coerce_exprs(a, b)
4463 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4464
4465
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 4466 of file z3py.py.

4466def BVAddNoUnderflow(a, b):
4467 """A predicate the determines that signed bit-vector addition does not underflow"""
4468 _check_bv_args(a, b)
4469 a, b = _coerce_exprs(a, b)
4470 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4471
4472
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 4501 of file z3py.py.

4501def BVMulNoOverflow(a, b, signed):
4502 """A predicate the determines that bit-vector multiplication does not overflow"""
4503 _check_bv_args(a, b)
4504 a, b = _coerce_exprs(a, b)
4505 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4506
4507
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 4508 of file z3py.py.

4508def BVMulNoUnderflow(a, b):
4509 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4510 _check_bv_args(a, b)
4511 a, b = _coerce_exprs(a, b)
4512 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4513
4514
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 4445 of file z3py.py.

4445def BVRedAnd(a):
4446 """Return the reduction-and expression of `a`."""
4447 if z3_debug():
4448 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4449 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4450
4451
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 4452 of file z3py.py.

4452def BVRedOr(a):
4453 """Return the reduction-or expression of `a`."""
4454 if z3_debug():
4455 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4456 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4457
4458
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 4487 of file z3py.py.

4487def BVSDivNoOverflow(a, b):
4488 """A predicate the determines that bit-vector signed division does not overflow"""
4489 _check_bv_args(a, b)
4490 a, b = _coerce_exprs(a, b)
4491 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4492
4493
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 4494 of file z3py.py.

4494def BVSNegNoOverflow(a):
4495 """A predicate the determines that bit-vector unary negation does not overflow"""
4496 if z3_debug():
4497 _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4498 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4499
4500
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 4473 of file z3py.py.

4473def BVSubNoOverflow(a, b):
4474 """A predicate the determines that bit-vector subtraction does not overflow"""
4475 _check_bv_args(a, b)
4476 a, b = _coerce_exprs(a, b)
4477 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4478
4479
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 4480 of file z3py.py.

4480def BVSubNoUnderflow(a, b, signed):
4481 """A predicate the determines that bit-vector subtraction does not underflow"""
4482 _check_bv_args(a, b)
4483 a, b = _coerce_exprs(a, b)
4484 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4485
4486
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 3424 of file z3py.py.

3424def Cbrt(a, ctx=None):
3425 """ Return a Z3 expression which represents the cubic root of a.
3426
3427 >>> x = Real('x')
3428 >>> Cbrt(x)
3429 x**(1/3)
3430 """
3431 if not is_expr(a):
3432 ctx = _get_ctx(ctx)
3433 a = RealVal(a, ctx)
3434 return a ** "1/3"
3435

Referenced by Cbrt().

◆ CharFromBv()

def CharFromBv (   ch,
  ctx = None 
)

Definition at line 10856 of file z3py.py.

10856def CharFromBv(ch, ctx=None):
10857 if not is_expr(ch):
10858 raise Z3Expression("Bit-vector expression needed")
10859 return _to_expr_ref(Z3_mk_char_from_bv(ch.ctx_ref(), ch.as_ast()), ch.ctx)
10860
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 10869 of file z3py.py.

10869def CharIsDigit(ch, ctx=None):
10870 ch = _coerce_char(ch, ctx)
10871 return ch.is_digit()
10872

◆ CharSort()

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

Definition at line 10755 of file z3py.py.

10755def CharSort(ctx=None):
10756 """Create a character sort
10757 >>> ch = CharSort()
10758 >>> print(ch)
10759 Char
10760 """
10761 ctx = _get_ctx(ctx)
10762 return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
10763
10764
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 10861 of file z3py.py.

10861def CharToBv(ch, ctx=None):
10862 ch = _coerce_char(ch, ctx)
10863 return ch.to_bv()
10864

◆ CharToInt()

def CharToInt (   ch,
  ctx = None 
)

Definition at line 10865 of file z3py.py.

10865def CharToInt(ch, ctx=None):
10866 ch = _coerce_char(ch, ctx)
10867 return ch.to_int()
10868

◆ CharVal()

def CharVal (   ch,
  ctx = None 
)

Definition at line 10848 of file z3py.py.

10848def CharVal(ch, ctx=None):
10849 ctx = _get_ctx(ctx)
10850 if isinstance(ch, str):
10851 ch = ord(ch)
10852 if not isinstance(ch, int):
10853 raise Z3Exception("character value should be an ordinal")
10854 return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
10855
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 11250 of file z3py.py.

11250def Complement(re):
11251 """Create the complement regular expression."""
11252 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11253
11254
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 4082 of file z3py.py.

4082def Concat(*args):
4083 """Create a Z3 bit-vector concatenation expression.
4084
4085 >>> v = BitVecVal(1, 4)
4086 >>> Concat(v, v+1, v)
4087 Concat(Concat(1, 1 + 1), 1)
4088 >>> simplify(Concat(v, v+1, v))
4089 289
4090 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4091 121
4092 """
4093 args = _get_args(args)
4094 sz = len(args)
4095 if z3_debug():
4096 _z3_assert(sz >= 2, "At least two arguments expected.")
4097
4098 ctx = None
4099 for a in args:
4100 if is_expr(a):
4101 ctx = a.ctx
4102 break
4103 if is_seq(args[0]) or isinstance(args[0], str):
4104 args = [_coerce_seq(s, ctx) for s in args]
4105 if z3_debug():
4106 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4107 v = (Ast * sz)()
4108 for i in range(sz):
4109 v[i] = args[i].as_ast()
4110 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4111
4112 if is_re(args[0]):
4113 if z3_debug():
4114 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4115 v = (Ast * sz)()
4116 for i in range(sz):
4117 v[i] = args[i].as_ast()
4118 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4119
4120 if z3_debug():
4121 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4122 r = args[0]
4123 for i in range(sz - 1):
4124 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4125 return r
4126
4127
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 8754 of file z3py.py.

8754def Cond(p, t1, t2, ctx=None):
8755 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8756
8757 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8758 """
8759 p = _to_probe(p, ctx)
8760 t1 = _to_tactic(t1, ctx)
8761 t2 = _to_tactic(t2, ctx)
8762 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8763
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 1437 of file z3py.py.

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

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

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

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

11025def Contains(a, b):
11026 """Check if 'a' contains 'b'
11027 >>> s1 = Contains("abc", "ab")
11028 >>> simplify(s1)
11029 True
11030 >>> s2 = Contains("abc", "bc")
11031 >>> simplify(s2)
11032 True
11033 >>> x, y, z = Strings('x y z')
11034 >>> s3 = Contains(Concat(x,y,z), y)
11035 >>> simplify(s3)
11036 True
11037 """
11038 ctx = _get_ctx2(a, b)
11039 a = _coerce_seq(a, ctx)
11040 b = _coerce_seq(b, ctx)
11041 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11042
11043
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 5158 of file z3py.py.

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

5358def DatatypeSort(name, ctx = None):
5359 """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5360 ctx = _get_ctx(ctx)
5361 return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5362
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 4779 of file z3py.py.

4779def Default(a):
4780 """ Return a default value for array expression.
4781 >>> b = K(IntSort(), 1)
4782 >>> prove(Default(b) == 1)
4783 proved
4784 """
4785 if z3_debug():
4786 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4787 return a.default()
4788
4789

Referenced by Default(), and is_default().

◆ describe_probes()

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

Definition at line 8675 of file z3py.py.

8675def describe_probes():
8676 """Display a (tabular) description of all available probes in Z3."""
8677 if in_html_mode():
8678 even = True
8679 print('<table border="1" cellpadding="2" cellspacing="0">')
8680 for p in probes():
8681 if even:
8682 print('<tr style="background-color:#CFCFCF">')
8683 even = False
8684 else:
8685 print("<tr>")
8686 even = True
8687 print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8688 print("</table>")
8689 else:
8690 for p in probes():
8691 print("%s : %s" % (p, probe_description(p)))
8692
8693

◆ describe_tactics()

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

Definition at line 8469 of file z3py.py.

8469def describe_tactics():
8470 """Display a (tabular) description of all available tactics in Z3."""
8471 if in_html_mode():
8472 even = True
8473 print('<table border="1" cellpadding="2" cellspacing="0">')
8474 for t in tactics():
8475 if even:
8476 print('<tr style="background-color:#CFCFCF">')
8477 even = False
8478 else:
8479 print("<tr>")
8480 even = True
8481 print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8482 print("</table>")
8483 else:
8484 for t in tactics():
8485 print("%s : %s" % (t, tactic_description(t)))
8486
8487

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

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

◆ Diff()

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

Definition at line 11293 of file z3py.py.

11293def Diff(a, b, ctx=None):
11294 """Create the difference regular epression
11295 """
11296 return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11297
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 5375 of file z3py.py.

5375def DisjointSum(name, sorts, ctx=None):
5376 """Create a named tagged union sort base on a set of underlying sorts
5377 Example:
5378 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5379 """
5380 sum = Datatype(name, ctx)
5381 for i in range(len(sorts)):
5382 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5383 sum = sum.create()
5384 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5385
5386

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

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

10955def Empty(s):
10956 """Create the empty sequence of the given sort
10957 >>> e = Empty(StringSort())
10958 >>> e2 = StringVal("")
10959 >>> print(e.eq(e2))
10960 True
10961 >>> e3 = Empty(SeqSort(IntSort()))
10962 >>> print(e3)
10963 Empty(Seq(Int))
10964 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10965 >>> print(e4)
10966 Empty(ReSort(Seq(Int)))
10967 """
10968 if isinstance(s, SeqSortRef):
10969 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10970 if isinstance(s, ReSortRef):
10971 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10972 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10973
10974
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 4922 of file z3py.py.

4922def EmptySet(s):
4923 """Create the empty set
4924 >>> EmptySet(IntSort())
4925 K(Int, False)
4926 """
4927 ctx = s.ctx
4928 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4929
4930
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 11408 of file z3py.py.

11408def ensure_prop_closures():
11409 global _prop_closures
11410 if _prop_closures is None:
11411 _prop_closures = PropClosures()
11412
11413

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

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

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

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

4868def Ext(a, b):
4869 """Return extensionality index for one-dimensional arrays.
4870 >> a, b = Consts('a b', SetSort(IntSort()))
4871 >> Ext(a, b)
4872 Ext(a, b)
4873 """
4874 ctx = a.ctx
4875 if z3_debug():
4876 _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4877 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4878
4879
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 4128 of file z3py.py.

4128def Extract(high, low, a):
4129 """Create a Z3 bit-vector extraction expression.
4130 Extract is overloaded to also work on sequence extraction.
4131 The functions SubString and SubSeq are redirected to Extract.
4132 For this case, the arguments are reinterpreted as:
4133 high - is a sequence (string)
4134 low - is an offset
4135 a - is the length to be extracted
4136
4137 >>> x = BitVec('x', 8)
4138 >>> Extract(6, 2, x)
4139 Extract(6, 2, x)
4140 >>> Extract(6, 2, x).sort()
4141 BitVec(5)
4142 >>> simplify(Extract(StringVal("abcd"),2,1))
4143 "c"
4144 """
4145 if isinstance(high, str):
4146 high = StringVal(high)
4147 if is_seq(high):
4148 s = high
4149 offset, length = _coerce_exprs(low, a, s.ctx)
4150 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4151 if z3_debug():
4152 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4153 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4154 "First and second arguments must be non negative integers")
4155 _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4156 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4157
4158
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 8712 of file z3py.py.

8712def FailIf(p, ctx=None):
8713 """Return a tactic that fails if the probe `p` evaluates to true.
8714 Otherwise, it returns the input goal unmodified.
8715
8716 In the following example, the tactic applies 'simplify' if and only if there are
8717 more than 2 constraints in the goal.
8718
8719 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8720 >>> x, y = Ints('x y')
8721 >>> g = Goal()
8722 >>> g.add(x > 0)
8723 >>> g.add(y > 0)
8724 >>> t(g)
8725 [[x > 0, y > 0]]
8726 >>> g.add(x == y + 1)
8727 >>> t(g)
8728 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8729 """
8730 p = _to_probe(p, ctx)
8731 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8732
8733
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 7716 of file z3py.py.

7716def FiniteDomainSort(name, sz, ctx=None):
7717 """Create a named finite domain sort of a given size sz"""
7718 if not isinstance(name, Symbol):
7719 name = to_symbol(name)
7720 ctx = _get_ctx(ctx)
7721 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7722
7723
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 7786 of file z3py.py.

7786def FiniteDomainVal(val, sort, ctx=None):
7787 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7788
7789 >>> s = FiniteDomainSort('S', 256)
7790 >>> FiniteDomainVal(255, s)
7791 255
7792 >>> FiniteDomainVal('100', s)
7793 100
7794 """
7795 if z3_debug():
7796 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7797 ctx = sort.ctx
7798 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7799
7800

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

9440def Float128(ctx=None):
9441 """Floating-point 128-bit (quadruple) sort."""
9442 ctx = _get_ctx(ctx)
9443 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9444
9445
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 9404 of file z3py.py.

9404def Float16(ctx=None):
9405 """Floating-point 16-bit (half) sort."""
9406 ctx = _get_ctx(ctx)
9407 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9408
9409
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 9416 of file z3py.py.

9416def Float32(ctx=None):
9417 """Floating-point 32-bit (single) sort."""
9418 ctx = _get_ctx(ctx)
9419 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9420
9421
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 9428 of file z3py.py.

9428def Float64(ctx=None):
9429 """Floating-point 64-bit (double) sort."""
9430 ctx = _get_ctx(ctx)
9431 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9432
9433
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 9434 of file z3py.py.

9434def FloatDouble(ctx=None):
9435 """Floating-point 64-bit (double) sort."""
9436 ctx = _get_ctx(ctx)
9437 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9438
9439
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 9410 of file z3py.py.

9410def FloatHalf(ctx=None):
9411 """Floating-point 16-bit (half) sort."""
9412 ctx = _get_ctx(ctx)
9413 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9414
9415
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 9446 of file z3py.py.

9446def FloatQuadruple(ctx=None):
9447 """Floating-point 128-bit (quadruple) sort."""
9448 ctx = _get_ctx(ctx)
9449 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9450
9451
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 9422 of file z3py.py.

9422def FloatSingle(ctx=None):
9423 """Floating-point 32-bit (single) sort."""
9424 ctx = _get_ctx(ctx)
9425 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9426
9427
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 2222 of file z3py.py.

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

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

10072def FP(name, fpsort, ctx=None):
10073 """Return a floating-point constant named `name`.
10074 `fpsort` is the floating-point sort.
10075 If `ctx=None`, then the global context is used.
10076
10077 >>> x = FP('x', FPSort(8, 24))
10078 >>> is_fp(x)
10079 True
10080 >>> x.ebits()
10081 8
10082 >>> x.sort()
10083 FPSort(8, 24)
10084 >>> word = FPSort(8, 24)
10085 >>> x2 = FP('x', word)
10086 >>> eq(x, x2)
10087 True
10088 """
10089 if isinstance(fpsort, FPSortRef) and ctx is None:
10090 ctx = fpsort.ctx
10091 else:
10092 ctx = _get_ctx(ctx)
10093 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10094
10095

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

10115def fpAbs(a, ctx=None):
10116 """Create a Z3 floating-point absolute value expression.
10117
10118 >>> s = FPSort(8, 24)
10119 >>> rm = RNE()
10120 >>> x = FPVal(1.0, s)
10121 >>> fpAbs(x)
10122 fpAbs(1)
10123 >>> y = FPVal(-20.0, s)
10124 >>> y
10125 -1.25*(2**4)
10126 >>> fpAbs(y)
10127 fpAbs(-1.25*(2**4))
10128 >>> fpAbs(-1.25*(2**4))
10129 fpAbs(-1.25*(2**4))
10130 >>> fpAbs(x).sort()
10131 FPSort(8, 24)
10132 """
10133 ctx = _get_ctx(ctx)
10134 [a] = _coerce_fp_expr_list([a], ctx)
10135 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10136
10137
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 10206 of file z3py.py.

10206def fpAdd(rm, a, b, ctx=None):
10207 """Create a Z3 floating-point addition expression.
10208
10209 >>> s = FPSort(8, 24)
10210 >>> rm = RNE()
10211 >>> x = FP('x', s)
10212 >>> y = FP('y', s)
10213 >>> fpAdd(rm, x, y)
10214 x + y
10215 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10216 fpAdd(RTZ(), x, y)
10217 >>> fpAdd(rm, x, y).sort()
10218 FPSort(8, 24)
10219 """
10220 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10221
10222

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

10528def fpBVToFP(v, sort, ctx=None):
10529 """Create a Z3 floating-point conversion expression that represents the
10530 conversion from a bit-vector term to a floating-point term.
10531
10532 >>> x_bv = BitVecVal(0x3F800000, 32)
10533 >>> x_fp = fpBVToFP(x_bv, Float32())
10534 >>> x_fp
10535 fpToFP(1065353216)
10536 >>> simplify(x_fp)
10537 1
10538 """
10539 _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10540 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10541 ctx = _get_ctx(ctx)
10542 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10543
10544
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 10253 of file z3py.py.

10253def fpDiv(rm, a, b, ctx=None):
10254 """Create a Z3 floating-point division expression.
10255
10256 >>> s = FPSort(8, 24)
10257 >>> rm = RNE()
10258 >>> x = FP('x', s)
10259 >>> y = FP('y', s)
10260 >>> fpDiv(rm, x, y)
10261 x / y
10262 >>> fpDiv(rm, x, y).sort()
10263 FPSort(8, 24)
10264 """
10265 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10266
10267

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

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

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

10312def fpFMA(rm, a, b, c, ctx=None):
10313 """Create a Z3 floating-point fused multiply-add expression.
10314 """
10315 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10316
10317

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

10460def fpFP(sgn, exp, sig, ctx=None):
10461 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10462
10463 >>> s = FPSort(8, 24)
10464 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10465 >>> print(x)
10466 fpFP(1, 127, 4194304)
10467 >>> xv = FPVal(-1.5, s)
10468 >>> print(xv)
10469 -1.5
10470 >>> slvr = Solver()
10471 >>> slvr.add(fpEQ(x, xv))
10472 >>> slvr.check()
10473 sat
10474 >>> xv = FPVal(+1.5, s)
10475 >>> print(xv)
10476 1.5
10477 >>> slvr = Solver()
10478 >>> slvr.add(fpEQ(x, xv))
10479 >>> slvr.check()
10480 unsat
10481 """
10482 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10483 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10484 ctx = _get_ctx(ctx)
10485 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10486 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10487
10488
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 10545 of file z3py.py.

10545def fpFPToFP(rm, v, sort, ctx=None):
10546 """Create a Z3 floating-point conversion expression that represents the
10547 conversion from a floating-point term to a floating-point term of different precision.
10548
10549 >>> x_sgl = FPVal(1.0, Float32())
10550 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10551 >>> x_dbl
10552 fpToFP(RNE(), 1)
10553 >>> simplify(x_dbl)
10554 1
10555 >>> x_dbl.sort()
10556 FPSort(11, 53)
10557 """
10558 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10559 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10560 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10561 ctx = _get_ctx(ctx)
10562 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10563
10564
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 10424 of file z3py.py.

10424def fpGEQ(a, b, ctx=None):
10425 """Create the Z3 floating-point expression `other >= self`.
10426
10427 >>> x, y = FPs('x y', FPSort(8, 24))
10428 >>> fpGEQ(x, y)
10429 x >= y
10430 >>> (x >= y).sexpr()
10431 '(fp.geq x y)'
10432 """
10433 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10434
10435

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

10412def fpGT(a, b, ctx=None):
10413 """Create the Z3 floating-point expression `other > self`.
10414
10415 >>> x, y = FPs('x y', FPSort(8, 24))
10416 >>> fpGT(x, y)
10417 x > y
10418 >>> (x > y).sexpr()
10419 '(fp.gt x y)'
10420 """
10421 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10422
10423

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

◆ fpInfinity()

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

Definition at line 10000 of file z3py.py.

10000def fpInfinity(s, negative):
10001 """Create a Z3 floating-point +oo or -oo term."""
10002 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10003 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10004 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10005
10006
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 10342 of file z3py.py.

10342def fpIsInf(a, ctx=None):
10343 """Create a Z3 floating-point isInfinite expression.
10344
10345 >>> s = FPSort(8, 24)
10346 >>> x = FP('x', s)
10347 >>> fpIsInf(x)
10348 fpIsInf(x)
10349 """
10350 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10351
10352

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

10330def fpIsNaN(a, ctx=None):
10331 """Create a Z3 floating-point isNaN expression.
10332
10333 >>> s = FPSort(8, 24)
10334 >>> x = FP('x', s)
10335 >>> y = FP('y', s)
10336 >>> fpIsNaN(x)
10337 fpIsNaN(x)
10338 """
10339 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10340
10341

Referenced by fpIsNaN().

◆ fpIsNegative()

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

Definition at line 10371 of file z3py.py.

10371def fpIsNegative(a, ctx=None):
10372 """Create a Z3 floating-point isNegative expression.
10373 """
10374 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10375
10376

◆ fpIsNormal()

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

Definition at line 10359 of file z3py.py.

10359def fpIsNormal(a, ctx=None):
10360 """Create a Z3 floating-point isNormal expression.
10361 """
10362 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10363
10364

◆ fpIsPositive()

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

Definition at line 10377 of file z3py.py.

10377def fpIsPositive(a, ctx=None):
10378 """Create a Z3 floating-point isPositive expression.
10379 """
10380 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10381
10382

◆ fpIsSubnormal()

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

Definition at line 10365 of file z3py.py.

10365def fpIsSubnormal(a, ctx=None):
10366 """Create a Z3 floating-point isSubnormal expression.
10367 """
10368 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10369
10370

◆ fpIsZero()

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

Definition at line 10353 of file z3py.py.

10353def fpIsZero(a, ctx=None):
10354 """Create a Z3 floating-point isZero expression.
10355 """
10356 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10357
10358

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

10400def fpLEQ(a, b, ctx=None):
10401 """Create the Z3 floating-point expression `other <= self`.
10402
10403 >>> x, y = FPs('x y', FPSort(8, 24))
10404 >>> fpLEQ(x, y)
10405 x <= y
10406 >>> (x <= y).sexpr()
10407 '(fp.leq x y)'
10408 """
10409 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10410
10411

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

10388def fpLT(a, b, ctx=None):
10389 """Create the Z3 floating-point expression `other < self`.
10390
10391 >>> x, y = FPs('x y', FPSort(8, 24))
10392 >>> fpLT(x, y)
10393 x < y
10394 >>> (x < y).sexpr()
10395 '(fp.lt x y)'
10396 """
10397 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10398
10399

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

10297def fpMax(a, b, ctx=None):
10298 """Create a Z3 floating-point maximum expression.
10299
10300 >>> s = FPSort(8, 24)
10301 >>> rm = RNE()
10302 >>> x = FP('x', s)
10303 >>> y = FP('y', s)
10304 >>> fpMax(x, y)
10305 fpMax(x, y)
10306 >>> fpMax(x, y).sort()
10307 FPSort(8, 24)
10308 """
10309 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10310
10311

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

10282def fpMin(a, b, ctx=None):
10283 """Create a Z3 floating-point minimum expression.
10284
10285 >>> s = FPSort(8, 24)
10286 >>> rm = RNE()
10287 >>> x = FP('x', s)
10288 >>> y = FP('y', s)
10289 >>> fpMin(x, y)
10290 fpMin(x, y)
10291 >>> fpMin(x, y).sort()
10292 FPSort(8, 24)
10293 """
10294 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10295
10296

Referenced by fpMin().

◆ fpMinusInfinity()

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

Definition at line 9994 of file z3py.py.

9994def fpMinusInfinity(s):
9995 """Create a Z3 floating-point -oo term."""
9996 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9997 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9998
9999

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 10013 of file z3py.py.

10013def fpMinusZero(s):
10014 """Create a Z3 floating-point -0.0 term."""
10015 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10016 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10017
10018
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 10238 of file z3py.py.

10238def fpMul(rm, a, b, ctx=None):
10239 """Create a Z3 floating-point multiplication expression.
10240
10241 >>> s = FPSort(8, 24)
10242 >>> rm = RNE()
10243 >>> x = FP('x', s)
10244 >>> y = FP('y', s)
10245 >>> fpMul(rm, x, y)
10246 x * y
10247 >>> fpMul(rm, x, y).sort()
10248 FPSort(8, 24)
10249 """
10250 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10251
10252

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

9960def fpNaN(s):
9961 """Create a Z3 floating-point NaN term.
9962
9963 >>> s = FPSort(8, 24)
9964 >>> set_fpa_pretty(True)
9965 >>> fpNaN(s)
9966 NaN
9967 >>> pb = get_fpa_pretty()
9968 >>> set_fpa_pretty(False)
9969 >>> fpNaN(s)
9970 fpNaN(FPSort(8, 24))
9971 >>> set_fpa_pretty(pb)
9972 """
9973 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9974 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9975
9976
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 10138 of file z3py.py.

10138def fpNeg(a, ctx=None):
10139 """Create a Z3 floating-point addition expression.
10140
10141 >>> s = FPSort(8, 24)
10142 >>> rm = RNE()
10143 >>> x = FP('x', s)
10144 >>> fpNeg(x)
10145 -x
10146 >>> fpNeg(x).sort()
10147 FPSort(8, 24)
10148 """
10149 ctx = _get_ctx(ctx)
10150 [a] = _coerce_fp_expr_list([a], ctx)
10151 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10152
10153
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 10448 of file z3py.py.

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

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

9977def fpPlusInfinity(s):
9978 """Create a Z3 floating-point +oo term.
9979
9980 >>> s = FPSort(8, 24)
9981 >>> pb = get_fpa_pretty()
9982 >>> set_fpa_pretty(True)
9983 >>> fpPlusInfinity(s)
9984 +oo
9985 >>> set_fpa_pretty(False)
9986 >>> fpPlusInfinity(s)
9987 fpPlusInfinity(FPSort(8, 24))
9988 >>> set_fpa_pretty(pb)
9989 """
9990 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9991 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9992
9993

Referenced by fpPlusInfinity(), and FPVal().

◆ fpPlusZero()

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

Definition at line 10007 of file z3py.py.

10007def fpPlusZero(s):
10008 """Create a Z3 floating-point +0.0 term."""
10009 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10010 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10011
10012

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

10565def fpRealToFP(rm, v, sort, ctx=None):
10566 """Create a Z3 floating-point conversion expression that represents the
10567 conversion from a real term to a floating-point term.
10568
10569 >>> x_r = RealVal(1.5)
10570 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10571 >>> x_fp
10572 fpToFP(RNE(), 3/2)
10573 >>> simplify(x_fp)
10574 1.5
10575 """
10576 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10577 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10578 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10579 ctx = _get_ctx(ctx)
10580 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10581
10582
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 10268 of file z3py.py.

10268def fpRem(a, b, ctx=None):
10269 """Create a Z3 floating-point remainder expression.
10270
10271 >>> s = FPSort(8, 24)
10272 >>> x = FP('x', s)
10273 >>> y = FP('y', s)
10274 >>> fpRem(x, y)
10275 fpRem(x, y)
10276 >>> fpRem(x, y).sort()
10277 FPSort(8, 24)
10278 """
10279 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10280
10281

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

10324def fpRoundToIntegral(rm, a, ctx=None):
10325 """Create a Z3 floating-point roundToIntegral expression.
10326 """
10327 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10328
10329

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

10096def FPs(names, fpsort, ctx=None):
10097 """Return an array of floating-point constants.
10098
10099 >>> x, y, z = FPs('x y z', FPSort(8, 24))
10100 >>> x.sort()
10101 FPSort(8, 24)
10102 >>> x.sbits()
10103 24
10104 >>> x.ebits()
10105 8
10106 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10107 x + y * z
10108 """
10109 ctx = _get_ctx(ctx)
10110 if isinstance(names, str):
10111 names = names.split(" ")
10112 return [FP(name, fpsort, ctx) for name in names]
10113
10114

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

10583def fpSignedToFP(rm, v, sort, ctx=None):
10584 """Create a Z3 floating-point conversion expression that represents the
10585 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10586
10587 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10588 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10589 >>> x_fp
10590 fpToFP(RNE(), 4294967291)
10591 >>> simplify(x_fp)
10592 -1.25*(2**2)
10593 """
10594 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10595 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10596 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10597 ctx = _get_ctx(ctx)
10598 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10599
10600
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 9901 of file z3py.py.

9901def FPSort(ebits, sbits, ctx=None):
9902 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9903
9904 >>> Single = FPSort(8, 24)
9905 >>> Double = FPSort(11, 53)
9906 >>> Single
9907 FPSort(8, 24)
9908 >>> x = Const('x', Single)
9909 >>> eq(x, FP('x', FPSort(8, 24)))
9910 True
9911 """
9912 ctx = _get_ctx(ctx)
9913 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9914
9915
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 10318 of file z3py.py.

10318def fpSqrt(rm, a, ctx=None):
10319 """Create a Z3 floating-point square root expression.
10320 """
10321 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10322
10323

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

10223def fpSub(rm, a, b, ctx=None):
10224 """Create a Z3 floating-point subtraction expression.
10225
10226 >>> s = FPSort(8, 24)
10227 >>> rm = RNE()
10228 >>> x = FP('x', s)
10229 >>> y = FP('y', s)
10230 >>> fpSub(rm, x, y)
10231 x - y
10232 >>> fpSub(rm, x, y).sort()
10233 FPSort(8, 24)
10234 """
10235 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10236
10237

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

10489def fpToFP(a1, a2=None, a3=None, ctx=None):
10490 """Create a Z3 floating-point conversion expression from other term sorts
10491 to floating-point.
10492
10493 From a bit-vector term in IEEE 754-2008 format:
10494 >>> x = FPVal(1.0, Float32())
10495 >>> x_bv = fpToIEEEBV(x)
10496 >>> simplify(fpToFP(x_bv, Float32()))
10497 1
10498
10499 From a floating-point term with different precision:
10500 >>> x = FPVal(1.0, Float32())
10501 >>> x_db = fpToFP(RNE(), x, Float64())
10502 >>> x_db.sort()
10503 FPSort(11, 53)
10504
10505 From a real term:
10506 >>> x_r = RealVal(1.5)
10507 >>> simplify(fpToFP(RNE(), x_r, Float32()))
10508 1.5
10509
10510 From a signed bit-vector term:
10511 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10512 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10513 -1.25*(2**2)
10514 """
10515 ctx = _get_ctx(ctx)
10516 if is_bv(a1) and is_fp_sort(a2):
10517 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10518 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10519 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10520 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10521 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10522 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10523 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10524 else:
10525 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10526
10527

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

10619def fpToFPUnsigned(rm, x, s, ctx=None):
10620 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10621 if z3_debug():
10622 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10623 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10624 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10625 ctx = _get_ctx(ctx)
10626 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10627
10628
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 10693 of file z3py.py.

10693def fpToIEEEBV(x, ctx=None):
10694 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10695
10696 The size of the resulting bit-vector is automatically determined.
10697
10698 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10699 knows only one NaN and it will always produce the same bit-vector representation of
10700 that NaN.
10701
10702 >>> x = FP('x', FPSort(8, 24))
10703 >>> y = fpToIEEEBV(x)
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_fp(x), "First argument must be a Z3 floating-point expression")
10715 ctx = _get_ctx(ctx)
10716 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10717
10718
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 10673 of file z3py.py.

10673def fpToReal(x, ctx=None):
10674 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10675
10676 >>> x = FP('x', FPSort(8, 24))
10677 >>> y = fpToReal(x)
10678 >>> print(is_fp(x))
10679 True
10680 >>> print(is_real(y))
10681 True
10682 >>> print(is_fp(y))
10683 False
10684 >>> print(is_real(x))
10685 False
10686 """
10687 if z3_debug():
10688 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10689 ctx = _get_ctx(ctx)
10690 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10691
10692
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 10629 of file z3py.py.

10629def fpToSBV(rm, x, s, ctx=None):
10630 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10631
10632 >>> x = FP('x', FPSort(8, 24))
10633 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10634 >>> print(is_fp(x))
10635 True
10636 >>> print(is_bv(y))
10637 True
10638 >>> print(is_fp(y))
10639 False
10640 >>> print(is_bv(x))
10641 False
10642 """
10643 if z3_debug():
10644 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10645 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10646 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10647 ctx = _get_ctx(ctx)
10648 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10649
10650
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 10651 of file z3py.py.

10651def fpToUBV(rm, x, s, ctx=None):
10652 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10653
10654 >>> x = FP('x', FPSort(8, 24))
10655 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10656 >>> print(is_fp(x))
10657 True
10658 >>> print(is_bv(y))
10659 True
10660 >>> print(is_fp(y))
10661 False
10662 >>> print(is_bv(x))
10663 False
10664 """
10665 if z3_debug():
10666 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10667 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10668 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10669 ctx = _get_ctx(ctx)
10670 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10671
10672
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 10601 of file z3py.py.

10601def fpUnsignedToFP(rm, v, sort, ctx=None):
10602 """Create a Z3 floating-point conversion expression that represents the
10603 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10604
10605 >>> x_signed = BitVecVal(-5, BitVecSort(32))
10606 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10607 >>> x_fp
10608 fpToFPUnsigned(RNE(), 4294967291)
10609 >>> simplify(x_fp)
10610 1*(2**32)
10611 """
10612 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10613 _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10614 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10615 ctx = _get_ctx(ctx)
10616 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10617
10618

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

10026def FPVal(sig, exp=None, fps=None, ctx=None):
10027 """Return a floating-point value of value `val` and sort `fps`.
10028 If `ctx=None`, then the global context is used.
10029
10030 >>> v = FPVal(20.0, FPSort(8, 24))
10031 >>> v
10032 1.25*(2**4)
10033 >>> print("0x%.8x" % v.exponent_as_long(False))
10034 0x00000004
10035 >>> v = FPVal(2.25, FPSort(8, 24))
10036 >>> v
10037 1.125*(2**1)
10038 >>> v = FPVal(-2.25, FPSort(8, 24))
10039 >>> v
10040 -1.125*(2**1)
10041 >>> FPVal(-0.0, FPSort(8, 24))
10042 -0.0
10043 >>> FPVal(0.0, FPSort(8, 24))
10044 +0.0
10045 >>> FPVal(+0.0, FPSort(8, 24))
10046 +0.0
10047 """
10048 ctx = _get_ctx(ctx)
10049 if is_fp_sort(exp):
10050 fps = exp
10051 exp = None
10052 elif fps is None:
10053 fps = _dflt_fps(ctx)
10054 _z3_assert(is_fp_sort(fps), "sort mismatch")
10055 if exp is None:
10056 exp = 0
10057 val = _to_float_str(sig)
10058 if val == "NaN" or val == "nan":
10059 return fpNaN(fps)
10060 elif val == "-0.0":
10061 return fpMinusZero(fps)
10062 elif val == "0.0" or val == "+0.0":
10063 return fpPlusZero(fps)
10064 elif val == "+oo" or val == "+inf" or val == "+Inf":
10065 return fpPlusInfinity(fps)
10066 elif val == "-oo" or val == "-inf" or val == "-Inf":
10067 return fpMinusInfinity(fps)
10068 else:
10069 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10070
10071

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

10019def fpZero(s, negative):
10020 """Create a Z3 floating-point +0.0 or -0.0 term."""
10021 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10022 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10023 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10024
10025

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

1771def FreshBool(prefix="b", ctx=None):
1772 """Return a fresh Boolean constant in the given context using the given prefix.
1773
1774 If `ctx=None`, then the global context is used.
1775
1776 >>> b1 = FreshBool()
1777 >>> b2 = FreshBool()
1778 >>> eq(b1, b2)
1779 False
1780 """
1781 ctx = _get_ctx(ctx)
1782 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1783
1784
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 1464 of file z3py.py.

1464def FreshConst(sort, prefix="c"):
1465 """Create a fresh constant of a specified sort"""
1466 ctx = _get_ctx(sort.ctx)
1467 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1468
1469

◆ FreshFunction()

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

Definition at line 886 of file z3py.py.

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

3287def FreshInt(prefix="x", ctx=None):
3288 """Return a fresh integer constant in the given context using the given prefix.
3289
3290 >>> x = FreshInt()
3291 >>> y = FreshInt()
3292 >>> eq(x, y)
3293 False
3294 >>> x.sort()
3295 Int
3296 """
3297 ctx = _get_ctx(ctx)
3298 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3299
3300

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

3344def FreshReal(prefix="b", ctx=None):
3345 """Return a fresh real constant in the given context using the given prefix.
3346
3347 >>> x = FreshReal()
3348 >>> y = FreshReal()
3349 >>> eq(x, y)
3350 False
3351 >>> x.sort()
3352 Real
3353 """
3354 ctx = _get_ctx(ctx)
3355 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3356
3357

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

10975def Full(s):
10976 """Create the regular expression that accepts the universal language
10977 >>> e = Full(ReSort(SeqSort(IntSort())))
10978 >>> print(e)
10979 Full(ReSort(Seq(Int)))
10980 >>> e1 = Full(ReSort(StringSort()))
10981 >>> print(e1)
10982 Full(ReSort(String))
10983 """
10984 if isinstance(s, ReSortRef):
10985 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10986 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10987
10988
10989
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 4931 of file z3py.py.

4931def FullSet(s):
4932 """Create the full set
4933 >>> FullSet(IntSort())
4934 K(Int, True)
4935 """
4936 ctx = s.ctx
4937 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4938
4939
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 863 of file z3py.py.

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

6699def get_as_array_func(n):
6700 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6701 if z3_debug():
6702 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6703 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6704
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 9323 of file z3py.py.

9323def get_default_fp_sort(ctx=None):
9324 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9325
9326

Referenced by _dflt_fps().

◆ get_default_rounding_mode()

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

Definition at line 9290 of file z3py.py.

9290def get_default_rounding_mode(ctx=None):
9291 """Retrieves the global default rounding mode."""
9292 global _dflt_rounding_mode
9293 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9294 return RTZ(ctx)
9295 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9296 return RTN(ctx)
9297 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9298 return RTP(ctx)
9299 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9300 return RNE(ctx)
9301 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9302 return RNA(ctx)
9303
9304

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

4676def get_map_func(a):
4677 """Return the function declaration associated with a Z3 map array expression.
4678
4679 >>> f = Function('f', IntSort(), IntSort())
4680 >>> b = Array('b', IntSort(), IntSort())
4681 >>> a = Map(f, b)
4682 >>> eq(f, get_map_func(a))
4683 True
4684 >>> get_map_func(a)
4685 f
4686 >>> get_map_func(a)(0)
4687 f(0)
4688 """
4689 if z3_debug():
4690 _z3_assert(is_map(a), "Z3 array map expression expected.")
4691 return FuncDeclRef(
4693 a.ctx_ref(),
4694 Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4695 ),
4696 ctx=a.ctx,
4697 )
4698
4699
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 1335 of file z3py.py.

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

8796def help_simplify():
8797 """Return a string describing all options available for Z3 `simplify` procedure."""
8798 print(Z3_simplify_get_help(main_ctx().ref()))
8799
8800
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 1381 of file z3py.py.

1381def If(a, b, c, ctx=None):
1382 """Create a Z3 if-then-else expression.
1383
1384 >>> x = Int('x')
1385 >>> y = Int('y')
1386 >>> max = If(x > y, x, y)
1387 >>> max
1388 If(x > y, x, y)
1389 >>> simplify(max)
1390 If(x <= y, y, x)
1391 """
1392 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1393 return Cond(a, b, c, ctx)
1394 else:
1395 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1396 s = BoolSort(ctx)
1397 a = s.cast(a)
1398 b, c = _coerce_exprs(b, c, ctx)
1399 if z3_debug():
1400 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1401 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1402
1403
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 1785 of file z3py.py.

1785def Implies(a, b, ctx=None):
1786 """Create a Z3 implies expression.
1787
1788 >>> p, q = Bools('p q')
1789 >>> Implies(p, q)
1790 Implies(p, q)
1791 """
1792 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1793 s = BoolSort(ctx)
1794 a = s.cast(a)
1795 b = s.cast(b)
1796 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1797
1798
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 11059 of file z3py.py.

11059def IndexOf(s, substr, offset=None):
11060 """Retrieve the index of substring within a string starting at a specified offset.
11061 >>> simplify(IndexOf("abcabc", "bc", 0))
11062 1
11063 >>> simplify(IndexOf("abcabc", "bc", 2))
11064 4
11065 """
11066 if offset is None:
11067 offset = IntVal(0)
11068 ctx = None
11069 if is_expr(offset):
11070 ctx = offset.ctx
11071 ctx = _get_ctx2(s, substr, ctx)
11072 s = _coerce_seq(s, ctx)
11073 substr = _coerce_seq(substr, ctx)
11074 if _is_int(offset):
11075 offset = IntVal(offset, ctx)
11076 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11077
11078
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 11172 of file z3py.py.

11172def InRe(s, re):
11173 """Create regular expression membership test
11174 >>> re = Union(Re("a"),Re("b"))
11175 >>> print (simplify(InRe("a", re)))
11176 True
11177 >>> print (simplify(InRe("b", re)))
11178 True
11179 >>> print (simplify(InRe("c", re)))
11180 False
11181 """
11182 s = _coerce_seq(s, re.ctx)
11183 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11184
11185
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 3248 of file z3py.py.

3248def Int(name, ctx=None):
3249 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3250
3251 >>> x = Int('x')
3252 >>> is_int(x)
3253 True
3254 >>> is_int(x + 1)
3255 True
3256 """
3257 ctx = _get_ctx(ctx)
3258 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3259
3260

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

3996def Int2BV(a, num_bits):
3997 """Return the z3 expression Int2BV(a, num_bits).
3998 It is a bit-vector of width num_bits and represents the
3999 modulo of a by 2^num_bits
4000 """
4001 ctx = a.ctx
4002 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4003
4004
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 11206 of file z3py.py.

11206def Intersect(*args):
11207 """Create intersection of regular expressions.
11208 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11209 """
11210 args = _get_args(args)
11211 sz = len(args)
11212 if z3_debug():
11213 _z3_assert(sz > 0, "At least one argument expected.")
11214 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11215 if sz == 1:
11216 return args[0]
11217 ctx = args[0].ctx
11218 v = (Ast * sz)()
11219 for i in range(sz):
11220 v[i] = args[i].as_ast()
11221 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11222
11223
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 3261 of file z3py.py.

3261def Ints(names, ctx=None):
3262 """Return a tuple of Integer constants.
3263
3264 >>> x, y, z = Ints('x y z')
3265 >>> Sum(x, y, z)
3266 x + y + z
3267 """
3268 ctx = _get_ctx(ctx)
3269 if isinstance(names, str):
3270 names = names.split(" ")
3271 return [Int(name, ctx) for name in names]
3272
3273

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

3138def IntSort(ctx=None):
3139 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3140
3141 >>> IntSort()
3142 Int
3143 >>> x = Const('x', IntSort())
3144 >>> is_int(x)
3145 True
3146 >>> x.sort() == IntSort()
3147 True
3148 >>> x.sort() == BoolSort()
3149 False
3150 """
3151 ctx = _get_ctx(ctx)
3152 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3153
3154
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 11114 of file z3py.py.

11114def IntToStr(s):
11115 """Convert integer expression to string"""
11116 if not is_expr(s):
11117 s = _py2expr(s)
11118 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11119
11120
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 3188 of file z3py.py.

3188def IntVal(val, ctx=None):
3189 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3190
3191 >>> IntVal(1)
3192 1
3193 >>> IntVal("100")
3194 100
3195 """
3196 ctx = _get_ctx(ctx)
3197 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3198
3199

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

3274def IntVector(prefix, sz, ctx=None):
3275 """Return a list of integer constants of size `sz`.
3276
3277 >>> X = IntVector('x', 3)
3278 >>> X
3279 [x__0, x__1, x__2]
3280 >>> Sum(X)
3281 x__0 + x__1 + x__2
3282 """
3283 ctx = _get_ctx(ctx)
3284 return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3285
3286

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4611def is_array(a):
4612 """Return `True` if `a` is a Z3 array expression.
4613
4614 >>> a = Array('a', IntSort(), IntSort())
4615 >>> is_array(a)
4616 True
4617 >>> is_array(Store(a, 0, 1))
4618 True
4619 >>> is_array(a[0])
4620 False
4621 """
4622 return isinstance(a, ArrayRef)
4623
4624

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

◆ is_array_sort()

def is_array_sort (   a)

Definition at line 4607 of file z3py.py.

4607def is_array_sort(a):
4608 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4609
4610

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

6694def is_as_array(n):
6695 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6696 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6697
6698
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 1571 of file z3py.py.

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

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

3944def is_bv(a):
3945 """Return `True` if `a` is a Z3 bit-vector expression.
3946
3947 >>> b = BitVec('b', 32)
3948 >>> is_bv(b)
3949 True
3950 >>> is_bv(b + 10)
3951 True
3952 >>> is_bv(Int('x'))
3953 False
3954 """
3955 return isinstance(a, BitVecRef)
3956
3957

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

3476def is_bv_sort(s):
3477 """Return True if `s` is a Z3 bit-vector sort.
3478
3479 >>> is_bv_sort(BitVecSort(32))
3480 True
3481 >>> is_bv_sort(IntSort())
3482 False
3483 """
3484 return isinstance(s, BitVecSortRef)
3485
3486

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

3958def is_bv_value(a):
3959 """Return `True` if `a` is a Z3 bit-vector numeral value.
3960
3961 >>> b = BitVec('b', 32)
3962 >>> is_bv_value(b)
3963 False
3964 >>> b = BitVecVal(10, 32)
3965 >>> b
3966 10
3967 >>> is_bv_value(b)
3968 True
3969 """
3970 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3971
3972

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

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

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

4625def is_const_array(a):
4626 """Return `True` if `a` is a Z3 constant array.
4627
4628 >>> a = K(IntSort(), 10)
4629 >>> is_const_array(a)
4630 True
4631 >>> a = Array('a', IntSort(), IntSort())
4632 >>> is_const_array(a)
4633 False
4634 """
4635 return is_app_of(a, Z3_OP_CONST_ARRAY)
4636
4637

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

4667def is_default(a):
4668 """Return `True` if `a` is a Z3 default array expression.
4669 >>> d = Default(K(IntSort(), 10))
4670 >>> is_default(d)
4671 True
4672 """
4673 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4674
4675

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

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

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

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

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

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

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

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

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

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

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

7747def is_finite_domain(a):
7748 """Return `True` if `a` is a Z3 finite-domain expression.
7749
7750 >>> s = FiniteDomainSort('S', 100)
7751 >>> b = Const('b', s)
7752 >>> is_finite_domain(b)
7753 True
7754 >>> is_finite_domain(Int('x'))
7755 False
7756 """
7757 return isinstance(a, FiniteDomainRef)
7758
7759

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

7724def is_finite_domain_sort(s):
7725 """Return True if `s` is a Z3 finite-domain sort.
7726
7727 >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7728 True
7729 >>> is_finite_domain_sort(IntSort())
7730 False
7731 """
7732 return isinstance(s, FiniteDomainSortRef)
7733
7734

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

7801def is_finite_domain_value(a):
7802 """Return `True` if `a` is a Z3 finite-domain value.
7803
7804 >>> s = FiniteDomainSort('S', 100)
7805 >>> b = Const('b', s)
7806 >>> is_finite_domain_value(b)
7807 False
7808 >>> b = FiniteDomainVal(10, s)
7809 >>> b
7810 10
7811 >>> is_finite_domain_value(b)
7812 True
7813 """
7814 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7815
7816

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

9872def is_fp(a):
9873 """Return `True` if `a` is a Z3 floating-point expression.
9874
9875 >>> b = FP('b', FPSort(8, 24))
9876 >>> is_fp(b)
9877 True
9878 >>> is_fp(b + 1.0)
9879 True
9880 >>> is_fp(Int('x'))
9881 False
9882 """
9883 return isinstance(a, FPRef)
9884
9885

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

9456def is_fp_sort(s):
9457 """Return True if `s` is a Z3 floating-point sort.
9458
9459 >>> is_fp_sort(FPSort(8, 24))
9460 True
9461 >>> is_fp_sort(IntSort())
9462 False
9463 """
9464 return isinstance(s, FPSortRef)
9465
9466

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

9886def is_fp_value(a):
9887 """Return `True` if `a` is a Z3 floating-point numeral value.
9888
9889 >>> b = FP('b', FPSort(8, 24))
9890 >>> is_fp_value(b)
9891 False
9892 >>> b = FPVal(1.0, FPSort(8, 24))
9893 >>> b
9894 1
9895 >>> is_fp_value(b)
9896 True
9897 """
9898 return is_fp(a) and _is_numeral(a.ctx, a.ast)
9899
9900

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

9716def is_fprm(a):
9717 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9718
9719 >>> rm = RNE()
9720 >>> is_fprm(rm)
9721 True
9722 >>> rm = 1.0
9723 >>> is_fprm(rm)
9724 False
9725 """
9726 return isinstance(a, FPRMRef)
9727
9728

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

9467def is_fprm_sort(s):
9468 """Return True if `s` is a Z3 floating-point rounding mode sort.
9469
9470 >>> is_fprm_sort(FPSort(8, 24))
9471 False
9472 >>> is_fprm_sort(RNE().sort())
9473 True
9474 """
9475 return isinstance(s, FPRMSortRef)
9476
9477# FP Expressions
9478
9479

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

9729def is_fprm_value(a):
9730 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9731 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9732
9733# FP Numerals
9734
9735

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

4638def is_K(a):
4639 """Return `True` if `a` is a Z3 constant array.
4640
4641 >>> a = K(IntSort(), 10)
4642 >>> is_K(a)
4643 True
4644 >>> a = Array('a', IntSort(), IntSort())
4645 >>> is_K(a)
4646 False
4647 """
4648 return is_app_of(a, Z3_OP_CONST_ARRAY)
4649
4650

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

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

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

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

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

4651def is_map(a):
4652 """Return `True` if `a` is a Z3 map array expression.
4653
4654 >>> f = Function('f', IntSort(), IntSort())
4655 >>> b = Array('b', IntSort(), IntSort())
4656 >>> a = Map(f, b)
4657 >>> a
4658 Map(f, b)
4659 >>> is_map(a)
4660 True
4661 >>> is_map(b)
4662 False
4663 """
4664 return is_app_of(a, Z3_OP_ARRAY_MAP)
4665
4666

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

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

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

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

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

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

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

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

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

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

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

8637def is_probe(p):
8638 """Return `True` if `p` is a Z3 probe.
8639
8640 >>> is_probe(Int('x'))
8641 False
8642 >>> is_probe(Probe('memory'))
8643 True
8644 """
8645 return isinstance(p, Probe)
8646
8647

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

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

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

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

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

◆ is_re()

def is_re (   s)

Definition at line 11168 of file z3py.py.

11168def is_re(s):
11169 return isinstance(s, ReRef)
11170
11171

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

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

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

4886def is_select(a):
4887 """Return `True` if `a` is a Z3 array select application.
4888
4889 >>> a = Array('a', IntSort(), IntSort())
4890 >>> is_select(a)
4891 False
4892 >>> i = Int('i')
4893 >>> is_select(a[i])
4894 True
4895 """
4896 return is_app_of(a, Z3_OP_SELECT)
4897
4898

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

10894def is_seq(a):
10895 """Return `True` if `a` is a Z3 sequence expression.
10896 >>> print (is_seq(Unit(IntVal(0))))
10897 True
10898 >>> print (is_seq(StringVal("abc")))
10899 True
10900 """
10901 return isinstance(a, SeqRef)
10902
10903

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

4899def is_store(a):
4900 """Return `True` if `a` is a Z3 array store application.
4901
4902 >>> a = Array('a', IntSort(), IntSort())
4903 >>> is_store(a)
4904 False
4905 >>> is_store(Store(a, 0, 1))
4906 True
4907 """
4908 return is_app_of(a, Z3_OP_STORE)
4909

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

10904def is_string(a):
10905 """Return `True` if `a` is a Z3 string expression.
10906 >>> print (is_string(StringVal("ab")))
10907 True
10908 """
10909 return isinstance(a, SeqRef) and a.is_string()
10910
10911

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

10912def is_string_value(a):
10913 """return 'True' if 'a' is a Z3 string constant expression.
10914 >>> print (is_string_value(StringVal("a")))
10915 True
10916 >>> print (is_string_value(StringVal("a") + StringVal("b")))
10917 False
10918 """
10919 return isinstance(a, SeqRef) and a.is_string_value()
10920

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

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

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

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

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

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

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

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

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

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

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

3394def IsInt(a):
3395 """ Return the Z3 predicate IsInt(a).
3396
3397 >>> x = Real('x')
3398 >>> IsInt(x + "1/2")
3399 IsInt(x + 1/2)
3400 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3401 [x = 1/2]
3402 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3403 no solution
3404 """
3405 if z3_debug():
3406 _z3_assert(a.is_real(), "Z3 real expression expected.")
3407 ctx = a.ctx
3408 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3409
3410
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 5009 of file z3py.py.

5009def IsMember(e, s):
5010 """ Check if e is a member of set s
5011 >>> a = Const('a', SetSort(IntSort()))
5012 >>> IsMember(1, a)
5013 a[1]
5014 """
5015 ctx = _ctx_from_ast_arg_list([s, e])
5016 e = _py2expr(e, ctx)
5017 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5018
5019
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 5020 of file z3py.py.

5020def IsSubset(a, b):
5021 """ Check if a is a subset of b
5022 >>> a = Const('a', SetSort(IntSort()))
5023 >>> b = Const('b', SetSort(IntSort()))
5024 >>> IsSubset(a, b)
5025 subset(a, b)
5026 """
5027 ctx = _ctx_from_ast_arg_list([a, b])
5028 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5029
5030
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 4846 of file z3py.py.

4846def K(dom, v):
4847 """Return a Z3 constant array expression.
4848
4849 >>> a = K(IntSort(), 10)
4850 >>> a
4851 K(Int, 10)
4852 >>> a.sort()
4853 Array(Int, Int)
4854 >>> i = Int('i')
4855 >>> a[i]
4856 K(Int, 10)[i]
4857 >>> simplify(a[i])
4858 10
4859 """
4860 if z3_debug():
4861 _z3_assert(is_sort(dom), "Z3 sort expected")
4862 ctx = dom.ctx
4863 if not is_expr(v):
4864 v = _py2expr(v, ctx)
4865 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4866
4867
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 2261 of file z3py.py.

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

11079def LastIndexOf(s, substr):
11080 """Retrieve the last index of substring within a string"""
11081 ctx = None
11082 ctx = _get_ctx2(s, substr, ctx)
11083 s = _coerce_seq(s, ctx)
11084 substr = _coerce_seq(substr, ctx)
11085 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11086
11087
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 11088 of file z3py.py.

11088def Length(s):
11089 """Obtain the length of a sequence 's'
11090 >>> l = Length(StringVal("abc"))
11091 >>> simplify(l)
11092 3
11093 """
11094 s = _coerce_seq(s)
11095 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11096
11097
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 11310 of file z3py.py.

11310def LinearOrder(a, index):
11311 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11312
11313
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 11268 of file z3py.py.

11268def Loop(re, lo, hi=0):
11269 """Create the regular expression accepting between a lower and upper bound repetitions
11270 >>> re = Loop(Re("a"), 1, 3)
11271 >>> print(simplify(InRe("aa", re)))
11272 True
11273 >>> print(simplify(InRe("aaaa", re)))
11274 False
11275 >>> print(simplify(InRe("", re)))
11276 False
11277 """
11278 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11279
11280
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 4299 of file z3py.py.

4299def LShR(a, b):
4300 """Create the Z3 expression logical right shift.
4301
4302 Use the operator >> for the arithmetical right shift.
4303
4304 >>> x, y = BitVecs('x y', 32)
4305 >>> LShR(x, y)
4306 LShR(x, y)
4307 >>> (x >> y).sexpr()
4308 '(bvashr x y)'
4309 >>> LShR(x, y).sexpr()
4310 '(bvlshr x y)'
4311 >>> BitVecVal(4, 3)
4312 4
4313 >>> BitVecVal(4, 3).as_signed_long()
4314 -4
4315 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4316 -2
4317 >>> simplify(BitVecVal(4, 3) >> 1)
4318 6
4319 >>> simplify(LShR(BitVecVal(4, 3), 1))
4320 2
4321 >>> simplify(BitVecVal(2, 3) >> 1)
4322 1
4323 >>> simplify(LShR(BitVecVal(2, 3), 1))
4324 1
4325 """
4326 _check_bv_args(a, b)
4327 a, b = _coerce_exprs(a, b)
4328 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4329
4330
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 4823 of file z3py.py.

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

1834def mk_not(a):
1835 if is_not(a):
1836 return a.arg(0)
1837 else:
1838 return Not(a)
1839
1840

◆ Model()

def Model (   ctx = None)

Definition at line 6689 of file z3py.py.

6689def Model(ctx=None):
6690 ctx = _get_ctx(ctx)
6691 return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6692
6693
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 1951 of file z3py.py.

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

1815def Not(a, ctx=None):
1816 """Create a Z3 not expression or probe.
1817
1818 >>> p = Bool('p')
1819 >>> Not(Not(p))
1820 Not(Not(p))
1821 >>> simplify(Not(Not(p)))
1822 p
1823 """
1824 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1825 if is_probe(a):
1826 # Not is also used to build probes
1827 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1828 else:
1829 s = BoolSort(ctx)
1830 a = s.cast(a)
1831 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1832
1833
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 11350 of file z3py.py.

11350def on_clause_eh(ctx, p, clause):
11351 onc = _my_hacky_class
11352 p = _to_expr_ref(to_Ast(p), onc.ctx)
11353 clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11354 onc.on_clause(p, clause)
11355

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

11237def Option(re):
11238 """Create the regular expression that optionally accepts the argument.
11239 >>> re = Option(Re("a"))
11240 >>> print(simplify(InRe("a", re)))
11241 True
11242 >>> print(simplify(InRe("", re)))
11243 True
11244 >>> print(simplify(InRe("aa", re)))
11245 False
11246 """
11247 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11248
11249
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 1882 of file z3py.py.

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

8330def OrElse(*ts, **ks):
8331 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8332
8333 >>> x = Int('x')
8334 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8335 >>> # Tactic split-clause fails if there is no clause in the given goal.
8336 >>> t(x == 0)
8337 [[x == 0]]
8338 >>> t(Or(x == 0, x == 1))
8339 [[x == 0], [x == 1]]
8340 """
8341 if z3_debug():
8342 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8343 ctx = ks.get("ctx", None)
8344 num = len(ts)
8345 r = ts[0]
8346 for i in range(num - 1):
8347 r = _or_else(r, ts[i + 1], ctx)
8348 return r
8349
8350

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

◆ ParAndThen()

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

Definition at line 8386 of file z3py.py.

8386def ParAndThen(t1, t2, ctx=None):
8387 """Alias for ParThen(t1, t2, ctx)."""
8388 return ParThen(t1, t2, ctx)
8389
8390

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

8351def ParOr(*ts, **ks):
8352 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8353
8354 >>> x = Int('x')
8355 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8356 >>> t(x + 1 == 2)
8357 [[x == 1]]
8358 """
8359 if z3_debug():
8360 _z3_assert(len(ts) >= 2, "At least two arguments expected")
8361 ctx = _get_ctx(ks.get("ctx", None))
8362 ts = [_to_tactic(t, ctx) for t in ts]
8363 sz = len(ts)
8364 _args = (TacticObj * sz)()
8365 for i in range(sz):
8366 _args[i] = ts[i].tactic
8367 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8368
8369
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 9266 of file z3py.py.

9266def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9267 """Parse a file in SMT 2.0 format using the given sorts and decls.
9268
9269 This function is similar to parse_smt2_string().
9270 """
9271 ctx = _get_ctx(ctx)
9272 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9273 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9274 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9275
9276
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 9245 of file z3py.py.

9245def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9246 """Parse a string in SMT 2.0 format using the given sorts and decls.
9247
9248 The arguments sorts and decls are Python dictionaries used to initialize
9249 the symbol table used for the SMT 2.0 parser.
9250
9251 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9252 [x > 0, x < 10]
9253 >>> x, y = Ints('x y')
9254 >>> f = Function('f', IntSort(), IntSort())
9255 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9256 [x + f(y) > 0]
9257 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9258 [a > 0]
9259 """
9260 ctx = _get_ctx(ctx)
9261 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9262 dsz, dnames, ddecls = _dict2darray(decls, ctx)
9263 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9264
9265
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 8370 of file z3py.py.

8370def ParThen(t1, t2, ctx=None):
8371 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8372 The subgoals are processed in parallel.
8373
8374 >>> x, y = Ints('x y')
8375 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8376 >>> t(And(Or(x == 1, x == 2), y == x + 1))
8377 [[x == 1, y == 2], [x == 2, y == 3]]
8378 """
8379 t1 = _to_tactic(t1, ctx)
8380 t2 = _to_tactic(t2, ctx)
8381 if z3_debug():
8382 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8383 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8384
8385
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 11306 of file z3py.py.

11306def PartialOrder(a, index):
11307 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11308
11309
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 inequality k constraint.

>>> a, b, c = Bools('a b c')
>>> f = PbEq(((a,1),(b,3),(c,2)), 3)

Definition at line 9022 of file z3py.py.

9022def PbEq(args, k, ctx=None):
9023 """Create a Pseudo-Boolean inequality k constraint.
9024
9025 >>> a, b, c = Bools('a b c')
9026 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9027 """
9028 _z3_check_cint_overflow(k, "k")
9029 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9030 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9031
9032
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 9011 of file z3py.py.

9011def PbGe(args, k):
9012 """Create a Pseudo-Boolean inequality k constraint.
9013
9014 >>> a, b, c = Bools('a b c')
9015 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9016 """
9017 _z3_check_cint_overflow(k, "k")
9018 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9019 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9020
9021
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 9000 of file z3py.py.

9000def PbLe(args, k):
9001 """Create a Pseudo-Boolean inequality k constraint.
9002
9003 >>> a, b, c = Bools('a b c')
9004 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9005 """
9006 _z3_check_cint_overflow(k, "k")
9007 ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9008 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9009
9010
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 11318 of file z3py.py.

11318def PiecewiseLinearOrder(a, index):
11319 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11320
11321
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 11224 of file z3py.py.

11224def Plus(re):
11225 """Create the regular expression accepting one or more repetitions of argument.
11226 >>> re = Plus(Re("a"))
11227 >>> print(simplify(InRe("aa", re)))
11228 True
11229 >>> print(simplify(InRe("ab", re)))
11230 False
11231 >>> print(simplify(InRe("", re)))
11232 False
11233 """
11234 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11235
11236
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 10995 of file z3py.py.

10995def PrefixOf(a, b):
10996 """Check if 'a' is a prefix of 'b'
10997 >>> s1 = PrefixOf("ab", "abc")
10998 >>> simplify(s1)
10999 True
11000 >>> s2 = PrefixOf("bc", "abc")
11001 >>> simplify(s2)
11002 False
11003 """
11004 ctx = _get_ctx2(a, b)
11005 a = _coerce_seq(a, ctx)
11006 b = _coerce_seq(b, ctx)
11007 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11008
11009
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 8666 of file z3py.py.

8666def probe_description(name, ctx=None):
8667 """Return a short description for the probe named `name`.
8668
8669 >>> d = probe_description('memory')
8670 """
8671 ctx = _get_ctx(ctx)
8672 return Z3_probe_get_descr(ctx.ref(), name)
8673
8674
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 8655 of file z3py.py.

8655def probes(ctx=None):
8656 """Return a list of all available probes in Z3.
8657
8658 >>> l = probes()
8659 >>> l.count('memory') == 1
8660 True
8661 """
8662 ctx = _get_ctx(ctx)
8663 return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8664
8665
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 8907 of file z3py.py.

8907def Product(*args):
8908 """Create the product of the Z3 expressions.
8909
8910 >>> a, b, c = Ints('a b c')
8911 >>> Product(a, b, c)
8912 a*b*c
8913 >>> Product([a, b, c])
8914 a*b*c
8915 >>> A = IntVector('a', 5)
8916 >>> Product(A)
8917 a__0*a__1*a__2*a__3*a__4
8918 """
8919 args = _get_args(args)
8920 if len(args) == 0:
8921 return 1
8922 ctx = _ctx_from_ast_arg_list(args)
8923 if ctx is None:
8924 return _reduce(lambda a, b: a * b, args, 1)
8925 args = _coerce_expr_list(args, ctx)
8926 if is_bv(args[0]):
8927 return _reduce(lambda a, b: a * b, args, 1)
8928 else:
8929 _args, sz = _to_ast_array(args)
8930 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8931
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 11501 of file z3py.py.

11501def PropagateFunction(name, *sig):
11502 """Create a function that gets tracked by user propagator.
11503 Every term headed by this function symbol is tracked.
11504 If a term is fixed and the fixed callback is registered a
11505 callback is invoked that the term headed by this function is fixed.
11506 """
11507 sig = _get_args(sig)
11508 if z3_debug():
11509 _z3_assert(len(sig) > 0, "At least two arguments expected")
11510 arity = len(sig) - 1
11511 rng = sig[arity]
11512 if z3_debug():
11513 _z3_assert(is_sort(rng), "Z3 sort expected")
11514 dom = (Sort * arity)()
11515 for i in range(arity):
11516 if z3_debug():
11517 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11518 dom[i] = sig[i].ast
11519 ctx = rng.ctx
11520 return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11521
11522
11523
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 9094 of file z3py.py.

9094def prove(claim, show=False, **keywords):
9095 """Try to prove the given claim.
9096
9097 This is a simple function for creating demonstrations. It tries to prove
9098 `claim` by showing the negation is unsatisfiable.
9099
9100 >>> p, q = Bools('p q')
9101 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9102 proved
9103 """
9104 if z3_debug():
9105 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9106 s = Solver()
9107 s.set(**keywords)
9108 s.add(Not(claim))
9109 if show:
9110 print(s)
9111 r = s.check()
9112 if r == unsat:
9113 print("proved")
9114 elif r == unknown:
9115 print("failed to prove")
9116 print(s.model())
9117 else:
9118 print("counterexample")
9119 print(s.model())
9120
9121

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

3235def Q(a, b, ctx=None):
3236 """Return a Z3 rational a/b.
3237
3238 If `ctx=None`, then the global context is used.
3239
3240 >>> Q(3,5)
3241 3/5
3242 >>> Q(3,5).sort()
3243 Real
3244 """
3245 return simplify(RatVal(a, b, ctx=ctx))
3246
3247

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

11281def Range(lo, hi, ctx=None):
11282 """Create the range regular expression over two sequences of length 1
11283 >>> range = Range("a","z")
11284 >>> print(simplify(InRe("b", range)))
11285 True
11286 >>> print(simplify(InRe("bb", range)))
11287 False
11288 """
11289 lo = _coerce_seq(lo, ctx)
11290 hi = _coerce_seq(hi, ctx)
11291 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11292
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 3219 of file z3py.py.

3219def RatVal(a, b, ctx=None):
3220 """Return a Z3 rational a/b.
3221
3222 If `ctx=None`, then the global context is used.
3223
3224 >>> RatVal(3,5)
3225 3/5
3226 >>> RatVal(3,5).sort()
3227 Real
3228 """
3229 if z3_debug():
3230 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3231 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3232 return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3233
3234

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

11133def Re(s, ctx=None):
11134 """The regular expression that accepts sequence 's'
11135 >>> s1 = Re("ab")
11136 >>> s2 = Re(StringVal("ab"))
11137 >>> s3 = Re(Unit(BoolVal(True)))
11138 """
11139 s = _coerce_seq(s, ctx)
11140 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11141
11142
11143# Regular expressions
11144
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 3301 of file z3py.py.

3301def Real(name, ctx=None):
3302 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3303
3304 >>> x = Real('x')
3305 >>> is_real(x)
3306 True
3307 >>> is_real(x + 1)
3308 True
3309 """
3310 ctx = _get_ctx(ctx)
3311 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3312
3313

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

3314def Reals(names, ctx=None):
3315 """Return a tuple of real constants.
3316
3317 >>> x, y, z = Reals('x y z')
3318 >>> Sum(x, y, z)
3319 x + y + z
3320 >>> Sum(x, y, z).sort()
3321 Real
3322 """
3323 ctx = _get_ctx(ctx)
3324 if isinstance(names, str):
3325 names = names.split(" ")
3326 return [Real(name, ctx) for name in names]
3327
3328

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

3155def RealSort(ctx=None):
3156 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3157
3158 >>> RealSort()
3159 Real
3160 >>> x = Const('x', RealSort())
3161 >>> is_real(x)
3162 True
3163 >>> is_int(x)
3164 False
3165 >>> x.sort() == RealSort()
3166 True
3167 """
3168 ctx = _get_ctx(ctx)
3169 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3170
3171
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 3200 of file z3py.py.

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

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

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

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

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

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

3329def RealVector(prefix, sz, ctx=None):
3330 """Return a list of real constants of size `sz`.
3331
3332 >>> X = RealVector('x', 3)
3333 >>> X
3334 [x__0, x__1, x__2]
3335 >>> Sum(X)
3336 x__0 + x__1 + x__2
3337 >>> Sum(X).sort()
3338 Real
3339 """
3340 ctx = _get_ctx(ctx)
3341 return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3342
3343

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

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

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

8419def Repeat(t, max=4294967295, ctx=None):
8420 """Return a tactic that keeps applying `t` until the goal is not modified anymore
8421 or the maximum number of iterations `max` is reached.
8422
8423 >>> x, y = Ints('x y')
8424 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8425 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8426 >>> r = t(c)
8427 >>> for subgoal in r: print(subgoal)
8428 [x == 0, y == 0, x > y]
8429 [x == 0, y == 1, x > y]
8430 [x == 1, y == 0, x > y]
8431 [x == 1, y == 1, x > y]
8432 >>> t = Then(t, Tactic('propagate-values'))
8433 >>> t(c)
8434 [[x == 1, y == 0]]
8435 """
8436 t = _to_tactic(t, ctx)
8437 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8438
8439
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 4421 of file z3py.py.

4421def RepeatBitVec(n, a):
4422 """Return an expression representing `n` copies of `a`.
4423
4424 >>> x = BitVec('x', 8)
4425 >>> n = RepeatBitVec(4, x)
4426 >>> n
4427 RepeatBitVec(4, x)
4428 >>> n.size()
4429 32
4430 >>> v0 = BitVecVal(10, 4)
4431 >>> print("%.x" % v0.as_long())
4432 a
4433 >>> v = simplify(RepeatBitVec(4, v0))
4434 >>> v.size()
4435 16
4436 >>> print("%.x" % v.as_long())
4437 aaaa
4438 """
4439 if z3_debug():
4440 _z3_assert(_is_int(n), "First argument must be an integer")
4441 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4442 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4443
4444
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 11044 of file z3py.py.

11044def Replace(s, src, dst):
11045 """Replace the first occurrence of 'src' by 'dst' in 's'
11046 >>> r = Replace("aaa", "a", "b")
11047 >>> simplify(r)
11048 "baa"
11049 """
11050 ctx = _get_ctx2(dst, s)
11051 if ctx is None and is_expr(src):
11052 ctx = src.ctx
11053 src = _coerce_seq(src, ctx)
11054 dst = _coerce_seq(dst, ctx)
11055 s = _coerce_seq(s, ctx)
11056 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11057
11058
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 11152 of file z3py.py.

11152def ReSort(s):
11153 if is_ast(s):
11154 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11155 if s is None or isinstance(s, Context):
11156 ctx = _get_ctx(s)
11157 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11158 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11159
11160
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 9681 of file z3py.py.

9681def RNA(ctx=None):
9682 ctx = _get_ctx(ctx)
9683 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9684
9685
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 9671 of file z3py.py.

9671def RNE(ctx=None):
9672 ctx = _get_ctx(ctx)
9673 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9674
9675
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 4331 of file z3py.py.

4331def RotateLeft(a, b):
4332 """Return an expression representing `a` rotated to the left `b` times.
4333
4334 >>> a, b = BitVecs('a b', 16)
4335 >>> RotateLeft(a, b)
4336 RotateLeft(a, b)
4337 >>> simplify(RotateLeft(a, 0))
4338 a
4339 >>> simplify(RotateLeft(a, 16))
4340 a
4341 """
4342 _check_bv_args(a, b)
4343 a, b = _coerce_exprs(a, b)
4344 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4345
4346
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 4347 of file z3py.py.

4347def RotateRight(a, b):
4348 """Return an expression representing `a` rotated to the right `b` times.
4349
4350 >>> a, b = BitVecs('a b', 16)
4351 >>> RotateRight(a, b)
4352 RotateRight(a, b)
4353 >>> simplify(RotateRight(a, 0))
4354 a
4355 >>> simplify(RotateRight(a, 16))
4356 a
4357 """
4358 _check_bv_args(a, b)
4359 a, b = _coerce_exprs(a, b)
4360 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4361
4362
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 9676 of file z3py.py.

9676def RoundNearestTiesToAway(ctx=None):
9677 ctx = _get_ctx(ctx)
9678 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9679
9680

◆ RoundNearestTiesToEven()

def RoundNearestTiesToEven (   ctx = None)

Definition at line 9666 of file z3py.py.

9666def RoundNearestTiesToEven(ctx=None):
9667 ctx = _get_ctx(ctx)
9668 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9669
9670

◆ RoundTowardNegative()

def RoundTowardNegative (   ctx = None)

Definition at line 9696 of file z3py.py.

9696def RoundTowardNegative(ctx=None):
9697 ctx = _get_ctx(ctx)
9698 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9699
9700
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 9686 of file z3py.py.

9686def RoundTowardPositive(ctx=None):
9687 ctx = _get_ctx(ctx)
9688 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9689
9690
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 9706 of file z3py.py.

9706def RoundTowardZero(ctx=None):
9707 ctx = _get_ctx(ctx)
9708 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9709
9710
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 9701 of file z3py.py.

9701def RTN(ctx=None):
9702 ctx = _get_ctx(ctx)
9703 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9704
9705

Referenced by get_default_rounding_mode().

◆ RTP()

def RTP (   ctx = None)

Definition at line 9691 of file z3py.py.

9691def RTP(ctx=None):
9692 ctx = _get_ctx(ctx)
9693 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9694
9695

Referenced by get_default_rounding_mode().

◆ RTZ()

def RTZ (   ctx = None)

Definition at line 9711 of file z3py.py.

9711def RTZ(ctx=None):
9712 ctx = _get_ctx(ctx)
9713 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9714
9715

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

4807def Select(a, *args):
4808 """Return a Z3 select array expression.
4809
4810 >>> a = Array('a', IntSort(), IntSort())
4811 >>> i = Int('i')
4812 >>> Select(a, i)
4813 a[i]
4814 >>> eq(Select(a, i), a[i])
4815 True
4816 """
4817 args = _get_args(args)
4818 if z3_debug():
4819 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4820 return a[args]
4821
4822

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

10765def SeqSort(s):
10766 """Create a sequence sort over elements provided in the argument
10767 >>> s = SeqSort(IntSort())
10768 >>> s == Unit(IntVal(1)).sort()
10769 True
10770 """
10771 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10772
10773
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 9327 of file z3py.py.

9327def set_default_fp_sort(ebits, sbits, ctx=None):
9328 global _dflt_fpsort_ebits
9329 global _dflt_fpsort_sbits
9330 _dflt_fpsort_ebits = ebits
9331 _dflt_fpsort_sbits = sbits
9332
9333

◆ set_default_rounding_mode()

def set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 9314 of file z3py.py.

9314def set_default_rounding_mode(rm, ctx=None):
9315 global _dflt_rounding_mode
9316 if is_fprm_value(rm):
9317 _dflt_rounding_mode = rm.decl().kind()
9318 else:
9319 _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9320 _dflt_rounding_mode = rm
9321
9322

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

4966def SetAdd(s, e):
4967 """ Add element e to set s
4968 >>> a = Const('a', SetSort(IntSort()))
4969 >>> SetAdd(a, 1)
4970 Store(a, 1, True)
4971 """
4972 ctx = _ctx_from_ast_arg_list([s, e])
4973 e = _py2expr(e, ctx)
4974 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4975
4976
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 4988 of file z3py.py.

4988def SetComplement(s):
4989 """ The complement of set s
4990 >>> a = Const('a', SetSort(IntSort()))
4991 >>> SetComplement(a)
4992 complement(a)
4993 """
4994 ctx = s.ctx
4995 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4996
4997
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 4977 of file z3py.py.

4977def SetDel(s, e):
4978 """ Remove element e to set s
4979 >>> a = Const('a', SetSort(IntSort()))
4980 >>> SetDel(a, 1)
4981 Store(a, 1, False)
4982 """
4983 ctx = _ctx_from_ast_arg_list([s, e])
4984 e = _py2expr(e, ctx)
4985 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4986
4987
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 4998 of file z3py.py.

4998def SetDifference(a, b):
4999 """ The set difference of a and b
5000 >>> a = Const('a', SetSort(IntSort()))
5001 >>> b = Const('b', SetSort(IntSort()))
5002 >>> SetDifference(a, b)
5003 setminus(a, b)
5004 """
5005 ctx = _ctx_from_ast_arg_list([a, b])
5006 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5007
5008
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 4880 of file z3py.py.

4880def SetHasSize(a, k):
4881 ctx = a.ctx
4882 k = _py2expr(k, ctx)
4883 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4884
4885
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 4953 of file z3py.py.

4953def SetIntersect(*args):
4954 """ Take the union of sets
4955 >>> a = Const('a', SetSort(IntSort()))
4956 >>> b = Const('b', SetSort(IntSort()))
4957 >>> SetIntersect(a, b)
4958 intersection(a, b)
4959 """
4960 args = _get_args(args)
4961 ctx = _ctx_from_ast_arg_list(args)
4962 _args, sz = _to_ast_array(args)
4963 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4964
4965
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 4917 of file z3py.py.

4917def SetSort(s):
4918 """ Create a set sort over element sort s"""
4919 return ArraySort(s, BoolSort())
4920
4921

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

4940def SetUnion(*args):
4941 """ Take the union of sets
4942 >>> a = Const('a', SetSort(IntSort()))
4943 >>> b = Const('b', SetSort(IntSort()))
4944 >>> SetUnion(a, b)
4945 union(a, b)
4946 """
4947 args = _get_args(args)
4948 ctx = _ctx_from_ast_arg_list(args)
4949 _args, sz = _to_ast_array(args)
4950 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4951
4952
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 4363 of file z3py.py.

4363def SignExt(n, a):
4364 """Return a bit-vector expression with `n` extra sign-bits.
4365
4366 >>> x = BitVec('x', 16)
4367 >>> n = SignExt(8, x)
4368 >>> n.size()
4369 24
4370 >>> n
4371 SignExt(8, x)
4372 >>> n.sort()
4373 BitVec(24)
4374 >>> v0 = BitVecVal(2, 2)
4375 >>> v0
4376 2
4377 >>> v0.size()
4378 2
4379 >>> v = simplify(SignExt(6, v0))
4380 >>> v
4381 254
4382 >>> v.size()
4383 8
4384 >>> print("%.x" % v.as_long())
4385 fe
4386 """
4387 if z3_debug():
4388 _z3_assert(_is_int(n), "First argument must be an integer")
4389 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4390 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4391
4392
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 7419 of file z3py.py.

7419def SimpleSolver(ctx=None, logFile=None):
7420 """Return a simple general purpose solver with limited amount of preprocessing.
7421
7422 >>> s = SimpleSolver()
7423 >>> x = Int('x')
7424 >>> s.add(x > 0)
7425 >>> s.check()
7426 sat
7427 """
7428 ctx = _get_ctx(ctx)
7429 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7430
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 8771 of file z3py.py.

8771def simplify(a, *arguments, **keywords):
8772 """Simplify the expression `a` using the given options.
8773
8774 This function has many options. Use `help_simplify` to obtain the complete list.
8775
8776 >>> x = Int('x')
8777 >>> y = Int('y')
8778 >>> simplify(x + 1 + y + x + 1)
8779 2 + 2*x + y
8780 >>> simplify((x + 1)*(y + 1), som=True)
8781 1 + x + y + x*y
8782 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8783 And(Not(x == y), Not(x == 1), Not(y == 1))
8784 >>> simplify(And(x == 0, y == 1), elim_and=True)
8785 Not(Or(Not(x == 0), Not(y == 1)))
8786 """
8787 if z3_debug():
8788 _z3_assert(is_expr(a), "Z3 expression expected")
8789 if len(arguments) > 0 or len(keywords) > 0:
8790 p = args2params(arguments, keywords, a.ctx)
8791 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8792 else:
8793 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8794
8795
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 8801 of file z3py.py.

8801def simplify_param_descrs():
8802 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8803 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8804
8805
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 9033 of file z3py.py.

9033def solve(*args, **keywords):
9034 """Solve the constraints `*args`.
9035
9036 This is a simple function for creating demonstrations. It creates a solver,
9037 configure it using the options in `keywords`, adds the constraints
9038 in `args`, and invokes check.
9039
9040 >>> a = Int('a')
9041 >>> solve(a > 0, a < 2)
9042 [a = 1]
9043 """
9044 show = keywords.pop("show", False)
9045 s = Solver()
9046 s.set(**keywords)
9047 s.add(*args)
9048 if show:
9049 print(s)
9050 r = s.check()
9051 if r == unsat:
9052 print("no solution")
9053 elif r == unknown:
9054 print("failed to solve")
9055 try:
9056 print(s.model())
9057 except Z3Exception:
9058 return
9059 else:
9060 print(s.model())
9061
9062

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

9063def solve_using(s, *args, **keywords):
9064 """Solve the constraints `*args` using solver `s`.
9065
9066 This is a simple function for creating demonstrations. It is similar to `solve`,
9067 but it uses the given solver `s`.
9068 It configures solver `s` using the options in `keywords`, adds the constraints
9069 in `args`, and invokes check.
9070 """
9071 show = keywords.pop("show", False)
9072 if z3_debug():
9073 _z3_assert(isinstance(s, Solver), "Solver object expected")
9074 s.set(**keywords)
9075 s.add(*args)
9076 if show:
9077 print("Problem:")
9078 print(s)
9079 r = s.check()
9080 if r == unsat:
9081 print("no solution")
9082 elif r == unknown:
9083 print("failed to solve")
9084 try:
9085 print(s.model())
9086 except Z3Exception:
9087 return
9088 else:
9089 if show:
9090 print("Solution:")
9091 print(s.model())
9092
9093

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

7398def SolverFor(logic, ctx=None, logFile=None):
7399 """Create a solver customized for the given logic.
7400
7401 The parameter `logic` is a string. It should be contains
7402 the name of a SMT-LIB logic.
7403 See http://www.smtlib.org/ for the name of all available logics.
7404
7405 >>> s = SolverFor("QF_LIA")
7406 >>> x = Int('x')
7407 >>> s.add(x > 0)
7408 >>> s.add(x < 2)
7409 >>> s.check()
7410 sat
7411 >>> s.model()
7412 [x = 1]
7413 """
7414 ctx = _get_ctx(ctx)
7415 logic = to_symbol(logic)
7416 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7417
7418
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 3411 of file z3py.py.

3411def Sqrt(a, ctx=None):
3412 """ Return a Z3 expression which represents the square root of a.
3413
3414 >>> x = Real('x')
3415 >>> Sqrt(x)
3416 x**(1/2)
3417 """
3418 if not is_expr(a):
3419 ctx = _get_ctx(ctx)
3420 a = RealVal(a, ctx)
3421 return a ** "1/2"
3422
3423

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

4278def SRem(a, b):
4279 """Create the Z3 expression signed remainder.
4280
4281 Use the operator % for signed modulus, and URem() for unsigned remainder.
4282
4283 >>> x = BitVec('x', 32)
4284 >>> y = BitVec('y', 32)
4285 >>> SRem(x, y)
4286 SRem(x, y)
4287 >>> SRem(x, y).sort()
4288 BitVec(32)
4289 >>> (x % y).sexpr()
4290 '(bvsmod x y)'
4291 >>> SRem(x, y).sexpr()
4292 '(bvsrem x y)'
4293 """
4294 _check_bv_args(a, b)
4295 a, b = _coerce_exprs(a, b)
4296 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4297
4298
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 11255 of file z3py.py.

11255def Star(re):
11256 """Create the regular expression accepting zero or more repetitions of argument.
11257 >>> re = Star(Re("a"))
11258 >>> print(simplify(InRe("aa", re)))
11259 True
11260 >>> print(simplify(InRe("ab", re)))
11261 False
11262 >>> print(simplify(InRe("", re)))
11263 True
11264 """
11265 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11266
11267
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 4790 of file z3py.py.

4790def Store(a, *args):
4791 """Return a Z3 store array expression.
4792
4793 >>> a = Array('a', IntSort(), IntSort())
4794 >>> i, v = Ints('i v')
4795 >>> s = Store(a, i, v)
4796 >>> s.sort()
4797 Array(Int, Int)
4798 >>> prove(s[i] == v)
4799 proved
4800 >>> j = Int('j')
4801 >>> prove(Implies(i != j, s[j] == a[j]))
4802 proved
4803 """
4804 return Update(a, args)
4805
4806

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

11127def StrFromCode(c):
11128 """Convert code to a string"""
11129 if not is_expr(c):
11130 c = _py2expr(c)
11131 return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11132
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 10928 of file z3py.py.

10928def String(name, ctx=None):
10929 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10930
10931 >>> x = String('x')
10932 """
10933 ctx = _get_ctx(ctx)
10934 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10935
10936

Referenced by String(), and Strings().

◆ Strings()

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

Definition at line 10937 of file z3py.py.

10937def Strings(names, ctx=None):
10938 """Return a tuple of String constants. """
10939 ctx = _get_ctx(ctx)
10940 if isinstance(names, str):
10941 names = names.split(" ")
10942 return [String(name, ctx) for name in names]
10943
10944

Referenced by Contains().

◆ StringSort()

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

Definition at line 10746 of file z3py.py.

10746def StringSort(ctx=None):
10747 """Create a string sort
10748 >>> s = StringSort()
10749 >>> print(s)
10750 String
10751 """
10752 ctx = _get_ctx(ctx)
10753 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10754

Referenced by DisjointSum(), Empty(), Full(), SeqSortRef.is_string(), String(), and TupleSort().

◆ StringVal()

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

Definition at line 10921 of file z3py.py.

10921def StringVal(s, ctx=None):
10922 """create a string expression"""
10923 s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
10924 ctx = _get_ctx(ctx)
10925 return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
10926
10927
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 11121 of file z3py.py.

11121def StrToCode(s):
11122 """Convert a unit length string to integer code"""
11123 if not is_expr(s):
11124 s = _py2expr(s)
11125 return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11126
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 11098 of file z3py.py.

11098def StrToInt(s):
11099 """Convert string expression to integer
11100 >>> a = StrToInt("1")
11101 >>> simplify(1 == a)
11102 True
11103 >>> b = StrToInt("2")
11104 >>> simplify(1 == b)
11105 False
11106 >>> c = StrToInt(IntToStr(2))
11107 >>> simplify(1 == c)
11108 False
11109 """
11110 s = _coerce_seq(s)
11111 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11112
11113
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 10950 of file z3py.py.

10950def SubSeq(s, offset, length):
10951 """Extract substring or subsequence starting at offset"""
10952 return Extract(s, offset, length)
10953
10954

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

8806def substitute(t, *m):
8807 """Apply substitution m on t, m is a list of pairs of the form (from, to).
8808 Every occurrence in t of from is replaced with to.
8809
8810 >>> x = Int('x')
8811 >>> y = Int('y')
8812 >>> substitute(x + 1, (x, y + 1))
8813 y + 1 + 1
8814 >>> f = Function('f', IntSort(), IntSort())
8815 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8816 1 + 1
8817 """
8818 if isinstance(m, tuple):
8819 m1 = _get_args(m)
8820 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8821 m = m1
8822 if z3_debug():
8823 _z3_assert(is_expr(t), "Z3 expression expected")
8824 _z3_assert(
8825 all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
8826 "Z3 invalid substitution, expression pairs expected.")
8827 _z3_assert(
8828 all([p[0].sort().eq(p[1].sort()) for p in m]),
8829 'Z3 invalid substitution, mismatching "from" and "to" sorts.')
8830 num = len(m)
8831 _from = (Ast * num)()
8832 _to = (Ast * num)()
8833 for i in range(num):
8834 _from[i] = m[i][0].as_ast()
8835 _to[i] = m[i][1].as_ast()
8836 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8837
8838
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 8859 of file z3py.py.

8859def substitute_funs(t, *m):
8860 """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
8861 Every occurrence in to of the function from is replaced with the expression to.
8862 The expression to can have free variables, that refer to the arguments of from.
8863 For examples, see
8864 """
8865 if isinstance(m, tuple):
8866 m1 = _get_args(m)
8867 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8868 m = m1
8869 if z3_debug():
8870 _z3_assert(is_expr(t), "Z3 expression expected")
8871 _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.")
8872 num = len(m)
8873 _from = (FuncDecl * num)()
8874 _to = (Ast * num)()
8875 for i in range(num):
8876 _from[i] = m[i][0].as_func_decl()
8877 _to[i] = m[i][1].as_ast()
8878 return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8879
8880
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 8839 of file z3py.py.

8839def substitute_vars(t, *m):
8840 """Substitute the free variables in t with the expression in m.
8841
8842 >>> v0 = Var(0, IntSort())
8843 >>> v1 = Var(1, IntSort())
8844 >>> x = Int('x')
8845 >>> f = Function('f', IntSort(), IntSort(), IntSort())
8846 >>> # replace v0 with x+1 and v1 with x
8847 >>> substitute_vars(f(v0, v1), x + 1, x)
8848 f(x + 1, x)
8849 """
8850 if z3_debug():
8851 _z3_assert(is_expr(t), "Z3 expression expected")
8852 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8853 num = len(m)
8854 _to = (Ast * num)()
8855 for i in range(num):
8856 _to[i] = m[i].as_ast()
8857 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8858
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 10945 of file z3py.py.

10945def SubString(s, offset, length):
10946 """Extract substring or subsequence starting at offset"""
10947 return Extract(s, offset, length)
10948
10949

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

11010def SuffixOf(a, b):
11011 """Check if 'a' is a suffix of 'b'
11012 >>> s1 = SuffixOf("ab", "abc")
11013 >>> simplify(s1)
11014 False
11015 >>> s2 = SuffixOf("bc", "abc")
11016 >>> simplify(s2)
11017 True
11018 """
11019 ctx = _get_ctx2(a, b)
11020 a = _coerce_seq(a, ctx)
11021 b = _coerce_seq(b, ctx)
11022 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11023
11024
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 8881 of file z3py.py.

8881def Sum(*args):
8882 """Create the sum of the Z3 expressions.
8883
8884 >>> a, b, c = Ints('a b c')
8885 >>> Sum(a, b, c)
8886 a + b + c
8887 >>> Sum([a, b, c])
8888 a + b + c
8889 >>> A = IntVector('a', 5)
8890 >>> Sum(A)
8891 a__0 + a__1 + a__2 + a__3 + a__4
8892 """
8893 args = _get_args(args)
8894 if len(args) == 0:
8895 return 0
8896 ctx = _ctx_from_ast_arg_list(args)
8897 if ctx is None:
8898 return _reduce(lambda a, b: a + b, args, 0)
8899 args = _coerce_expr_list(args, ctx)
8900 if is_bv(args[0]):
8901 return _reduce(lambda a, b: a + b, args, 0)
8902 else:
8903 _args, sz = _to_ast_array(args)
8904 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8905
8906
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 8460 of file z3py.py.

8460def tactic_description(name, ctx=None):
8461 """Return a short description for the tactic named `name`.
8462
8463 >>> d = tactic_description('simplify')
8464 """
8465 ctx = _get_ctx(ctx)
8466 return Z3_tactic_get_descr(ctx.ref(), name)
8467
8468
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 8449 of file z3py.py.

8449def tactics(ctx=None):
8450 """Return a list of all available tactics in Z3.
8451
8452 >>> l = tactics()
8453 >>> l.count('simplify') == 1
8454 True
8455 """
8456 ctx = _get_ctx(ctx)
8457 return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8458
8459
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 8317 of file z3py.py.

8317def Then(*ts, **ks):
8318 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8319
8320 >>> x, y = Ints('x y')
8321 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8322 >>> t(And(x == 0, y > x + 1))
8323 [[Not(y <= 1)]]
8324 >>> t(And(x == 0, y > x + 1)).as_expr()
8325 Not(y <= 1)
8326 """
8327 return AndThen(*ts, **ks)
8328
8329

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

11329def to_Ast(ptr,):
11330 ast = Ast(ptr)
11331 super(ctypes.c_void_p, ast).__init__(ptr)
11332 return ast
11333

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

11339def to_AstVectorObj(ptr,):
11340 v = AstVectorObj(ptr)
11341 super(ctypes.c_void_p, v).__init__(ptr)
11342 return v
11343
11344# NB. my-hacky-class only works for a single instance of OnClause
11345# it should be replaced with a proper correlation between OnClause
11346# and object references that can be passed over the FFI.
11347# for UserPropagator we use a global dictionary, which isn't great code.
11348

Referenced by on_clause_eh().

◆ to_ContextObj()

def to_ContextObj (   ptr)

Definition at line 11334 of file z3py.py.

11334def to_ContextObj(ptr,):
11335 ctx = ContextObj(ptr)
11336 super(ctypes.c_void_p, ctx).__init__(ptr)
11337 return ctx
11338

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

3376def ToInt(a):
3377 """ Return the Z3 expression ToInt(a).
3378
3379 >>> x = Real('x')
3380 >>> x.sort()
3381 Real
3382 >>> n = ToInt(x)
3383 >>> n
3384 ToInt(x)
3385 >>> n.sort()
3386 Int
3387 """
3388 if z3_debug():
3389 _z3_assert(a.is_real(), "Z3 real expression expected.")
3390 ctx = a.ctx
3391 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3392
3393
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 3358 of file z3py.py.

3358def ToReal(a):
3359 """ Return the Z3 expression ToReal(a).
3360
3361 >>> x = Int('x')
3362 >>> x.sort()
3363 Int
3364 >>> n = ToReal(x)
3365 >>> n
3366 ToReal(x)
3367 >>> n.sort()
3368 Real
3369 """
3370 if z3_debug():
3371 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3372 ctx = a.ctx
3373 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3374
3375
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 11322 of file z3py.py.

11322def TransitiveClosure(f):
11323 """Given a binary relation R, such that the two arguments have the same sort
11324 create the transitive closure relation R+.
11325 The transitive closure R+ is a new relation.
11326 """
11327 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11328
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 11314 of file z3py.py.

11314def TreeOrder(a, index):
11315 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11316
11317
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 8440 of file z3py.py.

8440def TryFor(t, ms, ctx=None):
8441 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8442
8443 If `t` does not terminate in `ms` milliseconds, then it fails.
8444 """
8445 t = _to_tactic(t, ctx)
8446 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8447
8448
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 5363 of file z3py.py.

5363def TupleSort(name, sorts, ctx=None):
5364 """Create a named tuple sort base on a set of underlying sorts
5365 Example:
5366 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5367 """
5368 tuple = Datatype(name, ctx)
5369 projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5370 tuple.declare(name, *projects)
5371 tuple = tuple.create()
5372 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5373
5374

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

4236def UDiv(a, b):
4237 """Create the Z3 expression (unsigned) division `self / other`.
4238
4239 Use the operator / for signed division.
4240
4241 >>> x = BitVec('x', 32)
4242 >>> y = BitVec('y', 32)
4243 >>> UDiv(x, y)
4244 UDiv(x, y)
4245 >>> UDiv(x, y).sort()
4246 BitVec(32)
4247 >>> (x / y).sexpr()
4248 '(bvsdiv x y)'
4249 >>> UDiv(x, y).sexpr()
4250 '(bvudiv x y)'
4251 """
4252 _check_bv_args(a, b)
4253 a, b = _coerce_exprs(a, b)
4254 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4255
4256
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 4200 of file z3py.py.

4200def UGE(a, b):
4201 """Create the Z3 expression (unsigned) `other >= self`.
4202
4203 Use the operator >= for signed greater than or equal to.
4204
4205 >>> x, y = BitVecs('x y', 32)
4206 >>> UGE(x, y)
4207 UGE(x, y)
4208 >>> (x >= y).sexpr()
4209 '(bvsge x y)'
4210 >>> UGE(x, y).sexpr()
4211 '(bvuge x y)'
4212 """
4213 _check_bv_args(a, b)
4214 a, b = _coerce_exprs(a, b)
4215 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4216
4217
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 4218 of file z3py.py.

4218def UGT(a, b):
4219 """Create the Z3 expression (unsigned) `other > self`.
4220
4221 Use the operator > for signed greater than.
4222
4223 >>> x, y = BitVecs('x y', 32)
4224 >>> UGT(x, y)
4225 UGT(x, y)
4226 >>> (x > y).sexpr()
4227 '(bvsgt x y)'
4228 >>> UGT(x, y).sexpr()
4229 '(bvugt x y)'
4230 """
4231 _check_bv_args(a, b)
4232 a, b = _coerce_exprs(a, b)
4233 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4234
4235
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 4164 of file z3py.py.

4164def ULE(a, b):
4165 """Create the Z3 expression (unsigned) `other <= self`.
4166
4167 Use the operator <= for signed less than or equal to.
4168
4169 >>> x, y = BitVecs('x y', 32)
4170 >>> ULE(x, y)
4171 ULE(x, y)
4172 >>> (x <= y).sexpr()
4173 '(bvsle x y)'
4174 >>> ULE(x, y).sexpr()
4175 '(bvule x y)'
4176 """
4177 _check_bv_args(a, b)
4178 a, b = _coerce_exprs(a, b)
4179 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4180
4181
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 4182 of file z3py.py.

4182def ULT(a, b):
4183 """Create the Z3 expression (unsigned) `other < self`.
4184
4185 Use the operator < for signed less than.
4186
4187 >>> x, y = BitVecs('x y', 32)
4188 >>> ULT(x, y)
4189 ULT(x, y)
4190 >>> (x < y).sexpr()
4191 '(bvslt x y)'
4192 >>> ULT(x, y).sexpr()
4193 '(bvult x y)'
4194 """
4195 _check_bv_args(a, b)
4196 a, b = _coerce_exprs(a, b)
4197 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4198
4199
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 11186 of file z3py.py.

11186def Union(*args):
11187 """Create union of regular expressions.
11188 >>> re = Union(Re("a"), Re("b"), Re("c"))
11189 >>> print (simplify(InRe("d", re)))
11190 False
11191 """
11192 args = _get_args(args)
11193 sz = len(args)
11194 if z3_debug():
11195 _z3_assert(sz > 0, "At least one argument expected.")
11196 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11197 if sz == 1:
11198 return args[0]
11199 ctx = args[0].ctx
11200 v = (Ast * sz)()
11201 for i in range(sz):
11202 v[i] = args[i].as_ast()
11203 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11204
11205
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 10990 of file z3py.py.

10990def Unit(a):
10991 """Create a singleton sequence"""
10992 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10993
10994
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 4747 of file z3py.py.

4747def Update(a, *args):
4748 """Return a Z3 store array expression.
4749
4750 >>> a = Array('a', IntSort(), IntSort())
4751 >>> i, v = Ints('i v')
4752 >>> s = Update(a, i, v)
4753 >>> s.sort()
4754 Array(Int, Int)
4755 >>> prove(s[i] == v)
4756 proved
4757 >>> j = Int('j')
4758 >>> prove(Implies(i != j, s[j] == a[j]))
4759 proved
4760 """
4761 if z3_debug():
4762 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4763 args = _get_args(args)
4764 ctx = a.ctx
4765 if len(args) <= 1:
4766 raise Z3Exception("array update requires index and value arguments")
4767 if len(args) == 2:
4768 i = args[0]
4769 v = args[1]
4770 i = a.sort().domain().cast(i)
4771 v = a.sort().range().cast(v)
4772 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4773 v = a.sort().range().cast(args[-1])
4774 idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4775 _args, sz = _to_ast_array(idxs)
4776 return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4777
4778
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 4257 of file z3py.py.

4257def URem(a, b):
4258 """Create the Z3 expression (unsigned) remainder `self % other`.
4259
4260 Use the operator % for signed modulus, and SRem() for signed remainder.
4261
4262 >>> x = BitVec('x', 32)
4263 >>> y = BitVec('y', 32)
4264 >>> URem(x, y)
4265 URem(x, y)
4266 >>> URem(x, y).sort()
4267 BitVec(32)
4268 >>> (x % y).sexpr()
4269 '(bvsmod x y)'
4270 >>> URem(x, y).sexpr()
4271 '(bvurem x y)'
4272 """
4273 _check_bv_args(a, b)
4274 a, b = _coerce_exprs(a, b)
4275 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4276
4277
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 11448 of file z3py.py.

11448def user_prop_created(ctx, cb, id):
11449 prop = _prop_closures.get(ctx)
11450 prop.cb = cb
11451 id = _to_expr_ref(to_Ast(id), prop.ctx())
11452 prop.created(id)
11453 prop.cb = None
11454

◆ user_prop_decide()

def user_prop_decide (   ctx,
  cb,
  t_ref,
  idx_ref,
  phase_ref 
)

Definition at line 11479 of file z3py.py.

11479def user_prop_decide(ctx, cb, t_ref, idx_ref, phase_ref):
11480 prop = _prop_closures.get(ctx)
11481 prop.cb = cb
11482 t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11483 t, idx, phase = prop.decide(t, idx, phase)
11484 t_ref = t
11485 idx_ref = idx
11486 phase_ref = phase
11487 prop.cb = None
11488
11489

◆ user_prop_diseq()

def user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11469 of file z3py.py.

11469def user_prop_diseq(ctx, cb, x, y):
11470 prop = _prop_closures.get(ctx)
11471 prop.cb = cb
11472 x = _to_expr_ref(to_Ast(x), prop.ctx())
11473 y = _to_expr_ref(to_Ast(y), prop.ctx())
11474 prop.diseq(x, y)
11475 prop.cb = None
11476
11477# TODO The decision callback is not fully implemented.
11478# 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 11461 of file z3py.py.

11461def user_prop_eq(ctx, cb, x, y):
11462 prop = _prop_closures.get(ctx)
11463 prop.cb = cb
11464 x = _to_expr_ref(to_Ast(x), prop.ctx())
11465 y = _to_expr_ref(to_Ast(y), prop.ctx())
11466 prop.eq(x, y)
11467 prop.cb = None
11468

◆ user_prop_final()

def user_prop_final (   ctx,
  cb 
)

Definition at line 11455 of file z3py.py.

11455def user_prop_final(ctx, cb):
11456 prop = _prop_closures.get(ctx)
11457 prop.cb = cb
11458 prop.final()
11459 prop.cb = None
11460

◆ user_prop_fixed()

def user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 11440 of file z3py.py.

11440def user_prop_fixed(ctx, cb, id, value):
11441 prop = _prop_closures.get(ctx)
11442 prop.cb = cb
11443 id = _to_expr_ref(to_Ast(id), prop.ctx())
11444 value = _to_expr_ref(to_Ast(value), prop.ctx())
11445 prop.fixed(id, value)
11446 prop.cb = None
11447

◆ user_prop_fresh()

def user_prop_fresh (   ctx,
  _new_ctx 
)

Definition at line 11426 of file z3py.py.

11426def user_prop_fresh(ctx, _new_ctx):
11427 _prop_closures.set_threaded()
11428 prop = _prop_closures.get(ctx)
11429 nctx = Context()
11430 Z3_del_context(nctx.ctx)
11431 new_ctx = to_ContextObj(_new_ctx)
11432 nctx.ctx = new_ctx
11433 nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11434 nctx.owner = False
11435 new_prop = prop.fresh(nctx)
11436 _prop_closures.set(new_prop.id, new_prop)
11437 return new_prop.id
11438
11439
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 11420 of file z3py.py.

11420def user_prop_pop(ctx, cb, num_scopes):
11421 prop = _prop_closures.get(ctx)
11422 prop.cb = cb
11423 prop.pop(num_scopes)
11424
11425

◆ user_prop_push()

def user_prop_push (   ctx,
  cb 
)

Definition at line 11414 of file z3py.py.

11414def user_prop_push(ctx, cb):
11415 prop = _prop_closures.get(ctx)
11416 prop.cb = cb
11417 prop.push()
11418
11419

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

1470def Var(idx, s):
1471 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1472 A free variable with index n is bound when it occurs within the scope of n+1 quantified
1473 declarations.
1474
1475 >>> Var(0, IntSort())
1476 Var(0)
1477 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1478 False
1479 """
1480 if z3_debug():
1481 _z3_assert(is_sort(s), "Z3 sort expected")
1482 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1483
1484
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 8734 of file z3py.py.

8734def When(p, t, ctx=None):
8735 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8736 Otherwise, it returns the input goal unmodified.
8737
8738 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8739 >>> x, y = Ints('x y')
8740 >>> g = Goal()
8741 >>> g.add(x > 0)
8742 >>> g.add(y > 0)
8743 >>> t(g)
8744 [[x > 0, y > 0]]
8745 >>> g.add(x == y + 1)
8746 >>> t(g)
8747 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8748 """
8749 p = _to_probe(p, ctx)
8750 t = _to_tactic(t, ctx)
8751 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8752
8753
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 8391 of file z3py.py.

8391def With(t, *args, **keys):
8392 """Return a tactic that applies tactic `t` using the given configuration options.
8393
8394 >>> x, y = Ints('x y')
8395 >>> t = With(Tactic('simplify'), som=True)
8396 >>> t((x + 1)*(y + 2) == 0)
8397 [[2*x + y + x*y == -2]]
8398 """
8399 ctx = keys.pop("ctx", None)
8400 t = _to_tactic(t, ctx)
8401 p = args2params(args, keys, t.ctx)
8402 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8403
8404
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 8405 of file z3py.py.

8405def WithParams(t, p):
8406 """Return a tactic that applies tactic `t` using the given configuration options.
8407
8408 >>> x, y = Ints('x y')
8409 >>> p = ParamsRef()
8410 >>> p.set("som", True)
8411 >>> t = WithParams(Tactic('simplify'), p)
8412 >>> t((x + 1)*(y + 2) == 0)
8413 [[2*x + y + x*y == -2]]
8414 """
8415 t = _to_tactic(t, None)
8416 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8417
8418

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

1799def Xor(a, b, ctx=None):
1800 """Create a Z3 Xor expression.
1801
1802 >>> p, q = Bools('p q')
1803 >>> Xor(p, q)
1804 Xor(p, q)
1805 >>> simplify(Xor(p, q))
1806 Not(p == q)
1807 """
1808 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1809 s = BoolSort(ctx)
1810 a = s.cast(a)
1811 b = s.cast(b)
1812 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1813
1814
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 FuncDeclRef.__call__(), 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_int_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(), FuncDeclRef.domain(), 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 4393 of file z3py.py.

4393def ZeroExt(n, a):
4394 """Return a bit-vector expression with `n` extra zero-bits.
4395
4396 >>> x = BitVec('x', 16)
4397 >>> n = ZeroExt(8, x)
4398 >>> n.size()
4399 24
4400 >>> n
4401 ZeroExt(8, x)
4402 >>> n.sort()
4403 BitVec(24)
4404 >>> v0 = BitVecVal(2, 2)
4405 >>> v0
4406 2
4407 >>> v0.size()
4408 2
4409 >>> v = simplify(ZeroExt(6, v0))
4410 >>> v
4411 2
4412 >>> v.size()
4413 8
4414 """
4415 if z3_debug():
4416 _z3_assert(_is_int(n), "First argument must be an integer")
4417 _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4418 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4419
4420
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 9286 of file z3py.py.

◆ _dflt_fpsort_sbits

int _dflt_fpsort_sbits = 53
protected

Definition at line 9287 of file z3py.py.

◆ _dflt_rounding_mode

Floating-Point Arithmetic.

Definition at line 9285 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 11349 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 11356 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 7863 of file z3py.py.

◆ _on_models

dict _on_models = {}
protected

Definition at line 7855 of file z3py.py.

◆ _prop_closures

None _prop_closures = None
protected

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

◆ _user_prop_created

Z3_created_eh _user_prop_created = Z3_created_eh(user_prop_created)
protected

Definition at line 11494 of file z3py.py.

◆ _user_prop_decide

Z3_decide_eh _user_prop_decide = Z3_decide_eh(user_prop_decide)
protected

Definition at line 11498 of file z3py.py.

◆ _user_prop_diseq

Z3_eq_eh _user_prop_diseq = Z3_eq_eh(user_prop_diseq)
protected

Definition at line 11497 of file z3py.py.

◆ _user_prop_eq

Z3_eq_eh _user_prop_eq = Z3_eq_eh(user_prop_eq)
protected

Definition at line 11496 of file z3py.py.

◆ _user_prop_final

Z3_final_eh _user_prop_final = Z3_final_eh(user_prop_final)
protected

Definition at line 11495 of file z3py.py.

◆ _user_prop_fixed

Z3_fixed_eh _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
protected

Definition at line 11493 of file z3py.py.

◆ _user_prop_fresh

Z3_fresh_eh _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
protected

Definition at line 11492 of file z3py.py.

◆ _user_prop_pop

Z3_pop_eh _user_prop_pop = Z3_pop_eh(user_prop_pop)
protected

Definition at line 11491 of file z3py.py.

◆ _user_prop_push

Z3_push_eh _user_prop_push = Z3_push_eh(user_prop_push)
protected

Definition at line 11490 of file z3py.py.

◆ else

else :

Definition at line 70 of file z3py.py.

◆ sat

Definition at line 6892 of file z3py.py.

◆ unknown

Definition at line 6894 of file z3py.py.

◆ unsat

Definition at line 6893 of file z3py.py.

◆ Z3_DEBUG

__debug__ Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.