Z3
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  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
 FP Numerals. More...
 
class  FPRef
 FP Expressions. More...
 
class  FPRMRef
 
class  FPRMSortRef
 
class  FPSortRef
 FP Sorts. More...
 
class  FuncDeclRef
 Function Declarations. More...
 
class  FuncEntry
 
class  FuncInterp
 
class  Goal
 
class  IntNumRef
 
class  ModelRef
 
class  Optimize
 
class  OptimizeObjective
 Optimize. More...
 
class  ParamDescrsRef
 
class  ParamsRef
 Parameter Sets. More...
 
class  PatternRef
 Patterns. More...
 
class  Probe
 
class  QuantifierRef
 Quantifiers. More...
 
class  RatNumRef
 
class  ReRef
 
class  ReSortRef
 Regular expressions. More...
 
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  Z3PPObject
 ASTs base class. More...
 

Functions

def z3_debug ()
 
def enable_trace (msg)
 
def disable_trace (msg)
 
def get_version_string ()
 
def get_version ()
 
def get_full_version ()
 
def open_log (fname)
 
def append_log (s)
 
def to_symbol (s, ctx=None)
 
def z3_error_handler (c, e)
 
def main_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 is_sort (s)
 
def DeclareSort (name, ctx=None)
 
def is_func_decl (a)
 
def Function (name, *sig)
 
def RecFunction (name, *sig)
 
def RecAddDefinition (f, args, body)
 
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 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 And (*args)
 
def Or (*args)
 
def is_pattern (a)
 
def MultiPattern (*args)
 
def is_quantifier (a)
 
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_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 IntSort (ctx=None)
 
def RealSort (ctx=None)
 
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 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 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, dom, rng)
 
def Update (a, i, v)
 
def Default (a)
 
def Store (a, i, v)
 
def Select (a, i)
 
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. More...
 
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 CreateDatatypes (*ds)
 
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 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 probes (ctx=None)
 
def probe_description (name, ctx=None)
 
def describe_probes ()
 
def FailIf (p, ctx=None)
 
def When (p, t, ctx=None)
 
def Cond (p, t1, t2, ctx=None)
 
def simplify (a, *arguments, **keywords)
 Utils. More...
 
def help_simplify ()
 
def simplify_param_descrs ()
 
def substitute (t, *m)
 
def substitute_vars (t, *m)
 
def Sum (*args)
 
def Product (*args)
 
def AtMost (*args)
 
def AtLeast (*args)
 
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, **keywords)
 
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 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 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 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 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 SeqSort (s)
 
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)
 
def IndexOf (s, substr, offset)
 
def LastIndexOf (s, substr)
 
def Length (s)
 
def StrToInt (s)
 
def IntToStr (s)
 
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 PartialOrder (a, index)
 
def LinearOrder (a, index)
 
def TreeOrder (a, index)
 
def PiecewiseLinearOrder (a, index)
 
def TransitiveClosure (f)
 

Variables

 Z3_DEBUG = __debug__
 
 sat = CheckSatResult(Z3_L_TRUE)
 
 unsat = CheckSatResult(Z3_L_FALSE)
 
 unknown = CheckSatResult(Z3_L_UNDEF)
 

Function Documentation

◆ And()

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

1680def And(*args):
1681 """Create a Z3 and-expression or and-probe.
1682
1683 >>> p, q, r = Bools('p q r')
1684 >>> And(p, q, r)
1685 And(p, q, r)
1686 >>> P = BoolVector('p', 5)
1687 >>> And(P)
1688 And(p__0, p__1, p__2, p__3, p__4)
1689 """
1690 last_arg = None
1691 if len(args) > 0:
1692 last_arg = args[len(args)-1]
1693 if isinstance(last_arg, Context):
1694 ctx = args[len(args)-1]
1695 args = args[:len(args)-1]
1696 elif len(args) == 1 and isinstance(args[0], AstVector):
1697 ctx = args[0].ctx
1698 args = [a for a in args[0]]
1699 else:
1700 ctx = main_ctx()
1701 args = _get_args(args)
1702 ctx_args = _ctx_from_ast_arg_list(args, ctx)
1703 if z3_debug():
1704 _z3_assert(ctx_args is None or ctx_args == ctx, "context mismatch")
1705 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1706 if _has_probe(args):
1707 return _probe_and(args, ctx)
1708 else:
1709 args = _coerce_expr_list(args, ctx)
1710 _args, sz = _to_ast_array(args)
1711 return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1712
def z3_debug()
Definition: z3py.py:56
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1594
def Bools(names, ctx=None)
Definition: z3py.py:1579
def main_ctx()
Definition: z3py.py:211
def And(*args)
Definition: z3py.py:1680
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 z3py.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 7747 of file z3py.py.

7747def AndThen(*ts, **ks):
7748 """Return a tactic that applies the tactics in `*ts` in sequence.
7749
7750 >>> x, y = Ints('x y')
7751 >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7752 >>> t(And(x == 0, y > x + 1))
7753 [[Not(y <= 1)]]
7754 >>> t(And(x == 0, y > x + 1)).as_expr()
7755 Not(y <= 1)
7756 """
7757 if z3_debug():
7758 _z3_assert(len(ts) >= 2, "At least two arguments expected")
7759 ctx = ks.get('ctx', None)
7760 num = len(ts)
7761 r = ts[0]
7762 for i in range(num - 1):
7763 r = _and_then(r, ts[i+1], ctx)
7764 return r
7765
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3431
def Not(a, ctx=None)
Definition: z3py.py:1649
def AndThen(*ts, **ks)
Definition: z3py.py:7747
def Ints(names, ctx=None)
Definition: z3py.py:3022

Referenced by AndThen(), and Then().

◆ append_log()

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

Definition at line 105 of file z3py.py.

105def append_log(s):
106 """Append user-defined string to interaction log. """
108
def append_log(s)
Definition: z3py.py:105
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.

◆ args2params()

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

5070def args2params(arguments, keywords, ctx=None):
5071 """Convert python arguments into a Z3_params object.
5072 A ':' is added to the keywords, and '_' is replaced with '-'
5073
5074 >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5075 (params model true relevancy 2 elim_and true)
5076 """
5077 if z3_debug():
5078 _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5079 prev = None
5080 r = ParamsRef(ctx)
5081 for a in arguments:
5082 if prev is None:
5083 prev = a
5084 else:
5085 r.set(prev, a)
5086 prev = None
5087 for k in keywords:
5088 v = keywords[k]
5089 r.set(k, v)
5090 return r
5091
def args2params(arguments, keywords, ctx=None)
Definition: z3py.py:5070

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

◆ Array()

def z3py.Array (   name,
  dom,
  rng 
)
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 4403 of file z3py.py.

4403def Array(name, dom, rng):
4404 """Return an array constant named `name` with the given domain and range sorts.
4405
4406 >>> a = Array('a', IntSort(), IntSort())
4407 >>> a.sort()
4408 Array(Int, Int)
4409 >>> a[0]
4410 a[0]
4411 """
4412 s = ArraySort(dom, rng)
4413 ctx = s.ctx
4414 return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4415
def IntSort(ctx=None)
Definition: z3py.py:2907
def ArraySort(*sig)
Definition: z3py.py:4371
def to_symbol(s, ctx=None)
Definition: z3py.py:109
def Array(name, dom, rng)
Definition: z3py.py:4403
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 z3py.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 4371 of file z3py.py.

4371def ArraySort(*sig):
4372 """Return the Z3 array sort with the given domain and range sorts.
4373
4374 >>> A = ArraySort(IntSort(), BoolSort())
4375 >>> A
4376 Array(Int, Bool)
4377 >>> A.domain()
4378 Int
4379 >>> A.range()
4380 Bool
4381 >>> AA = ArraySort(IntSort(), A)
4382 >>> AA
4383 Array(Int, Array(Int, Bool))
4384 """
4385 sig = _get_args(sig)
4386 if z3_debug():
4387 _z3_assert(len(sig) > 1, "At least two arguments expected")
4388 arity = len(sig) - 1
4389 r = sig[arity]
4390 d = sig[0]
4391 if z3_debug():
4392 for s in sig:
4393 _z3_assert(is_sort(s), "Z3 sort expected")
4394 _z3_assert(s.ctx == r.ctx, "Context mismatch")
4395 ctx = d.ctx
4396 if len(sig) == 2:
4397 return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4398 dom = (Sort * arity)()
4399 for i in range(arity):
4400 dom[i] = sig[i].ast
4401 return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4402
def BoolSort(ctx=None)
Definition: z3py.py:1533
def is_sort(s)
Definition: z3py.py:596
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(), Context.mkArraySort(), SortRef.name(), ArraySortRef.range(), and SetSort().

◆ AtLeast()

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

8328def AtLeast(*args):
8329 """Create an at-most Pseudo-Boolean k constraint.
8330
8331 >>> a, b, c = Bools('a b c')
8332 >>> f = AtLeast(a, b, c, 2)
8333 """
8334 args = _get_args(args)
8335 if z3_debug():
8336 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8337 ctx = _ctx_from_ast_arg_list(args)
8338 if z3_debug():
8339 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8340 args1 = _coerce_expr_list(args[:-1], ctx)
8341 k = args[-1]
8342 _args, sz = _to_ast_array(args1)
8343 return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8344
def AtLeast(*args)
Definition: z3py.py:8328
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 z3py.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 8311 of file z3py.py.

8311def AtMost(*args):
8312 """Create an at-most Pseudo-Boolean k constraint.
8313
8314 >>> a, b, c = Bools('a b c')
8315 >>> f = AtMost(a, b, c, 2)
8316 """
8317 args = _get_args(args)
8318 if z3_debug():
8319 _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8320 ctx = _ctx_from_ast_arg_list(args)
8321 if z3_debug():
8322 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8323 args1 = _coerce_expr_list(args[:-1], ctx)
8324 k = args[-1]
8325 _args, sz = _to_ast_array(args1)
8326 return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8327
def AtMost(*args)
Definition: z3py.py:8311
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 z3py.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 3770 of file z3py.py.

3770def BitVec(name, bv, ctx=None):
3771 """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
3772 If `ctx=None`, then the global context is used.
3773
3774 >>> x = BitVec('x', 16)
3775 >>> is_bv(x)
3776 True
3777 >>> x.size()
3778 16
3779 >>> x.sort()
3780 BitVec(16)
3781 >>> word = BitVecSort(16)
3782 >>> x2 = BitVec('x', word)
3783 >>> eq(x, x2)
3784 True
3785 """
3786 if isinstance(bv, BitVecSortRef):
3787 ctx = bv.ctx
3788 else:
3789 ctx = _get_ctx(ctx)
3790 bv = BitVecSort(bv, ctx)
3791 return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
3792
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3770
def is_bv(a)
Definition: z3py.py:3683
def eq(a, b)
Definition: z3py.py:432
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3740

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

3793def BitVecs(names, bv, ctx=None):
3794 """Return a tuple of bit-vector constants of size bv.
3795
3796 >>> x, y, z = BitVecs('x y z', 16)
3797 >>> x.size()
3798 16
3799 >>> x.sort()
3800 BitVec(16)
3801 >>> Sum(x, y, z)
3802 0 + x + y + z
3803 >>> Product(x, y, z)
3804 1*x*y*z
3805 >>> simplify(Product(x, y, z))
3806 x*y*z
3807 """
3808 ctx = _get_ctx(ctx)
3809 if isinstance(names, str):
3810 names = names.split(" ")
3811 return [BitVec(name, bv, ctx) for name in names]
3812
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8182
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3793
def Product(*args)
Definition: z3py.py:8286
def Sum(*args)
Definition: z3py.py:8260

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

3740def BitVecSort(sz, ctx=None):
3741 """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3742
3743 >>> Byte = BitVecSort(8)
3744 >>> Word = BitVecSort(16)
3745 >>> Byte
3746 BitVec(8)
3747 >>> x = Const('x', Byte)
3748 >>> eq(x, BitVec('x', 8))
3749 True
3750 """
3751 ctx = _get_ctx(ctx)
3752 return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
3753
def Const(name, sort)
Definition: z3py.py:1301
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(), Context.mkBitVecSort(), BitVecSortRef.size(), and BitVecRef.sort().

◆ BitVecVal()

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

3754def BitVecVal(val, bv, ctx=None):
3755 """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
3756
3757 >>> v = BitVecVal(10, 32)
3758 >>> v
3759 10
3760 >>> print("0x%.8x" % v.as_long())
3761 0x0000000a
3762 """
3763 if is_bv_sort(bv):
3764 ctx = bv.ctx
3765 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
3766 else:
3767 ctx = _get_ctx(ctx)
3768 return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
3769
def is_bv_sort(s)
Definition: z3py.py:3222
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3754
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 z3py.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 1568 of file z3py.py.

1568def Bool(name, ctx=None):
1569 """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1570
1571 >>> p = Bool('p')
1572 >>> q = Bool('q')
1573 >>> And(p, q)
1574 And(p, q)
1575 """
1576 ctx = _get_ctx(ctx)
1577 return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1578
def Bool(name, ctx=None)
Definition: z3py.py:1568

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

1579def Bools(names, ctx=None):
1580 """Return a tuple of Boolean constants.
1581
1582 `names` is a single string containing all names separated by blank spaces.
1583 If `ctx=None`, then the global context is used.
1584
1585 >>> p, q, r = Bools('p q r')
1586 >>> And(p, Or(q, r))
1587 And(p, Or(q, r))
1588 """
1589 ctx = _get_ctx(ctx)
1590 if isinstance(names, str):
1591 names = names.split(" ")
1592 return [Bool(name, ctx) for name in names]
1593
def Or(*args)
Definition: z3py.py:1713

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

1533def BoolSort(ctx=None):
1534 """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1535
1536 >>> BoolSort()
1537 Bool
1538 >>> p = Const('p', BoolSort())
1539 >>> is_bool(p)
1540 True
1541 >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1542 >>> r(0, 1)
1543 r(0, 1)
1544 >>> is_bool(r(0, 1))
1545 True
1546 """
1547 ctx = _get_ctx(ctx)
1548 return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1549
def Function(name, *sig)
Definition: z3py.py:799
def is_bool(a)
Definition: z3py.py:1422
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(), ArraySortRef.domain(), ArrayRef.domain(), FuncDeclRef.domain(), FreshBool(), Context.getBoolSort(), If(), Implies(), IntSort(), is_arith_sort(), is_ast(), SortRef.kind(), Context.mkBoolSort(), SortRef.name(), Not(), FuncDeclRef.range(), ArraySortRef.range(), ArrayRef.range(), SetSort(), QuantifierRef.sort(), ArrayRef.sort(), Var(), and Xor().

◆ BoolVal()

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

1550def BoolVal(val, ctx=None):
1551 """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1552
1553 >>> BoolVal(True)
1554 True
1555 >>> is_true(BoolVal(True))
1556 True
1557 >>> is_true(True)
1558 False
1559 >>> is_false(BoolVal(False))
1560 True
1561 """
1562 ctx = _get_ctx(ctx)
1563 if val == False:
1564 return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1565 else:
1566 return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1567
def is_false(a)
Definition: z3py.py:1456
def is_true(a)
Definition: z3py.py:1439
def BoolVal(val, ctx=None)
Definition: z3py.py:1550
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 AlgebraicNumRef.as_decimal(), Goal.as_expr(), ApplyResult.as_expr(), BoolVal(), BoolSortRef.cast(), is_false(), is_quantifier(), Re(), and Solver.to_smt2().

◆ BoolVector()

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

1594def BoolVector(prefix, sz, ctx=None):
1595 """Return a list of Boolean constants of size `sz`.
1596
1597 The constants are named using the given prefix.
1598 If `ctx=None`, then the global context is used.
1599
1600 >>> P = BoolVector('p', 3)
1601 >>> P
1602 [p__0, p__1, p__2]
1603 >>> And(P)
1604 And(p__0, p__1, p__2)
1605 """
1606 return [ Bool('%s__%s' % (prefix, i)) for i in range(sz) ]
1607

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

◆ BV2Int()

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

3710def BV2Int(a, is_signed=False):
3711 """Return the Z3 expression BV2Int(a).
3712
3713 >>> b = BitVec('b', 3)
3714 >>> BV2Int(b).sort()
3715 Int
3716 >>> x = Int('x')
3717 >>> x > BV2Int(b)
3718 x > BV2Int(b)
3719 >>> x > BV2Int(b, is_signed=False)
3720 x > BV2Int(b)
3721 >>> x > BV2Int(b, is_signed=True)
3722 x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3723 >>> solve(x > BV2Int(b), b == 1, x < 3)
3724 [x = 2, b = 1]
3725 """
3726 if z3_debug():
3727 _z3_assert(is_bv(a), "Z3 bit-vector expression expected")
3728 ctx = a.ctx
3729
3730 return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3731
def If(a, b, c, ctx=None)
Definition: z3py.py:1248
def BV2Int(a, is_signed=False)
Definition: z3py.py:3710
def solve(*args, **keywords)
Definition: z3py.py:8401
def Int(name, ctx=None)
Definition: z3py.py:3010
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 z3py.BVAddNoOverflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector addition does not overflow

Definition at line 4165 of file z3py.py.

4165def BVAddNoOverflow(a, b, signed):
4166 """A predicate the determines that bit-vector addition does not overflow"""
4167 _check_bv_args(a, b)
4168 a, b = _coerce_exprs(a, b)
4169 return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4170
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4165
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 z3py.BVAddNoUnderflow (   a,
  b 
)
A predicate the determines that signed bit-vector addition does not underflow

Definition at line 4171 of file z3py.py.

4171def BVAddNoUnderflow(a, b):
4172 """A predicate the determines that signed bit-vector addition does not underflow"""
4173 _check_bv_args(a, b)
4174 a, b = _coerce_exprs(a, b)
4175 return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4176
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4171
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 z3py.BVMulNoOverflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector multiplication does not overflow

Definition at line 4202 of file z3py.py.

4202def BVMulNoOverflow(a, b, signed):
4203 """A predicate the determines that bit-vector multiplication does not overflow"""
4204 _check_bv_args(a, b)
4205 a, b = _coerce_exprs(a, b)
4206 return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4207
4208
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4202
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 z3py.BVMulNoUnderflow (   a,
  b 
)
A predicate the determines that bit-vector signed multiplication does not underflow

Definition at line 4209 of file z3py.py.

4209def BVMulNoUnderflow(a, b):
4210 """A predicate the determines that bit-vector signed multiplication does not underflow"""
4211 _check_bv_args(a, b)
4212 a, b = _coerce_exprs(a, b)
4213 return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4214
4215
4216
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4209
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 z3py.BVRedAnd (   a)
Return the reduction-and expression of `a`.

Definition at line 4153 of file z3py.py.

4153def BVRedAnd(a):
4154 """Return the reduction-and expression of `a`."""
4155 if z3_debug():
4156 _z3_assert(is_bv(a), "First argument must be a Z3 Bitvector expression")
4157 return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4158
def BVRedAnd(a)
Definition: z3py.py:4153
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 z3py.BVRedOr (   a)
Return the reduction-or expression of `a`.

Definition at line 4159 of file z3py.py.

4159def BVRedOr(a):
4160 """Return the reduction-or expression of `a`."""
4161 if z3_debug():
4162 _z3_assert(is_bv(a), "First argument must be a Z3 Bitvector expression")
4163 return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4164
def BVRedOr(a)
Definition: z3py.py:4159
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 z3py.BVSDivNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector signed division does not overflow

Definition at line 4190 of file z3py.py.

4190def BVSDivNoOverflow(a, b):
4191 """A predicate the determines that bit-vector signed division does not overflow"""
4192 _check_bv_args(a, b)
4193 a, b = _coerce_exprs(a, b)
4194 return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4195
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4190
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 z3py.BVSNegNoOverflow (   a)
A predicate the determines that bit-vector unary negation does not overflow

Definition at line 4196 of file z3py.py.

4196def BVSNegNoOverflow(a):
4197 """A predicate the determines that bit-vector unary negation does not overflow"""
4198 if z3_debug():
4199 _z3_assert(is_bv(a), "Argument should be a bit-vector")
4200 return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4201
def BVSNegNoOverflow(a)
Definition: z3py.py:4196
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 z3py.BVSubNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector subtraction does not overflow

Definition at line 4177 of file z3py.py.

4177def BVSubNoOverflow(a, b):
4178 """A predicate the determines that bit-vector subtraction does not overflow"""
4179 _check_bv_args(a, b)
4180 a, b = _coerce_exprs(a, b)
4181 return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4182
4183
def BVSubNoOverflow(a, b)
Definition: z3py.py:4177
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 z3py.BVSubNoUnderflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector subtraction does not underflow

Definition at line 4184 of file z3py.py.

4184def BVSubNoUnderflow(a, b, signed):
4185 """A predicate the determines that bit-vector subtraction does not underflow"""
4186 _check_bv_args(a, b)
4187 a, b = _coerce_exprs(a, b)
4188 return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4189
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4184
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 z3py.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 3172 of file z3py.py.

3172def Cbrt(a, ctx=None):
3173 """ Return a Z3 expression which represents the cubic root of a.
3174
3175 >>> x = Real('x')
3176 >>> Cbrt(x)
3177 x**(1/3)
3178 """
3179 if not is_expr(a):
3180 ctx = _get_ctx(ctx)
3181 a = RealVal(a, ctx)
3182 return a ** "1/3"
3183
def is_expr(a)
Definition: z3py.py:1115
def Cbrt(a, ctx=None)
Definition: z3py.py:3172
def RealVal(val, ctx=None)
Definition: z3py.py:2965
def Real(name, ctx=None)
Definition: z3py.py:3058

Referenced by Cbrt().

◆ Complement()

def z3py.Complement (   re)
Create the complement regular expression.

Definition at line 10386 of file z3py.py.

10386def Complement(re):
10387 """Create the complement regular expression."""
10388 return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10389
def Complement(re)
Definition: z3py.py:10386
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.

◆ Concat()

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

3813def Concat(*args):
3814 """Create a Z3 bit-vector concatenation expression.
3815
3816 >>> v = BitVecVal(1, 4)
3817 >>> Concat(v, v+1, v)
3818 Concat(Concat(1, 1 + 1), 1)
3819 >>> simplify(Concat(v, v+1, v))
3820 289
3821 >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
3822 121
3823 """
3824 args = _get_args(args)
3825 sz = len(args)
3826 if z3_debug():
3827 _z3_assert(sz >= 2, "At least two arguments expected.")
3828
3829 ctx = None
3830 for a in args:
3831 if is_expr(a):
3832 ctx = a.ctx
3833 break
3834 if is_seq(args[0]) or isinstance(args[0], str):
3835 args = [_coerce_seq(s, ctx) for s in args]
3836 if z3_debug():
3837 _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
3838 v = (Ast * sz)()
3839 for i in range(sz):
3840 v[i] = args[i].as_ast()
3841 return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
3842
3843 if is_re(args[0]):
3844 if z3_debug():
3845 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
3846 v = (Ast * sz)()
3847 for i in range(sz):
3848 v[i] = args[i].as_ast()
3849 return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
3850
3851 if z3_debug():
3852 _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
3853 r = args[0]
3854 for i in range(sz - 1):
3855 r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i+1].as_ast()), ctx)
3856 return r
3857
def Concat(*args)
Definition: z3py.py:3813
def is_seq(a)
Definition: z3py.py:10054
def is_re(s)
Definition: z3py.py:10309
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 z3py.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 8166 of file z3py.py.

8166def Cond(p, t1, t2, ctx=None):
8167 """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8168
8169 >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8170 """
8171 p = _to_probe(p, ctx)
8172 t1 = _to_tactic(t1, ctx)
8173 t2 = _to_tactic(t2, ctx)
8174 return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8175
def Cond(p, t1, t2, ctx=None)
Definition: z3py.py:8166
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 z3py.Const (   name,
  sort 
)
Create a constant of the given sort.

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

Definition at line 1301 of file z3py.py.

1301def Const(name, sort):
1302 """Create a constant of the given sort.
1303
1304 >>> Const('x', IntSort())
1305 x
1306 """
1307 if z3_debug():
1308 _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1309 ctx = sort.ctx
1310 return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1311

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

1312def Consts(names, sort):
1313 """Create several constants of the given sort.
1314
1315 `names` is a string containing the names of all constants to be created.
1316 Blank spaces separate the names of different constants.
1317
1318 >>> x, y, z = Consts('x y z', IntSort())
1319 >>> x + y + z
1320 x + y + z
1321 """
1322 if isinstance(names, str):
1323 names = names.split(" ")
1324 return [Const(name, sort) for name in names]
1325
def Consts(names, sort)
Definition: z3py.py:1312

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

◆ Contains()

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

10180def Contains(a, b):
10181 """Check if 'a' contains 'b'
10182 >>> s1 = Contains("abc", "ab")
10183 >>> simplify(s1)
10184 True
10185 >>> s2 = Contains("abc", "bc")
10186 >>> simplify(s2)
10187 True
10188 >>> x, y, z = Strings('x y z')
10189 >>> s3 = Contains(Concat(x,y,z), y)
10190 >>> simplify(s3)
10191 True
10192 """
10193 ctx = _get_ctx2(a, b)
10194 a = _coerce_seq(a, ctx)
10195 b = _coerce_seq(b, ctx)
10196 return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10197
10198
def Strings(names, ctx=None)
Definition: z3py.py:10093
def Contains(a, b)
Definition: z3py.py:10180
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 z3py.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 4782 of file z3py.py.

4782def CreateDatatypes(*ds):
4783 """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
4784
4785 In the following example we define a Tree-List using two mutually recursive datatypes.
4786
4787 >>> TreeList = Datatype('TreeList')
4788 >>> Tree = Datatype('Tree')
4789 >>> # Tree has two constructors: leaf and node
4790 >>> Tree.declare('leaf', ('val', IntSort()))
4791 >>> # a node contains a list of trees
4792 >>> Tree.declare('node', ('children', TreeList))
4793 >>> TreeList.declare('nil')
4794 >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
4795 >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
4796 >>> Tree.val(Tree.leaf(10))
4797 val(leaf(10))
4798 >>> simplify(Tree.val(Tree.leaf(10)))
4799 10
4800 >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
4801 >>> n1
4802 node(cons(leaf(10), cons(leaf(20), nil)))
4803 >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
4804 >>> simplify(n2 == n1)
4805 False
4806 >>> simplify(TreeList.car(Tree.children(n2)) == n1)
4807 True
4808 """
4809 ds = _get_args(ds)
4810 if z3_debug():
4811 _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
4812 _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
4813 _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
4814 _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
4815 ctx = ds[0].ctx
4816 num = len(ds)
4817 names = (Symbol * num)()
4818 out = (Sort * num)()
4819 clists = (ConstructorList * num)()
4820 to_delete = []
4821 for i in range(num):
4822 d = ds[i]
4823 names[i] = to_symbol(d.name, ctx)
4824 num_cs = len(d.constructors)
4825 cs = (Constructor * num_cs)()
4826 for j in range(num_cs):
4827 c = d.constructors[j]
4828 cname = to_symbol(c[0], ctx)
4829 rname = to_symbol(c[1], ctx)
4830 fs = c[2]
4831 num_fs = len(fs)
4832 fnames = (Symbol * num_fs)()
4833 sorts = (Sort * num_fs)()
4834 refs = (ctypes.c_uint * num_fs)()
4835 for k in range(num_fs):
4836 fname = fs[k][0]
4837 ftype = fs[k][1]
4838 fnames[k] = to_symbol(fname, ctx)
4839 if isinstance(ftype, Datatype):
4840 if z3_debug():
4841 _z3_assert(ds.count(ftype) == 1, "One and only one occurrence of each datatype is expected")
4842 sorts[k] = None
4843 refs[k] = ds.index(ftype)
4844 else:
4845 if z3_debug():
4846 _z3_assert(is_sort(ftype), "Z3 sort expected")
4847 sorts[k] = ftype.ast
4848 refs[k] = 0
4849 cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
4850 to_delete.append(ScopedConstructor(cs[j], ctx))
4851 clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
4852 to_delete.append(ScopedConstructorList(clists[i], ctx))
4853 Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
4854 result = []
4855
4856 for i in range(num):
4857 dref = DatatypeSortRef(out[i], ctx)
4858 num_cs = dref.num_constructors()
4859 for j in range(num_cs):
4860 cref = dref.constructor(j)
4861 cref_name = cref.name()
4862 cref_arity = cref.arity()
4863 if cref.arity() == 0:
4864 cref = cref()
4865 setattr(dref, cref_name, cref)
4866 rref = dref.recognizer(j)
4867 setattr(dref, "is_" + cref_name, rref)
4868 for k in range(cref_arity):
4869 aref = dref.accessor(j, k)
4870 setattr(dref, aref.name(), aref)
4871 result.append(dref)
4872 return tuple(result)
4873
def CreateDatatypes(*ds)
Definition: z3py.py:4782
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().

◆ DeclareSort()

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

637def DeclareSort(name, ctx=None):
638 """Create a new uninterpreted sort named `name`.
639
640 If `ctx=None`, then the new sort is declared in the global Z3Py context.
641
642 >>> A = DeclareSort('A')
643 >>> a = Const('a', A)
644 >>> b = Const('b', A)
645 >>> a.sort() == A
646 True
647 >>> b.sort() == A
648 True
649 >>> a == b
650 a == b
651 """
652 ctx = _get_ctx(ctx)
653 return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
654
def DeclareSort(name, ctx=None)
Definition: z3py.py:637
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 z3py.Default (   a)
 Return a default value for array expression.
>>> b = K(IntSort(), 1)
>>> prove(Default(b) == 1)
proved

Definition at line 4437 of file z3py.py.

4437def Default(a):
4438 """ Return a default value for array expression.
4439 >>> b = K(IntSort(), 1)
4440 >>> prove(Default(b) == 1)
4441 proved
4442 """
4443 if z3_debug():
4444 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4445 return a.default()
4446
4447
def is_array_sort(a)
Definition: z3py.py:4290
def K(dom, v)
Definition: z3py.py:4501
def Default(a)
Definition: z3py.py:4437
def prove(claim, **keywords)
Definition: z3py.py:8458

Referenced by Default(), and is_default().

◆ describe_probes()

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

Definition at line 8096 of file z3py.py.

8096def describe_probes():
8097 """Display a (tabular) description of all available probes in Z3."""
8098 if in_html_mode():
8099 even = True
8100 print('<table border="1" cellpadding="2" cellspacing="0">')
8101 for p in probes():
8102 if even:
8103 print('<tr style="background-color:#CFCFCF">')
8104 even = False
8105 else:
8106 print('<tr>')
8107 even = True
8108 print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8109 print('</table>')
8110 else:
8111 for p in probes():
8112 print('%s : %s' % (p, probe_description(p)))
8113
def probe_description(name, ctx=None)
Definition: z3py.py:8088
def describe_probes()
Definition: z3py.py:8096
def probes(ctx=None)
Definition: z3py.py:8078

◆ describe_tactics()

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

Definition at line 7905 of file z3py.py.

7905def describe_tactics():
7906 """Display a (tabular) description of all available tactics in Z3."""
7907 if in_html_mode():
7908 even = True
7909 print('<table border="1" cellpadding="2" cellspacing="0">')
7910 for t in tactics():
7911 if even:
7912 print('<tr style="background-color:#CFCFCF">')
7913 even = False
7914 else:
7915 print('<tr>')
7916 even = True
7917 print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7918 print('</table>')
7919 else:
7920 for t in tactics():
7921 print('%s : %s' % (t, tactic_description(t)))
7922
def tactics(ctx=None)
Definition: z3py.py:7887
def tactic_description(name, ctx=None)
Definition: z3py.py:7897
def describe_tactics()
Definition: z3py.py:7905

◆ disable_trace()

def z3py.disable_trace (   msg)

Definition at line 70 of file z3py.py.

70def disable_trace(msg):
72
def disable_trace(msg)
Definition: z3py.py:70
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 z3py.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 4982 of file z3py.py.

4982def DisjointSum(name, sorts, ctx=None):
4983 """Create a named tagged union sort base on a set of underlying sorts
4984 Example:
4985 >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
4986 """
4987 sum = Datatype(name, ctx)
4988 for i in range(len(sorts)):
4989 sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
4990 sum = sum.create()
4991 return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
4992
4993
def StringSort(ctx=None)
Definition: z3py.py:9970
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:4982

Referenced by DisjointSum().

◆ Distinct()

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

1270def Distinct(*args):
1271 """Create a Z3 distinct expression.
1272
1273 >>> x = Int('x')
1274 >>> y = Int('y')
1275 >>> Distinct(x, y)
1276 x != y
1277 >>> z = Int('z')
1278 >>> Distinct(x, y, z)
1279 Distinct(x, y, z)
1280 >>> simplify(Distinct(x, y, z))
1281 Distinct(x, y, z)
1282 >>> simplify(Distinct(x, y, z), blast_distinct=True)
1283 And(Not(x == y), Not(x == z), Not(y == z))
1284 """
1285 args = _get_args(args)
1286 ctx = _ctx_from_ast_arg_list(args)
1287 if z3_debug():
1288 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1289 args = _coerce_expr_list(args, ctx)
1290 _args, sz = _to_ast_array(args)
1291 return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1292
def Distinct(*args)
Definition: z3py.py:1270
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 z3py.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 10115 of file z3py.py.

10115def Empty(s):
10116 """Create the empty sequence of the given sort
10117 >>> e = Empty(StringSort())
10118 >>> e2 = StringVal("")
10119 >>> print(e.eq(e2))
10120 True
10121 >>> e3 = Empty(SeqSort(IntSort()))
10122 >>> print(e3)
10123 Empty(Seq(Int))
10124 >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10125 >>> print(e4)
10126 Empty(ReSort(Seq(Int)))
10127 """
10128 if isinstance(s, SeqSortRef):
10129 return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10130 if isinstance(s, ReSortRef):
10131 return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10132 raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10133
def Empty(s)
Definition: z3py.py:10115
def SeqSort(s)
Definition: z3py.py:9980
def ReSort(s)
Definition: z3py.py:10294
def StringVal(s, ctx=None)
Definition: z3py.py:10080
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 z3py.EmptySet (   s)
Create the empty set
>>> EmptySet(IntSort())
K(Int, False)

Definition at line 4572 of file z3py.py.

4572def EmptySet(s):
4573 """Create the empty set
4574 >>> EmptySet(IntSort())
4575 K(Int, False)
4576 """
4577 ctx = s.ctx
4578 return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4579
def EmptySet(s)
Definition: z3py.py:4572
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.

Referenced by EmptySet().

◆ enable_trace()

def z3py.enable_trace (   msg)

Definition at line 67 of file z3py.py.

67def enable_trace(msg):
69
def enable_trace(msg)
Definition: z3py.py:67
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.

◆ EnumSort()

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

4994def EnumSort(name, values, ctx=None):
4995 """Return a new enumeration sort named `name` containing the given values.
4996
4997 The result is a pair (sort, list of constants).
4998 Example:
4999 >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5000 """
5001 if z3_debug():
5002 _z3_assert(isinstance(name, str), "Name must be a string")
5003 _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5004 _z3_assert(len(values) > 0, "At least one value expected")
5005 ctx = _get_ctx(ctx)
5006 num = len(values)
5007 _val_names = (Symbol * num)()
5008 for i in range(num):
5009 _val_names[i] = to_symbol(values[i])
5010 _values = (FuncDecl * num)()
5011 _testers = (FuncDecl * num)()
5012 name = to_symbol(name)
5013 S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5014 V = []
5015 for i in range(num):
5016 V.append(FuncDeclRef(_values[i], ctx))
5017 V = [a() for a in V]
5018 return S, V
5019
def EnumSort(name, values, ctx=None)
Definition: z3py.py:4994
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(), and Context.mkEnumSort().

◆ eq()

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

432def eq(a, b):
433 """Return `True` if `a` and `b` are structurally identical AST nodes.
434
435 >>> x = Int('x')
436 >>> y = Int('y')
437 >>> eq(x, y)
438 False
439 >>> eq(x + 1, x + 1)
440 True
441 >>> eq(x + 1, 1 + x)
442 False
443 >>> eq(simplify(x + 1), simplify(1 + x))
444 True
445 """
446 if z3_debug():
447 _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
448 return a.eq(b)
449
def is_ast(a)
Definition: z3py.py:412

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

◆ Exists()

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

2061def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2062 """Create a Z3 exists formula.
2063
2064 The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2065
2066
2067 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2068 >>> x = Int('x')
2069 >>> y = Int('y')
2070 >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2071 >>> q
2072 Exists([x, y], f(x, y) >= x)
2073 >>> is_quantifier(q)
2074 True
2075 >>> r = Tactic('nnf')(q).as_expr()
2076 >>> is_quantifier(r)
2077 False
2078 """
2079 return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2080
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2061
def is_quantifier(a)
Definition: z3py.py:1997

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

◆ Ext()

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

4522def Ext(a, b):
4523 """Return extensionality index for one-dimensional arrays.
4524 >> a, b = Consts('a b', SetSort(IntSort()))
4525 >> Ext(a, b)
4526 Ext(a, b)
4527 """
4528 ctx = a.ctx
4529 if z3_debug():
4530 _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4531 return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4532
def is_array(a)
Definition: z3py.py:4294
def Ext(a, b)
Definition: z3py.py:4522
def SetSort(s)
Sets.
Definition: z3py.py:4568
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 z3py.Extract (   high,
  low,
  a 
)
Create a Z3 bit-vector extraction expression, or create a string extraction expression.

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

3858def Extract(high, low, a):
3859 """Create a Z3 bit-vector extraction expression, or create a string extraction expression.
3860
3861 >>> x = BitVec('x', 8)
3862 >>> Extract(6, 2, x)
3863 Extract(6, 2, x)
3864 >>> Extract(6, 2, x).sort()
3865 BitVec(5)
3866 >>> simplify(Extract(StringVal("abcd"),2,1))
3867 "c"
3868 """
3869 if isinstance(high, str):
3870 high = StringVal(high)
3871 if is_seq(high):
3872 s = high
3873 offset, length = _coerce_exprs(low, a, s.ctx)
3874 return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
3875 if z3_debug():
3876 _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
3877 _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0, "First and second arguments must be non negative integers")
3878 _z3_assert(is_bv(a), "Third argument must be a Z3 Bitvector expression")
3879 return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
3880
def Extract(high, low, a)
Definition: z3py.py:3858
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 z3py.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 8129 of file z3py.py.

8129def FailIf(p, ctx=None):
8130 """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8131
8132 In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8133
8134 >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8135 >>> x, y = Ints('x y')
8136 >>> g = Goal()
8137 >>> g.add(x > 0)
8138 >>> g.add(y > 0)
8139 >>> t(g)
8140 [[x > 0, y > 0]]
8141 >>> g.add(x == y + 1)
8142 >>> t(g)
8143 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8144 """
8145 p = _to_probe(p, ctx)
8146 return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8147
def OrElse(*ts, **ks)
Definition: z3py.py:7778
def FailIf(p, ctx=None)
Definition: z3py.py:8129
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 z3py.FiniteDomainSort (   name,
  sz,
  ctx = None 
)
Create a named finite domain sort of a given size sz

Definition at line 7221 of file z3py.py.

7221def FiniteDomainSort(name, sz, ctx=None):
7222 """Create a named finite domain sort of a given size sz"""
7223 if not isinstance(name, Symbol):
7224 name = to_symbol(name)
7225 ctx = _get_ctx(ctx)
7226 return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7227
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7221
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(), is_finite_domain_value(), and Context.mkFiniteDomainSort().

◆ FiniteDomainVal()

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

7289def FiniteDomainVal(val, sort, ctx=None):
7290 """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7291
7292 >>> s = FiniteDomainSort('S', 256)
7293 >>> FiniteDomainVal(255, s)
7294 255
7295 >>> FiniteDomainVal('100', s)
7296 100
7297 """
7298 if z3_debug():
7299 _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7300 ctx = sort.ctx
7301 return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7302
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7289
def is_finite_domain_sort(s)
Definition: z3py.py:7228

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

◆ Float128()

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

Definition at line 8759 of file z3py.py.

8759def Float128(ctx=None):
8760 """Floating-point 128-bit (quadruple) sort."""
8761 ctx = _get_ctx(ctx)
8762 return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8763
def Float128(ctx=None)
Definition: z3py.py:8759
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.

◆ Float16()

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

Definition at line 8729 of file z3py.py.

8729def Float16(ctx=None):
8730 """Floating-point 16-bit (half) sort."""
8731 ctx = _get_ctx(ctx)
8732 return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8733
def Float16(ctx=None)
Definition: z3py.py:8729
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ Float32()

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

Definition at line 8739 of file z3py.py.

8739def Float32(ctx=None):
8740 """Floating-point 32-bit (single) sort."""
8741 ctx = _get_ctx(ctx)
8742 return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8743
def Float32(ctx=None)
Definition: z3py.py:8739
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 z3py.Float64 (   ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 8749 of file z3py.py.

8749def Float64(ctx=None):
8750 """Floating-point 64-bit (double) sort."""
8751 ctx = _get_ctx(ctx)
8752 return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8753
def Float64(ctx=None)
Definition: z3py.py:8749
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 z3py.FloatDouble (   ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 8754 of file z3py.py.

8754def FloatDouble(ctx=None):
8755 """Floating-point 64-bit (double) sort."""
8756 ctx = _get_ctx(ctx)
8757 return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8758
def FloatDouble(ctx=None)
Definition: z3py.py:8754
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

◆ FloatHalf()

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

Definition at line 8734 of file z3py.py.

8734def FloatHalf(ctx=None):
8735 """Floating-point 16-bit (half) sort."""
8736 ctx = _get_ctx(ctx)
8737 return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8738
def FloatHalf(ctx=None)
Definition: z3py.py:8734
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.

◆ FloatQuadruple()

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

Definition at line 8764 of file z3py.py.

8764def FloatQuadruple(ctx=None):
8765 """Floating-point 128-bit (quadruple) sort."""
8766 ctx = _get_ctx(ctx)
8767 return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8768
def FloatQuadruple(ctx=None)
Definition: z3py.py:8764
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.

◆ FloatSingle()

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

Definition at line 8744 of file z3py.py.

8744def FloatSingle(ctx=None):
8745 """Floating-point 32-bit (single) sort."""
8746 ctx = _get_ctx(ctx)
8747 return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8748
def FloatSingle(ctx=None)
Definition: z3py.py:8744
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

◆ ForAll()

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

2044def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2045 """Create a Z3 forall formula.
2046
2047 The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2048
2049 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2050 >>> x = Int('x')
2051 >>> y = Int('y')
2052 >>> ForAll([x, y], f(x, y) >= x)
2053 ForAll([x, y], f(x, y) >= x)
2054 >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2055 ForAll([x, y], f(x, y) >= x)
2056 >>> ForAll([x, y], f(x, y) >= x, weight=10)
2057 ForAll([x, y], f(x, y) >= x)
2058 """
2059 return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2060
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2044

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

9344def FP(name, fpsort, ctx=None):
9345 """Return a floating-point constant named `name`.
9346 `fpsort` is the floating-point sort.
9347 If `ctx=None`, then the global context is used.
9348
9349 >>> x = FP('x', FPSort(8, 24))
9350 >>> is_fp(x)
9351 True
9352 >>> x.ebits()
9353 8
9354 >>> x.sort()
9355 FPSort(8, 24)
9356 >>> word = FPSort(8, 24)
9357 >>> x2 = FP('x', word)
9358 >>> eq(x, x2)
9359 True
9360 """
9361 if isinstance(fpsort, FPSortRef) and ctx is None:
9362 ctx = fpsort.ctx
9363 else:
9364 ctx = _get_ctx(ctx)
9365 return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9366
def is_fp(a)
Definition: z3py.py:9156
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9344
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9183

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

9385def fpAbs(a, ctx=None):
9386 """Create a Z3 floating-point absolute value expression.
9387
9388 >>> s = FPSort(8, 24)
9389 >>> rm = RNE()
9390 >>> x = FPVal(1.0, s)
9391 >>> fpAbs(x)
9392 fpAbs(1)
9393 >>> y = FPVal(-20.0, s)
9394 >>> y
9395 -1.25*(2**4)
9396 >>> fpAbs(y)
9397 fpAbs(-1.25*(2**4))
9398 >>> fpAbs(-1.25*(2**4))
9399 fpAbs(-1.25*(2**4))
9400 >>> fpAbs(x).sort()
9401 FPSort(8, 24)
9402 """
9403 ctx = _get_ctx(ctx)
9404 [a] = _coerce_fp_expr_list([a], ctx)
9405 return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
9406
def fpAbs(a, ctx=None)
Definition: z3py.py:9385
def RNE(ctx=None)
Definition: z3py.py:8984
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9300
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.

Referenced by fpAbs().

◆ fpAdd()

def z3py.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)
fpAdd(RNE(), x, y)
>>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
x + y
>>> fpAdd(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9467 of file z3py.py.

9467def fpAdd(rm, a, b, ctx=None):
9468 """Create a Z3 floating-point addition expression.
9469
9470 >>> s = FPSort(8, 24)
9471 >>> rm = RNE()
9472 >>> x = FP('x', s)
9473 >>> y = FP('y', s)
9474 >>> fpAdd(rm, x, y)
9475 fpAdd(RNE(), x, y)
9476 >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9477 x + y
9478 >>> fpAdd(rm, x, y).sort()
9479 FPSort(8, 24)
9480 """
9481 return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9482
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9467
def RTZ(ctx=None)
Definition: z3py.py:9016

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

◆ fpBVToFP()

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

9763def fpBVToFP(v, sort, ctx=None):
9764 """Create a Z3 floating-point conversion expression that represents the
9765 conversion from a bit-vector term to a floating-point term.
9766
9767 >>> x_bv = BitVecVal(0x3F800000, 32)
9768 >>> x_fp = fpBVToFP(x_bv, Float32())
9769 >>> x_fp
9770 fpToFP(1065353216)
9771 >>> simplify(x_fp)
9772 1
9773 """
9774 _z3_assert(is_bv(v), "First argument must be a Z3 floating-point rounding mode expression.")
9775 _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9776 ctx = _get_ctx(ctx)
9777 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9778
def fpToFP(a1, a2=None, a3=None, ctx=None)
Definition: z3py.py:9725
def is_fp_sort(s)
Definition: z3py.py:8773
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9763
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 z3py.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)
fpDiv(RNE(), x, y)
>>> fpDiv(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9511 of file z3py.py.

9511def fpDiv(rm, a, b, ctx=None):
9512 """Create a Z3 floating-point division expression.
9513
9514 >>> s = FPSort(8, 24)
9515 >>> rm = RNE()
9516 >>> x = FP('x', s)
9517 >>> y = FP('y', s)
9518 >>> fpDiv(rm, x, y)
9519 fpDiv(RNE(), x, y)
9520 >>> fpDiv(rm, x, y).sort()
9521 FPSort(8, 24)
9522 """
9523 return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9524
def fpDiv(rm, a, b, ctx=None)
Definition: z3py.py:9511

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

◆ fpEQ()

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

9675def fpEQ(a, b, ctx=None):
9676 """Create the Z3 floating-point expression `fpEQ(other, self)`.
9677
9678 >>> x, y = FPs('x y', FPSort(8, 24))
9679 >>> fpEQ(x, y)
9680 fpEQ(x, y)
9681 >>> fpEQ(x, y).sexpr()
9682 '(fp.eq x y)'
9683 """
9684 return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9685
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9675
def FPs(names, fpsort, ctx=None)
Definition: z3py.py:9367

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

◆ fpFMA()

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

Definition at line 9566 of file z3py.py.

9566def fpFMA(rm, a, b, c, ctx=None):
9567 """Create a Z3 floating-point fused multiply-add expression.
9568 """
9569 return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9570
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9566

◆ fpFP()

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

9697def fpFP(sgn, exp, sig, ctx=None):
9698 """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9699
9700 >>> s = FPSort(8, 24)
9701 >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9702 >>> print(x)
9703 fpFP(1, 127, 4194304)
9704 >>> xv = FPVal(-1.5, s)
9705 >>> print(xv)
9706 -1.5
9707 >>> slvr = Solver()
9708 >>> slvr.add(fpEQ(x, xv))
9709 >>> slvr.check()
9710 sat
9711 >>> xv = FPVal(+1.5, s)
9712 >>> print(xv)
9713 1.5
9714 >>> slvr = Solver()
9715 >>> slvr.add(fpEQ(x, xv))
9716 >>> slvr.check()
9717 unsat
9718 """
9719 _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9720 _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9721 ctx = _get_ctx(ctx)
9722 _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9723 return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9724
def fpFP(sgn, exp, sig, ctx=None)
Definition: z3py.py:9697
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 z3py.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 9779 of file z3py.py.

9779def fpFPToFP(rm, v, sort, ctx=None):
9780 """Create a Z3 floating-point conversion expression that represents the
9781 conversion from a floating-point term to a floating-point term of different precision.
9782
9783 >>> x_sgl = FPVal(1.0, Float32())
9784 >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9785 >>> x_dbl
9786 fpToFP(RNE(), 1)
9787 >>> simplify(x_dbl)
9788 1
9789 >>> x_dbl.sort()
9790 FPSort(11, 53)
9791 """
9792 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9793 _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9794 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9795 ctx = _get_ctx(ctx)
9796 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9797
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9779
def is_fprm(a)
Definition: z3py.py:9020
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 z3py.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 9664 of file z3py.py.

9664def fpGEQ(a, b, ctx=None):
9665 """Create the Z3 floating-point expression `other >= self`.
9666
9667 >>> x, y = FPs('x y', FPSort(8, 24))
9668 >>> fpGEQ(x, y)
9669 x >= y
9670 >>> (x >= y).sexpr()
9671 '(fp.geq x y)'
9672 """
9673 return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9674
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9664

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

◆ fpGT()

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

9653def fpGT(a, b, ctx=None):
9654 """Create the Z3 floating-point expression `other > self`.
9655
9656 >>> x, y = FPs('x y', FPSort(8, 24))
9657 >>> fpGT(x, y)
9658 x > y
9659 >>> (x > y).sexpr()
9660 '(fp.gt x y)'
9661 """
9662 return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9663
def fpGT(a, b, ctx=None)
Definition: z3py.py:9653

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

◆ fpInfinity()

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

Definition at line 9278 of file z3py.py.

9278def fpInfinity(s, negative):
9279 """Create a Z3 floating-point +oo or -oo term."""
9280 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9281 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9282 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9283
def fpInfinity(s, negative)
Definition: z3py.py:9278
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 z3py.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 9592 of file z3py.py.

9592def fpIsInf(a, ctx=None):
9593 """Create a Z3 floating-point isInfinite expression.
9594
9595 >>> s = FPSort(8, 24)
9596 >>> x = FP('x', s)
9597 >>> fpIsInf(x)
9598 fpIsInf(x)
9599 """
9600 return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9601
def fpIsInf(a, ctx=None)
Definition: z3py.py:9592

Referenced by fpIsInf().

◆ fpIsNaN()

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

9581def fpIsNaN(a, ctx=None):
9582 """Create a Z3 floating-point isNaN expression.
9583
9584 >>> s = FPSort(8, 24)
9585 >>> x = FP('x', s)
9586 >>> y = FP('y', s)
9587 >>> fpIsNaN(x)
9588 fpIsNaN(x)
9589 """
9590 return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9591
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9581

Referenced by fpIsNaN().

◆ fpIsNegative()

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

Definition at line 9617 of file z3py.py.

9617def fpIsNegative(a, ctx=None):
9618 """Create a Z3 floating-point isNegative expression.
9619 """
9620 return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9621
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9617

◆ fpIsNormal()

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

Definition at line 9607 of file z3py.py.

9607def fpIsNormal(a, ctx=None):
9608 """Create a Z3 floating-point isNormal expression.
9609 """
9610 return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9611
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9607

◆ fpIsPositive()

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

Definition at line 9622 of file z3py.py.

9622def fpIsPositive(a, ctx=None):
9623 """Create a Z3 floating-point isPositive expression.
9624 """
9625 return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9626
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9622

◆ fpIsSubnormal()

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

Definition at line 9612 of file z3py.py.

9612def fpIsSubnormal(a, ctx=None):
9613 """Create a Z3 floating-point isSubnormal expression.
9614 """
9615 return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9616
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9612

◆ fpIsZero()

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

Definition at line 9602 of file z3py.py.

9602def fpIsZero(a, ctx=None):
9603 """Create a Z3 floating-point isZero expression.
9604 """
9605 return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9606
def fpIsZero(a, ctx=None)
Definition: z3py.py:9602

◆ fpLEQ()

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

9642def fpLEQ(a, b, ctx=None):
9643 """Create the Z3 floating-point expression `other <= self`.
9644
9645 >>> x, y = FPs('x y', FPSort(8, 24))
9646 >>> fpLEQ(x, y)
9647 x <= y
9648 >>> (x <= y).sexpr()
9649 '(fp.leq x y)'
9650 """
9651 return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9652
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9642

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

◆ fpLT()

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

9631def fpLT(a, b, ctx=None):
9632 """Create the Z3 floating-point expression `other < self`.
9633
9634 >>> x, y = FPs('x y', FPSort(8, 24))
9635 >>> fpLT(x, y)
9636 x < y
9637 >>> (x < y).sexpr()
9638 '(fp.lt x y)'
9639 """
9640 return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9641
def fpLT(a, b, ctx=None)
Definition: z3py.py:9631

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

◆ fpMax()

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

9552def fpMax(a, b, ctx=None):
9553 """Create a Z3 floating-point maximum expression.
9554
9555 >>> s = FPSort(8, 24)
9556 >>> rm = RNE()
9557 >>> x = FP('x', s)
9558 >>> y = FP('y', s)
9559 >>> fpMax(x, y)
9560 fpMax(x, y)
9561 >>> fpMax(x, y).sort()
9562 FPSort(8, 24)
9563 """
9564 return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9565
def fpMax(a, b, ctx=None)
Definition: z3py.py:9552

Referenced by fpMax().

◆ fpMin()

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

9538def fpMin(a, b, ctx=None):
9539 """Create a Z3 floating-point minimum expression.
9540
9541 >>> s = FPSort(8, 24)
9542 >>> rm = RNE()
9543 >>> x = FP('x', s)
9544 >>> y = FP('y', s)
9545 >>> fpMin(x, y)
9546 fpMin(x, y)
9547 >>> fpMin(x, y).sort()
9548 FPSort(8, 24)
9549 """
9550 return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9551
def fpMin(a, b, ctx=None)
Definition: z3py.py:9538

Referenced by fpMin().

◆ fpMinusInfinity()

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

Definition at line 9273 of file z3py.py.

9273def fpMinusInfinity(s):
9274 """Create a Z3 floating-point -oo term."""
9275 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9276 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9277
def fpMinusInfinity(s)
Definition: z3py.py:9273

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 9289 of file z3py.py.

9289def fpMinusZero(s):
9290 """Create a Z3 floating-point -0.0 term."""
9291 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9292 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9293
def fpMinusZero(s)
Definition: z3py.py:9289
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 z3py.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)
fpMul(RNE(), x, y)
>>> fpMul(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9497 of file z3py.py.

9497def fpMul(rm, a, b, ctx=None):
9498 """Create a Z3 floating-point multiplication expression.
9499
9500 >>> s = FPSort(8, 24)
9501 >>> rm = RNE()
9502 >>> x = FP('x', s)
9503 >>> y = FP('y', s)
9504 >>> fpMul(rm, x, y)
9505 fpMul(RNE(), x, y)
9506 >>> fpMul(rm, x, y).sort()
9507 FPSort(8, 24)
9508 """
9509 return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
9510
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9497

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

◆ fpNaN()

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

9241def fpNaN(s):
9242 """Create a Z3 floating-point NaN term.
9243
9244 >>> s = FPSort(8, 24)
9245 >>> set_fpa_pretty(True)
9246 >>> fpNaN(s)
9247 NaN
9248 >>> pb = get_fpa_pretty()
9249 >>> set_fpa_pretty(False)
9250 >>> fpNaN(s)
9251 fpNaN(FPSort(8, 24))
9252 >>> set_fpa_pretty(pb)
9253 """
9254 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9255 return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9256
def fpNaN(s)
Definition: z3py.py:9241
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 z3py.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 9407 of file z3py.py.

9407def fpNeg(a, ctx=None):
9408 """Create a Z3 floating-point addition expression.
9409
9410 >>> s = FPSort(8, 24)
9411 >>> rm = RNE()
9412 >>> x = FP('x', s)
9413 >>> fpNeg(x)
9414 -x
9415 >>> fpNeg(x).sort()
9416 FPSort(8, 24)
9417 """
9418 ctx = _get_ctx(ctx)
9419 [a] = _coerce_fp_expr_list([a], ctx)
9420 return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9421
def fpNeg(a, ctx=None)
Definition: z3py.py:9407
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 z3py.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 9686 of file z3py.py.

9686def fpNEQ(a, b, ctx=None):
9687 """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9688
9689 >>> x, y = FPs('x y', FPSort(8, 24))
9690 >>> fpNEQ(x, y)
9691 Not(fpEQ(x, y))
9692 >>> (x != y).sexpr()
9693 '(distinct x y)'
9694 """
9695 return Not(fpEQ(a, b, ctx))
9696
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9686

Referenced by fpNEQ().

◆ fpPlusInfinity()

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

9257def fpPlusInfinity(s):
9258 """Create a Z3 floating-point +oo term.
9259
9260 >>> s = FPSort(8, 24)
9261 >>> pb = get_fpa_pretty()
9262 >>> set_fpa_pretty(True)
9263 >>> fpPlusInfinity(s)
9264 +oo
9265 >>> set_fpa_pretty(False)
9266 >>> fpPlusInfinity(s)
9267 fpPlusInfinity(FPSort(8, 24))
9268 >>> set_fpa_pretty(pb)
9269 """
9270 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9271 return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9272
def fpPlusInfinity(s)
Definition: z3py.py:9257

Referenced by fpPlusInfinity(), and FPVal().

◆ fpPlusZero()

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

Definition at line 9284 of file z3py.py.

9284def fpPlusZero(s):
9285 """Create a Z3 floating-point +0.0 term."""
9286 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9287 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9288
def fpPlusZero(s)
Definition: z3py.py:9284

Referenced by FPVal().

◆ fpRealToFP()

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

9798def fpRealToFP(rm, v, sort, ctx=None):
9799 """Create a Z3 floating-point conversion expression that represents the
9800 conversion from a real term to a floating-point term.
9801
9802 >>> x_r = RealVal(1.5)
9803 >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9804 >>> x_fp
9805 fpToFP(RNE(), 3/2)
9806 >>> simplify(x_fp)
9807 1.5
9808 """
9809 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9810 _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9811 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9812 ctx = _get_ctx(ctx)
9813 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9814
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9798
def is_real(a)
Definition: z3py.py:2515
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 z3py.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 9525 of file z3py.py.

9525def fpRem(a, b, ctx=None):
9526 """Create a Z3 floating-point remainder expression.
9527
9528 >>> s = FPSort(8, 24)
9529 >>> x = FP('x', s)
9530 >>> y = FP('y', s)
9531 >>> fpRem(x, y)
9532 fpRem(x, y)
9533 >>> fpRem(x, y).sort()
9534 FPSort(8, 24)
9535 """
9536 return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9537
def fpRem(a, b, ctx=None)
Definition: z3py.py:9525

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

◆ fpRoundToIntegral()

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

Definition at line 9576 of file z3py.py.

9576def fpRoundToIntegral(rm, a, ctx=None):
9577 """Create a Z3 floating-point roundToIntegral expression.
9578 """
9579 return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9580
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9576

◆ FPs()

def z3py.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)
fpMul(RNE(), fpAdd(RNE(), x, y), z)

Definition at line 9367 of file z3py.py.

9367def FPs(names, fpsort, ctx=None):
9368 """Return an array of floating-point constants.
9369
9370 >>> x, y, z = FPs('x y z', FPSort(8, 24))
9371 >>> x.sort()
9372 FPSort(8, 24)
9373 >>> x.sbits()
9374 24
9375 >>> x.ebits()
9376 8
9377 >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9378 fpMul(RNE(), fpAdd(RNE(), x, y), z)
9379 """
9380 ctx = _get_ctx(ctx)
9381 if isinstance(names, str):
9382 names = names.split(" ")
9383 return [FP(name, fpsort, ctx) for name in names]
9384

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

◆ fpSignedToFP()

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

9815def fpSignedToFP(rm, v, sort, ctx=None):
9816 """Create a Z3 floating-point conversion expression that represents the
9817 conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9818
9819 >>> x_signed = BitVecVal(-5, BitVecSort(32))
9820 >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9821 >>> x_fp
9822 fpToFP(RNE(), 4294967291)
9823 >>> simplify(x_fp)
9824 -1.25*(2**2)
9825 """
9826 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9827 _z3_assert(is_bv(v), "Second argument must be a Z3 expression or real sort.")
9828 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9829 ctx = _get_ctx(ctx)
9830 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9831
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9815
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 z3py.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 9183 of file z3py.py.

9183def FPSort(ebits, sbits, ctx=None):
9184 """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9185
9186 >>> Single = FPSort(8, 24)
9187 >>> Double = FPSort(11, 53)
9188 >>> Single
9189 FPSort(8, 24)
9190 >>> x = Const('x', Single)
9191 >>> eq(x, FP('x', FPSort(8, 24)))
9192 True
9193 """
9194 ctx = _get_ctx(ctx)
9195 return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9196
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(), Context.mkFPSort(), Context.mkFPSort128(), Context.mkFPSort16(), Context.mkFPSort32(), Context.mkFPSort64(), Context.mkFPSortDouble(), Context.mkFPSortHalf(), Context.mkFPSortQuadruple(), Context.mkFPSortSingle(), FPSortRef.sbits(), FPRef.sbits(), FPNumRef.sign_as_bv(), FPNumRef.significand(), FPNumRef.significand_as_bv(), and FPRef.sort().

◆ fpSqrt()

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

Definition at line 9571 of file z3py.py.

9571def fpSqrt(rm, a, ctx=None):
9572 """Create a Z3 floating-point square root expression.
9573 """
9574 return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9575
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9571

◆ fpSub()

def z3py.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)
fpSub(RNE(), x, y)
>>> fpSub(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9483 of file z3py.py.

9483def fpSub(rm, a, b, ctx=None):
9484 """Create a Z3 floating-point subtraction expression.
9485
9486 >>> s = FPSort(8, 24)
9487 >>> rm = RNE()
9488 >>> x = FP('x', s)
9489 >>> y = FP('y', s)
9490 >>> fpSub(rm, x, y)
9491 fpSub(RNE(), x, y)
9492 >>> fpSub(rm, x, y).sort()
9493 FPSort(8, 24)
9494 """
9495 return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
9496
def fpSub(rm, a, b, ctx=None)
Definition: z3py.py:9483

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

◆ fpToFP()

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

9725def fpToFP(a1, a2=None, a3=None, ctx=None):
9726 """Create a Z3 floating-point conversion expression from other term sorts
9727 to floating-point.
9728
9729 From a bit-vector term in IEEE 754-2008 format:
9730 >>> x = FPVal(1.0, Float32())
9731 >>> x_bv = fpToIEEEBV(x)
9732 >>> simplify(fpToFP(x_bv, Float32()))
9733 1
9734
9735 From a floating-point term with different precision:
9736 >>> x = FPVal(1.0, Float32())
9737 >>> x_db = fpToFP(RNE(), x, Float64())
9738 >>> x_db.sort()
9739 FPSort(11, 53)
9740
9741 From a real term:
9742 >>> x_r = RealVal(1.5)
9743 >>> simplify(fpToFP(RNE(), x_r, Float32()))
9744 1.5
9745
9746 From a signed bit-vector term:
9747 >>> x_signed = BitVecVal(-5, BitVecSort(32))
9748 >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9749 -1.25*(2**2)
9750 """
9751 ctx = _get_ctx(ctx)
9752 if is_bv(a1) and is_fp_sort(a2):
9753 return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9754 elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9755 return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9756 elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9757 return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9758 elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9759 return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9760 else:
9761 raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9762
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9919

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

◆ fpToFPUnsigned()

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

Definition at line 9849 of file z3py.py.

9849def fpToFPUnsigned(rm, x, s, ctx=None):
9850 """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9851 if z3_debug():
9852 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9853 _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9854 _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9855 ctx = _get_ctx(ctx)
9856 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9857
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9849
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 z3py.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 9919 of file z3py.py.

9919def fpToIEEEBV(x, ctx=None):
9920 """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9921
9922 The size of the resulting bit-vector is automatically determined.
9923
9924 Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9925 knows only one NaN and it will always produce the same bit-vector representation of
9926 that NaN.
9927
9928 >>> x = FP('x', FPSort(8, 24))
9929 >>> y = fpToIEEEBV(x)
9930 >>> print(is_fp(x))
9931 True
9932 >>> print(is_bv(y))
9933 True
9934 >>> print(is_fp(y))
9935 False
9936 >>> print(is_bv(x))
9937 False
9938 """
9939 if z3_debug():
9940 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9941 ctx = _get_ctx(ctx)
9942 return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
9943
9944
9945
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 z3py.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 9900 of file z3py.py.

9900def fpToReal(x, ctx=None):
9901 """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9902
9903 >>> x = FP('x', FPSort(8, 24))
9904 >>> y = fpToReal(x)
9905 >>> print(is_fp(x))
9906 True
9907 >>> print(is_real(y))
9908 True
9909 >>> print(is_fp(y))
9910 False
9911 >>> print(is_real(x))
9912 False
9913 """
9914 if z3_debug():
9915 _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9916 ctx = _get_ctx(ctx)
9917 return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9918
def fpToReal(x, ctx=None)
Definition: z3py.py:9900
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 z3py.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 9858 of file z3py.py.

9858def fpToSBV(rm, x, s, ctx=None):
9859 """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9860
9861 >>> x = FP('x', FPSort(8, 24))
9862 >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9863 >>> print(is_fp(x))
9864 True
9865 >>> print(is_bv(y))
9866 True
9867 >>> print(is_fp(y))
9868 False
9869 >>> print(is_bv(x))
9870 False
9871 """
9872 if z3_debug():
9873 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9874 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9875 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9876 ctx = _get_ctx(ctx)
9877 return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9878
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9858
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 z3py.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 9879 of file z3py.py.

9879def fpToUBV(rm, x, s, ctx=None):
9880 """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9881
9882 >>> x = FP('x', FPSort(8, 24))
9883 >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9884 >>> print(is_fp(x))
9885 True
9886 >>> print(is_bv(y))
9887 True
9888 >>> print(is_fp(y))
9889 False
9890 >>> print(is_bv(x))
9891 False
9892 """
9893 if z3_debug():
9894 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9895 _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9896 _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9897 ctx = _get_ctx(ctx)
9898 return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9899
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9879
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 z3py.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 9832 of file z3py.py.

9832def fpUnsignedToFP(rm, v, sort, ctx=None):
9833 """Create a Z3 floating-point conversion expression that represents the
9834 conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9835
9836 >>> x_signed = BitVecVal(-5, BitVecSort(32))
9837 >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9838 >>> x_fp
9839 fpToFPUnsigned(RNE(), 4294967291)
9840 >>> simplify(x_fp)
9841 1*(2**32)
9842 """
9843 _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9844 _z3_assert(is_bv(v), "Second argument must be a Z3 expression or real sort.")
9845 _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9846 ctx = _get_ctx(ctx)
9847 return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9848
def fpUnsignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9832

Referenced by fpUnsignedToFP().

◆ FPVal()

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

9300def FPVal(sig, exp=None, fps=None, ctx=None):
9301 """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9302
9303 >>> v = FPVal(20.0, FPSort(8, 24))
9304 >>> v
9305 1.25*(2**4)
9306 >>> print("0x%.8x" % v.exponent_as_long(False))
9307 0x00000004
9308 >>> v = FPVal(2.25, FPSort(8, 24))
9309 >>> v
9310 1.125*(2**1)
9311 >>> v = FPVal(-2.25, FPSort(8, 24))
9312 >>> v
9313 -1.125*(2**1)
9314 >>> FPVal(-0.0, FPSort(8, 24))
9315 -0.0
9316 >>> FPVal(0.0, FPSort(8, 24))
9317 +0.0
9318 >>> FPVal(+0.0, FPSort(8, 24))
9319 +0.0
9320 """
9321 ctx = _get_ctx(ctx)
9322 if is_fp_sort(exp):
9323 fps = exp
9324 exp = None
9325 elif fps is None:
9326 fps = _dflt_fps(ctx)
9327 _z3_assert(is_fp_sort(fps), "sort mismatch")
9328 if exp is None:
9329 exp = 0
9330 val = _to_float_str(sig)
9331 if val == "NaN" or val == "nan":
9332 return fpNaN(fps)
9333 elif val == "-0.0":
9334 return fpMinusZero(fps)
9335 elif val == "0.0" or val == "+0.0":
9336 return fpPlusZero(fps)
9337 elif val == "+oo" or val == "+inf" or val == "+Inf":
9338 return fpPlusInfinity(fps)
9339 elif val == "-oo" or val == "-inf" or val == "-Inf":
9340 return fpMinusInfinity(fps)
9341 else:
9342 return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9343

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

◆ fpZero()

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

Definition at line 9294 of file z3py.py.

9294def fpZero(s, negative):
9295 """Create a Z3 floating-point +0.0 or -0.0 term."""
9296 _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9297 _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9298 return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9299
def fpZero(s, negative)
Definition: z3py.py:9294

◆ FreshBool()

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

1608def FreshBool(prefix='b', ctx=None):
1609 """Return a fresh Boolean constant in the given context using the given prefix.
1610
1611 If `ctx=None`, then the global context is used.
1612
1613 >>> b1 = FreshBool()
1614 >>> b2 = FreshBool()
1615 >>> eq(b1, b2)
1616 False
1617 """
1618 ctx = _get_ctx(ctx)
1619 return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1620
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1608
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 z3py.FreshConst (   sort,
  prefix = 'c' 
)
Create a fresh constant of a specified sort

Definition at line 1326 of file z3py.py.

1326def FreshConst(sort, prefix='c'):
1327 """Create a fresh constant of a specified sort"""
1328 ctx = _get_ctx(sort.ctx)
1329 return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1330
def FreshConst(sort, prefix='c')
Definition: z3py.py:1326

◆ FreshInt()

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

3045def FreshInt(prefix='x', ctx=None):
3046 """Return a fresh integer constant in the given context using the given prefix.
3047
3048 >>> x = FreshInt()
3049 >>> y = FreshInt()
3050 >>> eq(x, y)
3051 False
3052 >>> x.sort()
3053 Int
3054 """
3055 ctx = _get_ctx(ctx)
3056 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3057
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3045

Referenced by FreshInt().

◆ FreshReal()

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

3097def FreshReal(prefix='b', ctx=None):
3098 """Return a fresh real constant in the given context using the given prefix.
3099
3100 >>> x = FreshReal()
3101 >>> y = FreshReal()
3102 >>> eq(x, y)
3103 False
3104 >>> x.sort()
3105 Real
3106 """
3107 ctx = _get_ctx(ctx)
3108 return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3109
def RealSort(ctx=None)
Definition: z3py.py:2923
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3097

Referenced by FreshReal().

◆ Full()

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

10134def Full(s):
10135 """Create the regular expression that accepts the universal language
10136 >>> e = Full(ReSort(SeqSort(IntSort())))
10137 >>> print(e)
10138 Full(ReSort(Seq(Int)))
10139 >>> e1 = Full(ReSort(StringSort()))
10140 >>> print(e1)
10141 Full(ReSort(String))
10142 """
10143 if isinstance(s, ReSortRef):
10144 return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10145 raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10146
10147
def Full(s)
Definition: z3py.py:10134
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 z3py.FullSet (   s)
Create the full set
>>> FullSet(IntSort())
K(Int, True)

Definition at line 4580 of file z3py.py.

4580def FullSet(s):
4581 """Create the full set
4582 >>> FullSet(IntSort())
4583 K(Int, True)
4584 """
4585 ctx = s.ctx
4586 return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4587
def FullSet(s)
Definition: z3py.py:4580
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.

Referenced by FullSet().

◆ Function()

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

799def Function(name, *sig):
800 """Create a new Z3 uninterpreted function with the given sorts.
801
802 >>> f = Function('f', IntSort(), IntSort())
803 >>> f(f(0))
804 f(f(0))
805 """
806 sig = _get_args(sig)
807 if z3_debug():
808 _z3_assert(len(sig) > 0, "At least two arguments expected")
809 arity = len(sig) - 1
810 rng = sig[arity]
811 if z3_debug():
812 _z3_assert(is_sort(rng), "Z3 sort expected")
813 dom = (Sort * arity)()
814 for i in range(arity):
815 if z3_debug():
816 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
817 dom[i] = sig[i].ast
818 ctx = rng.ctx
819 return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
820
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 z3py.get_as_array_func (   n)
Return the function declaration f associated with a Z3 expression of the form (_ as-array f).

Definition at line 6244 of file z3py.py.

6244def get_as_array_func(n):
6245 """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6246 if z3_debug():
6247 _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6248 return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6249
def is_as_array(n)
Definition: z3py.py:6240
def get_as_array_func(n)
Definition: z3py.py:6244
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 z3py.get_ctx (   ctx)

Definition at line 237 of file z3py.py.

237def get_ctx(ctx):
238 return _get_ctx(ctx)
239
def get_ctx(ctx)
Definition: z3py.py:237

◆ get_default_fp_sort()

def z3py.get_default_fp_sort (   ctx = None)

Definition at line 8653 of file z3py.py.

8653def get_default_fp_sort(ctx=None):
8654 return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8655
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8653

Referenced by set_default_fp_sort().

◆ get_default_rounding_mode()

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

Definition at line 8626 of file z3py.py.

8626def get_default_rounding_mode(ctx=None):
8627 """Retrieves the global default rounding mode."""
8628 global _dflt_rounding_mode
8629 if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8630 return RTZ(ctx)
8631 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8632 return RTN(ctx)
8633 elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8634 return RTP(ctx)
8635 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8636 return RNE(ctx)
8637 elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8638 return RNA(ctx)
8639
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8626
def RTN(ctx=None)
Definition: z3py.py:9008
def RTP(ctx=None)
Definition: z3py.py:9000
def RNA(ctx=None)
Definition: z3py.py:8992

Referenced by set_default_fp_sort().

◆ get_full_version()

def z3py.get_full_version ( )

Definition at line 89 of file z3py.py.

90 return Z3_get_full_version()
91
92# We use _z3_assert instead of the assert command because we want to
93# produce nice error messages in Z3Py at rise4fun.com
def get_full_version()
Definition: z3py.py:89
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 z3py.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 4354 of file z3py.py.

4354def get_map_func(a):
4355 """Return the function declaration associated with a Z3 map array expression.
4356
4357 >>> f = Function('f', IntSort(), IntSort())
4358 >>> b = Array('b', IntSort(), IntSort())
4359 >>> a = Map(f, b)
4360 >>> eq(f, get_map_func(a))
4361 True
4362 >>> get_map_func(a)
4363 f
4364 >>> get_map_func(a)(0)
4365 f(0)
4366 """
4367 if z3_debug():
4368 _z3_assert(is_map(a), "Z3 array map expression expected.")
4369 return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4370
def is_map(a)
Definition: z3py.py:4331
def Map(f, *args)
Definition: z3py.py:4479
def get_map_func(a)
Definition: z3py.py:4354
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 z3py.get_param (   name)
Return the value of a Z3 global (or module) parameter

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

Definition at line 273 of file z3py.py.

273def get_param(name):
274 """Return the value of a Z3 global (or module) parameter
275
276 >>> get_param('nlsat.reorder')
277 'true'
278 """
279 ptr = (ctypes.c_char_p * 1)()
280 if Z3_global_param_get(str(name), ptr):
281 r = z3core._to_pystr(ptr[0])
282 return r
283 raise Z3Exception("failed to retrieve value for '%s'" % name)
284
def get_param(name)
Definition: z3py.py:273
Z3_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 z3py.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 1204 of file z3py.py.

1204def get_var_index(a):
1205 """Return the de-Bruijn index of the Z3 bounded variable `a`.
1206
1207 >>> x = Int('x')
1208 >>> y = Int('y')
1209 >>> is_var(x)
1210 False
1211 >>> is_const(x)
1212 True
1213 >>> f = Function('f', IntSort(), IntSort(), IntSort())
1214 >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1215 >>> q = ForAll([x, y], f(x, y) == x + y)
1216 >>> q.body()
1217 f(Var(1), Var(0)) == Var(1) + Var(0)
1218 >>> b = q.body()
1219 >>> b.arg(0)
1220 f(Var(1), Var(0))
1221 >>> v1 = b.arg(0).arg(0)
1222 >>> v2 = b.arg(0).arg(1)
1223 >>> v1
1224 Var(1)
1225 >>> v2
1226 Var(0)
1227 >>> get_var_index(v1)
1228 1
1229 >>> get_var_index(v2)
1230 0
1231 """
1232 if z3_debug():
1233 _z3_assert(is_var(a), "Z3 bound variable expected")
1234 return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1235
def is_var(a)
Definition: z3py.py:1180
def get_var_index(a)
Definition: z3py.py:1204
def Var(idx, s)
Definition: z3py.py:1331
def is_const(a)
Definition: z3py.py:1162
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 z3py.get_version ( )

Definition at line 81 of file z3py.py.

81def get_version():
82 major = ctypes.c_uint(0)
83 minor = ctypes.c_uint(0)
84 build = ctypes.c_uint(0)
85 rev = ctypes.c_uint(0)
86 Z3_get_version(major, minor, build, rev)
87 return (major.value, minor.value, build.value, rev.value)
88
def get_version()
Definition: z3py.py:81
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 z3py.get_version_string ( )

Definition at line 73 of file z3py.py.

74 major = ctypes.c_uint(0)
75 minor = ctypes.c_uint(0)
76 build = ctypes.c_uint(0)
77 rev = ctypes.c_uint(0)
78 Z3_get_version(major, minor, build, rev)
79 return "%s.%s.%s" % (major.value, minor.value, build.value)
80
def get_version_string()
Definition: z3py.py:73

◆ help_simplify()

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

Definition at line 8206 of file z3py.py.

8206def help_simplify():
8207 """Return a string describing all options available for Z3 `simplify` procedure."""
8208 print(Z3_simplify_get_help(main_ctx().ref()))
8209
def help_simplify()
Definition: z3py.py:8206
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.

◆ If()

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

1248def If(a, b, c, ctx=None):
1249 """Create a Z3 if-then-else expression.
1250
1251 >>> x = Int('x')
1252 >>> y = Int('y')
1253 >>> max = If(x > y, x, y)
1254 >>> max
1255 If(x > y, x, y)
1256 >>> simplify(max)
1257 If(x <= y, y, x)
1258 """
1259 if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1260 return Cond(a, b, c, ctx)
1261 else:
1262 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1263 s = BoolSort(ctx)
1264 a = s.cast(a)
1265 b, c = _coerce_exprs(b, c, ctx)
1266 if z3_debug():
1267 _z3_assert(a.ctx == b.ctx, "Context mismatch")
1268 return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1269
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__(), BV2Int(), If(), Lambda(), and RecAddDefinition().

◆ Implies()

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

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

Definition at line 1621 of file z3py.py.

1621def Implies(a, b, ctx=None):
1622 """Create a Z3 implies expression.
1623
1624 >>> p, q = Bools('p q')
1625 >>> Implies(p, q)
1626 Implies(p, q)
1627 """
1628 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1629 s = BoolSort(ctx)
1630 a = s.cast(a)
1631 b = s.cast(b)
1632 return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1633
def Implies(a, b, ctx=None)
Definition: z3py.py:1621
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() [1/2]

def z3py.IndexOf (   s,
  substr 
)

Definition at line 10213 of file z3py.py.

10213def IndexOf(s, substr):
10214 return IndexOf(s, substr, IntVal(0))
10215
def IndexOf(s, substr, offset)
Definition: z3py.py:10216
def IntVal(val, ctx=None)
Definition: z3py.py:2954

Referenced by IndexOf().

◆ IndexOf() [2/2]

def z3py.IndexOf (   s,
  substr,
  offset 
)
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 10216 of file z3py.py.

10216def IndexOf(s, substr, offset):
10217 """Retrieve the index of substring within a string starting at a specified offset.
10218 >>> simplify(IndexOf("abcabc", "bc", 0))
10219 1
10220 >>> simplify(IndexOf("abcabc", "bc", 2))
10221 4
10222 """
10223 ctx = None
10224 if is_expr(offset):
10225 ctx = offset.ctx
10226 ctx = _get_ctx2(s, substr, ctx)
10227 s = _coerce_seq(s, ctx)
10228 substr = _coerce_seq(substr, ctx)
10229 if _is_int(offset):
10230 offset = IntVal(offset, ctx)
10231 return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10232
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of first occurrence of substr in s starting from offset offset. If s does not contain su...

◆ InRe()

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

10313def InRe(s, re):
10314 """Create regular expression membership test
10315 >>> re = Union(Re("a"),Re("b"))
10316 >>> print (simplify(InRe("a", re)))
10317 True
10318 >>> print (simplify(InRe("b", re)))
10319 True
10320 >>> print (simplify(InRe("c", re)))
10321 False
10322 """
10323 s = _coerce_seq(s, re.ctx)
10324 return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10325
def Re(s, ctx=None)
Definition: z3py.py:10274
def Union(*args)
Definition: z3py.py:10326
def InRe(s, re)
Definition: z3py.py:10313
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 z3py.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 3010 of file z3py.py.

3010def Int(name, ctx=None):
3011 """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3012
3013 >>> x = Int('x')
3014 >>> is_int(x)
3015 True
3016 >>> is_int(x + 1)
3017 True
3018 """
3019 ctx = _get_ctx(ctx)
3020 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3021
def is_int(a)
Definition: z3py.py:2497

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

3732def Int2BV(a, num_bits):
3733 """Return the z3 expression Int2BV(a, num_bits).
3734 It is a bit-vector of width num_bits and represents the
3735 modulo of a by 2^num_bits
3736 """
3737 ctx = a.ctx
3738 return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3739
def Int2BV(a, num_bits)
Definition: z3py.py:3732
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 z3py.Intersect ( args)
Create intersection of regular expressions.
>>> re = Intersect(Re("a"), Re("b"), Re("c"))

Definition at line 10345 of file z3py.py.

10345def Intersect(*args):
10346 """Create intersection of regular expressions.
10347 >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10348 """
10349 args = _get_args(args)
10350 sz = len(args)
10351 if z3_debug():
10352 _z3_assert(sz > 0, "At least one argument expected.")
10353 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10354 if sz == 1:
10355 return args[0]
10356 ctx = args[0].ctx
10357 v = (Ast * sz)()
10358 for i in range(sz):
10359 v[i] = args[i].as_ast()
10360 return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10361
def Intersect(*args)
Definition: z3py.py:10345
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 z3py.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 3022 of file z3py.py.

3022def Ints(names, ctx=None):
3023 """Return a tuple of Integer constants.
3024
3025 >>> x, y, z = Ints('x y z')
3026 >>> Sum(x, y, z)
3027 x + y + z
3028 """
3029 ctx = _get_ctx(ctx)
3030 if isinstance(names, str):
3031 names = names.split(" ")
3032 return [Int(name, ctx) for name in names]
3033

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

2907def IntSort(ctx=None):
2908 """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2909
2910 >>> IntSort()
2911 Int
2912 >>> x = Const('x', IntSort())
2913 >>> is_int(x)
2914 True
2915 >>> x.sort() == IntSort()
2916 True
2917 >>> x.sort() == BoolSort()
2918 False
2919 """
2920 ctx = _get_ctx(ctx)
2921 return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2922
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(), Context.getIntSort(), 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(), Context.mkIntSort(), 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 z3py.IntToStr (   s)
Convert integer expression to string

Definition at line 10267 of file z3py.py.

10267def IntToStr(s):
10268 """Convert integer expression to string"""
10269 if not is_expr(s):
10270 s = _py2expr(s)
10271 return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10272
10273
def IntToStr(s)
Definition: z3py.py:10267
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.

Referenced by StrToInt().

◆ IntVal()

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

2954def IntVal(val, ctx=None):
2955 """Return a Z3 integer value. If `ctx=None`, then the global context is used.
2956
2957 >>> IntVal(1)
2958 1
2959 >>> IntVal("100")
2960 100
2961 """
2962 ctx = _get_ctx(ctx)
2963 return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
2964

Referenced by SeqRef.__getitem__(), AstMap.__len__(), ArithRef.__mod__(), ArithRef.__pow__(), ArithRef.__rpow__(), AstMap.__setitem__(), AlgebraicNumRef.as_decimal(), 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 z3py.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 3034 of file z3py.py.

3034def IntVector(prefix, sz, ctx=None):
3035 """Return a list of integer constants of size `sz`.
3036
3037 >>> X = IntVector('x', 3)
3038 >>> X
3039 [x__0, x__1, x__2]
3040 >>> Sum(X)
3041 x__0 + x__1 + x__2
3042 """
3043 return [ Int('%s__%s' % (prefix, i)) for i in range(sz) ]
3044
def IntVector(prefix, sz, ctx=None)
Definition: z3py.py:3034

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

◆ is_add()

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

2596def is_add(a):
2597 """Return `True` if `a` is an expression of the form b + c.
2598
2599 >>> x, y = Ints('x y')
2600 >>> is_add(x + y)
2601 True
2602 >>> is_add(x - y)
2603 False
2604 """
2605 return is_app_of(a, Z3_OP_ADD)
2606
def is_add(a)
Definition: z3py.py:2596
def is_app_of(a, k)
Definition: z3py.py:1236

Referenced by is_add().

◆ is_algebraic_value()

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

2583def is_algebraic_value(a):
2584 """Return `True` if `a` is an algebraic value of sort Real.
2585
2586 >>> is_algebraic_value(RealVal("3/5"))
2587 False
2588 >>> n = simplify(Sqrt(2))
2589 >>> n
2590 1.4142135623?
2591 >>> is_algebraic_value(n)
2592 True
2593 """
2594 return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2595
def Sqrt(a, ctx=None)
Definition: z3py.py:3160
def is_algebraic_value(a)
Definition: z3py.py:2583
def is_arith(a)
Definition: z3py.py:2477

Referenced by is_algebraic_value().

◆ is_and()

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

1469def is_and(a):
1470 """Return `True` if `a` is a Z3 and expression.
1471
1472 >>> p, q = Bools('p q')
1473 >>> is_and(And(p, q))
1474 True
1475 >>> is_and(Or(p, q))
1476 False
1477 """
1478 return is_app_of(a, Z3_OP_AND)
1479
def is_and(a)
Definition: z3py.py:1469

Referenced by is_and().

◆ is_app()

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

1137def is_app(a):
1138 """Return `True` if `a` is a Z3 function application.
1139
1140 Note that, constants are function applications with 0 arguments.
1141
1142 >>> a = Int('a')
1143 >>> is_app(a)
1144 True
1145 >>> is_app(a + 1)
1146 True
1147 >>> is_app(IntSort())
1148 False
1149 >>> is_app(1)
1150 False
1151 >>> is_app(IntVal(1))
1152 True
1153 >>> x = Int('x')
1154 >>> is_app(ForAll(x, x >= 0))
1155 False
1156 """
1157 if not isinstance(a, ExprRef):
1158 return False
1159 k = _ast_kind(a.ctx, a)
1160 return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1161
def is_app(a)
Definition: z3py.py:1137

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

◆ is_app_of()

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

1236def is_app_of(a, k):
1237 """Return `True` if `a` is an application of the given kind `k`.
1238
1239 >>> x = Int('x')
1240 >>> n = x + 1
1241 >>> is_app_of(n, Z3_OP_ADD)
1242 True
1243 >>> is_app_of(n, Z3_OP_MUL)
1244 False
1245 """
1246 return is_app(a) and a.decl().kind() == k
1247

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

2477def is_arith(a):
2478 """Return `True` if `a` is an arithmetical expression.
2479
2480 >>> x = Int('x')
2481 >>> is_arith(x)
2482 True
2483 >>> is_arith(x + 1)
2484 True
2485 >>> is_arith(1)
2486 False
2487 >>> is_arith(IntVal(1))
2488 True
2489 >>> y = Real('y')
2490 >>> is_arith(y)
2491 True
2492 >>> is_arith(y + 1)
2493 True
2494 """
2495 return isinstance(a, ArithRef)
2496

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

◆ is_arith_sort()

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

2178def is_arith_sort(s):
2179 """Return `True` if s is an arithmetical sort (type).
2180
2181 >>> is_arith_sort(IntSort())
2182 True
2183 >>> is_arith_sort(RealSort())
2184 True
2185 >>> is_arith_sort(BoolSort())
2186 False
2187 >>> n = Int('x') + 1
2188 >>> is_arith_sort(n.sort())
2189 True
2190 """
2191 return isinstance(s, ArithSortRef)
2192
def is_arith_sort(s)
Definition: z3py.py:2178

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

◆ is_array()

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

4294def is_array(a):
4295 """Return `True` if `a` is a Z3 array expression.
4296
4297 >>> a = Array('a', IntSort(), IntSort())
4298 >>> is_array(a)
4299 True
4300 >>> is_array(Store(a, 0, 1))
4301 True
4302 >>> is_array(a[0])
4303 False
4304 """
4305 return isinstance(a, ArrayRef)
4306
def Store(a, i, v)
Definition: z3py.py:4448

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

◆ is_array_sort()

def z3py.is_array_sort (   a)

Definition at line 4290 of file z3py.py.

4290def is_array_sort(a):
4291 return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4292
4293
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).
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.

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

◆ is_as_array()

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

Definition at line 6240 of file z3py.py.

6240def is_as_array(n):
6241 """Return true if n is a Z3 expression of the form (_ as-array f)."""
6242 return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6243
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 z3py.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 412 of file z3py.py.

412def is_ast(a):
413 """Return `True` if `a` is an AST node.
414
415 >>> is_ast(10)
416 False
417 >>> is_ast(IntVal(10))
418 True
419 >>> is_ast(Int('x'))
420 True
421 >>> is_ast(BoolSort())
422 True
423 >>> is_ast(Function('f', IntSort(), IntSort()))
424 True
425 >>> is_ast("x")
426 False
427 >>> is_ast(Solver())
428 False
429 """
430 return isinstance(a, AstRef)
431

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

◆ is_bool()

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

1422def is_bool(a):
1423 """Return `True` if `a` is a Z3 Boolean expression.
1424
1425 >>> p = Bool('p')
1426 >>> is_bool(p)
1427 True
1428 >>> q = Bool('q')
1429 >>> is_bool(And(p, q))
1430 True
1431 >>> x = Real('x')
1432 >>> is_bool(x)
1433 False
1434 >>> is_bool(x == 0)
1435 True
1436 """
1437 return isinstance(a, BoolRef)
1438

Referenced by BoolSort(), is_bool(), is_quantifier(), and prove().

◆ is_bv()

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

3683def is_bv(a):
3684 """Return `True` if `a` is a Z3 bit-vector expression.
3685
3686 >>> b = BitVec('b', 32)
3687 >>> is_bv(b)
3688 True
3689 >>> is_bv(b + 10)
3690 True
3691 >>> is_bv(Int('x'))
3692 False
3693 """
3694 return isinstance(a, BitVecRef)
3695

Referenced by 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 z3py.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 3222 of file z3py.py.

3222def is_bv_sort(s):
3223 """Return True if `s` is a Z3 bit-vector sort.
3224
3225 >>> is_bv_sort(BitVecSort(32))
3226 True
3227 >>> is_bv_sort(IntSort())
3228 False
3229 """
3230 return isinstance(s, BitVecSortRef)
3231

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

◆ is_bv_value()

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

3696def is_bv_value(a):
3697 """Return `True` if `a` is a Z3 bit-vector numeral value.
3698
3699 >>> b = BitVec('b', 32)
3700 >>> is_bv_value(b)
3701 False
3702 >>> b = BitVecVal(10, 32)
3703 >>> b
3704 10
3705 >>> is_bv_value(b)
3706 True
3707 """
3708 return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3709
def is_bv_value(a)
Definition: z3py.py:3696

Referenced by is_bv_value().

◆ is_const()

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

1162def is_const(a):
1163 """Return `True` if `a` is Z3 constant/variable expression.
1164
1165 >>> a = Int('a')
1166 >>> is_const(a)
1167 True
1168 >>> is_const(a + 1)
1169 False
1170 >>> is_const(1)
1171 False
1172 >>> is_const(IntVal(1))
1173 True
1174 >>> x = Int('x')
1175 >>> is_const(ForAll(x, x >= 0))
1176 False
1177 """
1178 return is_app(a) and a.num_args() == 0
1179

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

◆ is_const_array()

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

4307def is_const_array(a):
4308 """Return `True` if `a` is a Z3 constant array.
4309
4310 >>> a = K(IntSort(), 10)
4311 >>> is_const_array(a)
4312 True
4313 >>> a = Array('a', IntSort(), IntSort())
4314 >>> is_const_array(a)
4315 False
4316 """
4317 return is_app_of(a, Z3_OP_CONST_ARRAY)
4318
def is_const_array(a)
Definition: z3py.py:4307

Referenced by is_const_array().

◆ is_default()

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

4346def is_default(a):
4347 """Return `True` if `a` is a Z3 default array expression.
4348 >>> d = Default(K(IntSort(), 10))
4349 >>> is_default(d)
4350 True
4351 """
4352 return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4353
def is_default(a)
Definition: z3py.py:4346

Referenced by is_default().

◆ is_distinct()

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

1522def is_distinct(a):
1523 """Return `True` if `a` is a Z3 distinct expression.
1524
1525 >>> x, y, z = Ints('x y z')
1526 >>> is_distinct(x == y)
1527 False
1528 >>> is_distinct(Distinct(x, y, z))
1529 True
1530 """
1531 return is_app_of(a, Z3_OP_DISTINCT)
1532
def is_distinct(a)
Definition: z3py.py:1522

Referenced by is_distinct().

◆ is_div()

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

2629def is_div(a):
2630 """Return `True` if `a` is an expression of the form b / c.
2631
2632 >>> x, y = Reals('x y')
2633 >>> is_div(x / y)
2634 True
2635 >>> is_div(x + y)
2636 False
2637 >>> x, y = Ints('x y')
2638 >>> is_div(x / y)
2639 False
2640 >>> is_idiv(x / y)
2641 True
2642 """
2643 return is_app_of(a, Z3_OP_DIV)
2644
def Reals(names, ctx=None)
Definition: z3py.py:3070
def is_idiv(a)
Definition: z3py.py:2645
def is_div(a)
Definition: z3py.py:2629

Referenced by is_div().

◆ is_eq()

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

1513def is_eq(a):
1514 """Return `True` if `a` is a Z3 equality expression.
1515
1516 >>> x, y = Ints('x y')
1517 >>> is_eq(x == y)
1518 True
1519 """
1520 return is_app_of(a, Z3_OP_EQ)
1521
def is_eq(a)
Definition: z3py.py:1513

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

◆ is_expr()

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

1115def is_expr(a):
1116 """Return `True` if `a` is a Z3 expression.
1117
1118 >>> a = Int('a')
1119 >>> is_expr(a)
1120 True
1121 >>> is_expr(a + 1)
1122 True
1123 >>> is_expr(IntSort())
1124 False
1125 >>> is_expr(1)
1126 False
1127 >>> is_expr(IntVal(1))
1128 True
1129 >>> x = Int('x')
1130 >>> is_expr(ForAll(x, x >= 0))
1131 True
1132 >>> is_expr(FPVal(1.0))
1133 True
1134 """
1135 return isinstance(a, ExprRef)
1136

Referenced by SeqRef.__gt__(), AlgebraicNumRef.as_decimal(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), Cbrt(), ExprRef.children(), Concat(), IndexOf(), IntToStr(), is_expr(), is_quantifier(), is_sort(), is_var(), K(), MultiPattern(), Replace(), simplify(), Sqrt(), substitute(), and substitute_vars().

◆ is_false()

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

1456def is_false(a):
1457 """Return `True` if `a` is the Z3 false expression.
1458
1459 >>> p = Bool('p')
1460 >>> is_false(p)
1461 False
1462 >>> is_false(False)
1463 False
1464 >>> is_false(BoolVal(False))
1465 True
1466 """
1467 return is_app_of(a, Z3_OP_FALSE)
1468

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

◆ is_finite_domain()

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

7250def is_finite_domain(a):
7251 """Return `True` if `a` is a Z3 finite-domain expression.
7252
7253 >>> s = FiniteDomainSort('S', 100)
7254 >>> b = Const('b', s)
7255 >>> is_finite_domain(b)
7256 True
7257 >>> is_finite_domain(Int('x'))
7258 False
7259 """
7260 return isinstance(a, FiniteDomainRef)
7261
7262
def is_finite_domain(a)
Definition: z3py.py:7250

Referenced by is_finite_domain(), and is_finite_domain_value().

◆ is_finite_domain_sort()

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

7229 """Return True if `s` is a Z3 finite-domain sort.
7230
7232 True
7234 False
7235 """
7236 return isinstance(s, FiniteDomainSortRef)
7237
7238

Referenced by FiniteDomainVal(), and is_finite_domain_sort().

◆ is_finite_domain_value()

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

7304 """Return `True` if `a` is a Z3 finite-domain value.
7305
7306 >>> s = FiniteDomainSort('S', 100)
7307 >>> b = Const('b', s)
7309 False
7310 >>> b = FiniteDomainVal(10, s)
7311 >>> b
7312 10
7314 True
7315 """
7316 return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7317
7318
def is_finite_domain_value(a)
Definition: z3py.py:7303

Referenced by is_finite_domain_value().

◆ is_fp()

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

9156def is_fp(a):
9157 """Return `True` if `a` is a Z3 floating-point expression.
9158
9159 >>> b = FP('b', FPSort(8, 24))
9160 >>> is_fp(b)
9161 True
9162 >>> is_fp(b + 1.0)
9163 True
9164 >>> is_fp(Int('x'))
9165 False
9166 """
9167 return isinstance(a, FPRef)
9168

Referenced by FP(), fpFPToFP(), fpIsPositive(), fpNeg(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), is_fp(), is_fp_value(), and set_default_fp_sort().

◆ is_fp_sort()

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

8773def is_fp_sort(s):
8774 """Return True if `s` is a Z3 floating-point sort.
8775
8776 >>> is_fp_sort(FPSort(8, 24))
8777 True
8778 >>> is_fp_sort(IntSort())
8779 False
8780 """
8781 return isinstance(s, FPSortRef)
8782

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

◆ is_fp_value()

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

9169def is_fp_value(a):
9170 """Return `True` if `a` is a Z3 floating-point numeral value.
9171
9172 >>> b = FP('b', FPSort(8, 24))
9173 >>> is_fp_value(b)
9174 False
9175 >>> b = FPVal(1.0, FPSort(8, 24))
9176 >>> b
9177 1
9178 >>> is_fp_value(b)
9179 True
9180 """
9181 return is_fp(a) and _is_numeral(a.ctx, a.ast)
9182
def is_fp_value(a)
Definition: z3py.py:9169

Referenced by is_fp_value().

◆ is_fprm()

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

9020def is_fprm(a):
9021 """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9022
9023 >>> rm = RNE()
9024 >>> is_fprm(rm)
9025 True
9026 >>> rm = 1.0
9027 >>> is_fprm(rm)
9028 False
9029 """
9030 return isinstance(a, FPRMRef)
9031

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

◆ is_fprm_sort()

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

8783def is_fprm_sort(s):
8784 """Return True if `s` is a Z3 floating-point rounding mode sort.
8785
8786 >>> is_fprm_sort(FPSort(8, 24))
8787 False
8788 >>> is_fprm_sort(RNE().sort())
8789 True
8790 """
8791 return isinstance(s, FPRMSortRef)
8792
def is_fprm_sort(s)
Definition: z3py.py:8783

Referenced by is_fprm_sort().

◆ is_fprm_value()

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

Definition at line 9032 of file z3py.py.

9032def is_fprm_value(a):
9033 """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9034 return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9035
def is_fprm_value(a)
Definition: z3py.py:9032

Referenced by set_default_rounding_mode().

◆ is_func_decl()

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

787def is_func_decl(a):
788 """Return `True` if `a` is a Z3 function declaration.
789
790 >>> f = Function('f', IntSort(), IntSort())
791 >>> is_func_decl(f)
792 True
793 >>> x = Real('x')
794 >>> is_func_decl(x)
795 False
796 """
797 return isinstance(a, FuncDeclRef)
798
def is_func_decl(a)
Definition: z3py.py:787

Referenced by is_func_decl(), Map(), and prove().

◆ is_ge()

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

2689def is_ge(a):
2690 """Return `True` if `a` is an expression of the form b >= c.
2691
2692 >>> x, y = Ints('x y')
2693 >>> is_ge(x >= y)
2694 True
2695 >>> is_ge(x == y)
2696 False
2697 """
2698 return is_app_of(a, Z3_OP_GE)
2699
def is_ge(a)
Definition: z3py.py:2689

Referenced by is_ge().

◆ is_gt()

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

2700def is_gt(a):
2701 """Return `True` if `a` is an expression of the form b > c.
2702
2703 >>> x, y = Ints('x y')
2704 >>> is_gt(x > y)
2705 True
2706 >>> is_gt(x == y)
2707 False
2708 """
2709 return is_app_of(a, Z3_OP_GT)
2710
def is_gt(a)
Definition: z3py.py:2700

Referenced by is_gt().

◆ is_idiv()

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

2645def is_idiv(a):
2646 """Return `True` if `a` is an expression of the form b div c.
2647
2648 >>> x, y = Ints('x y')
2649 >>> is_idiv(x / y)
2650 True
2651 >>> is_idiv(x + y)
2652 False
2653 """
2654 return is_app_of(a, Z3_OP_IDIV)
2655

Referenced by is_div(), and is_idiv().

◆ is_implies()

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

1491def is_implies(a):
1492 """Return `True` if `a` is a Z3 implication expression.
1493
1494 >>> p, q = Bools('p q')
1495 >>> is_implies(Implies(p, q))
1496 True
1497 >>> is_implies(And(p, q))
1498 False
1499 """
1500 return is_app_of(a, Z3_OP_IMPLIES)
1501
def is_implies(a)
Definition: z3py.py:1491

Referenced by is_implies().

◆ is_int()

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

2497def is_int(a):
2498 """Return `True` if `a` is an integer expression.
2499
2500 >>> x = Int('x')
2501 >>> is_int(x + 1)
2502 True
2503 >>> is_int(1)
2504 False
2505 >>> is_int(IntVal(1))
2506 True
2507 >>> y = Real('y')
2508 >>> is_int(y)
2509 False
2510 >>> is_int(y + 1)
2511 False
2512 """
2513 return is_arith(a) and a.is_int()
2514

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

◆ is_int_value()

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

2539def is_int_value(a):
2540 """Return `True` if `a` is an integer value of sort Int.
2541
2542 >>> is_int_value(IntVal(1))
2543 True
2544 >>> is_int_value(1)
2545 False
2546 >>> is_int_value(Int('x'))
2547 False
2548 >>> n = Int('x') + 1
2549 >>> n
2550 x + 1
2551 >>> n.arg(1)
2552 1
2553 >>> is_int_value(n.arg(1))
2554 True
2555 >>> is_int_value(RealVal("1/3"))
2556 False
2557 >>> is_int_value(RealVal(1))
2558 False
2559 """
2560 return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2561
def is_int_value(a)
Definition: z3py.py:2539

Referenced by is_int_value().

◆ is_is_int()

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

2711def is_is_int(a):
2712 """Return `True` if `a` is an expression of the form IsInt(b).
2713
2714 >>> x = Real('x')
2715 >>> is_is_int(IsInt(x))
2716 True
2717 >>> is_is_int(x)
2718 False
2719 """
2720 return is_app_of(a, Z3_OP_IS_INT)
2721
def is_is_int(a)
Definition: z3py.py:2711
def IsInt(a)
Definition: z3py.py:3144

Referenced by is_is_int().

◆ is_K()

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

4319def is_K(a):
4320 """Return `True` if `a` is a Z3 constant array.
4321
4322 >>> a = K(IntSort(), 10)
4323 >>> is_K(a)
4324 True
4325 >>> a = Array('a', IntSort(), IntSort())
4326 >>> is_K(a)
4327 False
4328 """
4329 return is_app_of(a, Z3_OP_CONST_ARRAY)
4330
def is_K(a)
Definition: z3py.py:4319

Referenced by is_K().

◆ is_le()

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

2667def is_le(a):
2668 """Return `True` if `a` is an expression of the form b <= c.
2669
2670 >>> x, y = Ints('x y')
2671 >>> is_le(x <= y)
2672 True
2673 >>> is_le(x < y)
2674 False
2675 """
2676 return is_app_of(a, Z3_OP_LE)
2677
def is_le(a)
Definition: z3py.py:2667

Referenced by is_le().

◆ is_lt()

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

2678def is_lt(a):
2679 """Return `True` if `a` is an expression of the form b < c.
2680
2681 >>> x, y = Ints('x y')
2682 >>> is_lt(x < y)
2683 True
2684 >>> is_lt(x == y)
2685 False
2686 """
2687 return is_app_of(a, Z3_OP_LT)
2688
def is_lt(a)
Definition: z3py.py:2678

Referenced by is_lt().

◆ is_map()

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

4331def is_map(a):
4332 """Return `True` if `a` is a Z3 map array expression.
4333
4334 >>> f = Function('f', IntSort(), IntSort())
4335 >>> b = Array('b', IntSort(), IntSort())
4336 >>> a = Map(f, b)
4337 >>> a
4338 Map(f, b)
4339 >>> is_map(a)
4340 True
4341 >>> is_map(b)
4342 False
4343 """
4344 return is_app_of(a, Z3_OP_ARRAY_MAP)
4345

Referenced by get_map_func(), and is_map().

◆ is_mod()

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

2656def is_mod(a):
2657 """Return `True` if `a` is an expression of the form b % c.
2658
2659 >>> x, y = Ints('x y')
2660 >>> is_mod(x % y)
2661 True
2662 >>> is_mod(x + y)
2663 False
2664 """
2665 return is_app_of(a, Z3_OP_MOD)
2666
def is_mod(a)
Definition: z3py.py:2656

Referenced by is_mod().

◆ is_mul()

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

2607def is_mul(a):
2608 """Return `True` if `a` is an expression of the form b * c.
2609
2610 >>> x, y = Ints('x y')
2611 >>> is_mul(x * y)
2612 True
2613 >>> is_mul(x - y)
2614 False
2615 """
2616 return is_app_of(a, Z3_OP_MUL)
2617
def is_mul(a)
Definition: z3py.py:2607

Referenced by is_mul().

◆ is_not()

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

1502def is_not(a):
1503 """Return `True` if `a` is a Z3 not expression.
1504
1505 >>> p = Bool('p')
1506 >>> is_not(p)
1507 False
1508 >>> is_not(Not(p))
1509 True
1510 """
1511 return is_app_of(a, Z3_OP_NOT)
1512
def is_not(a)
Definition: z3py.py:1502

Referenced by is_not(), and mk_not().

◆ is_or()

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

1480def is_or(a):
1481 """Return `True` if `a` is a Z3 or expression.
1482
1483 >>> p, q = Bools('p q')
1484 >>> is_or(Or(p, q))
1485 True
1486 >>> is_or(And(p, q))
1487 False
1488 """
1489 return is_app_of(a, Z3_OP_OR)
1490
def is_or(a)
Definition: z3py.py:1480

Referenced by is_or().

◆ is_pattern()

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

1759def is_pattern(a):
1760 """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1761
1762 >>> f = Function('f', IntSort(), IntSort())
1763 >>> x = Int('x')
1764 >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1765 >>> q
1766 ForAll(x, f(x) == 0)
1767 >>> q.num_patterns()
1768 1
1769 >>> is_pattern(q.pattern(0))
1770 True
1771 >>> q.pattern(0)
1772 f(Var(0))
1773 """
1774 return isinstance(a, PatternRef)
1775
def is_pattern(a)
Definition: z3py.py:1759

Referenced by is_pattern(), is_quantifier(), and MultiPattern().

◆ is_probe()

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

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

Definition at line 8062 of file z3py.py.

8062def is_probe(p):
8063 """Return `True` if `p` is a Z3 probe.
8064
8065 >>> is_probe(Int('x'))
8066 False
8067 >>> is_probe(Probe('memory'))
8068 True
8069 """
8070 return isinstance(p, Probe)
8071
def is_probe(p)
Definition: z3py.py:8062

Referenced by eq(), is_probe(), mk_not(), and Not().

◆ is_quantifier()

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

1997def is_quantifier(a):
1998 """Return `True` if `a` is a Z3 quantifier.
1999
2000 >>> f = Function('f', IntSort(), IntSort())
2001 >>> x = Int('x')
2002 >>> q = ForAll(x, f(x) == 0)
2003 >>> is_quantifier(q)
2004 True
2005 >>> is_quantifier(f(x))
2006 False
2007 """
2008 return isinstance(a, QuantifierRef)
2009

Referenced by Exists(), and is_quantifier().

◆ is_rational_value()

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

2562def is_rational_value(a):
2563 """Return `True` if `a` is rational value of sort Real.
2564
2566 True
2567 >>> is_rational_value(RealVal("3/5"))
2568 True
2570 False
2571 >>> is_rational_value(1)
2572 False
2573 >>> n = Real('x') + 1
2574 >>> n.arg(1)
2575 1
2576 >>> is_rational_value(n.arg(1))
2577 True
2578 >>> is_rational_value(Real('x'))
2579 False
2580 """
2581 return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2582
def is_rational_value(a)
Definition: z3py.py:2562

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

◆ is_re()

def z3py.is_re (   s)

Definition at line 10309 of file z3py.py.

10309def is_re(s):
10310 return isinstance(s, ReRef)
10311
10312

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

◆ is_real()

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

2515def is_real(a):
2516 """Return `True` if `a` is a real expression.
2517
2518 >>> x = Int('x')
2519 >>> is_real(x + 1)
2520 False
2521 >>> y = Real('y')
2522 >>> is_real(y)
2523 True
2524 >>> is_real(y + 1)
2525 True
2526 >>> is_real(1)
2527 False
2528 >>> is_real(RealVal(1))
2529 True
2530 """
2531 return is_arith(a) and a.is_real()
2532

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

◆ is_select()

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

4538def is_select(a):
4539 """Return `True` if `a` is a Z3 array select application.
4540
4541 >>> a = Array('a', IntSort(), IntSort())
4542 >>> is_select(a)
4543 False
4544 >>> i = Int('i')
4545 >>> is_select(a[i])
4546 True
4547 """
4548 return is_app_of(a, Z3_OP_SELECT)
4549
def is_select(a)
Definition: z3py.py:4538

Referenced by is_select().

◆ is_seq()

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

10054def is_seq(a):
10055 """Return `True` if `a` is a Z3 sequence expression.
10056 >>> print (is_seq(Unit(IntVal(0))))
10057 True
10058 >>> print (is_seq(StringVal("abc")))
10059 True
10060 """
10061 return isinstance(a, SeqRef)
10062
def Unit(a)
Definition: z3py.py:10148

Referenced by SeqRef.__gt__(), Concat(), Extract(), and is_seq().

◆ is_sort()

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

596def is_sort(s):
597 """Return `True` if `s` is a Z3 sort.
598
599 >>> is_sort(IntSort())
600 True
601 >>> is_sort(Int('x'))
602 False
603 >>> is_expr(Int('x'))
604 True
605 """
606 return isinstance(s, SortRef)
607

Referenced by ArraySort(), CreateDatatypes(), Function(), is_sort(), IsSubset(), K(), prove(), RecFunction(), and Var().

◆ is_store()

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

4550def is_store(a):
4551 """Return `True` if `a` is a Z3 array store application.
4552
4553 >>> a = Array('a', IntSort(), IntSort())
4554 >>> is_store(a)
4555 False
4556 >>> is_store(Store(a, 0, 1))
4557 True
4558 """
4559 return is_app_of(a, Z3_OP_STORE)
4560
def is_store(a)
Definition: z3py.py:4550

Referenced by is_store().

◆ is_string()

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

Definition at line 10063 of file z3py.py.

10063def is_string(a):
10064 """Return `True` if `a` is a Z3 string expression.
10065 >>> print (is_string(StringVal("ab")))
10066 True
10067 """
10068 return isinstance(a, SeqRef) and a.is_string()
10069
def is_string(a)
Definition: z3py.py:10063

Referenced by is_string().

◆ is_string_value()

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

10070def is_string_value(a):
10071 """return 'True' if 'a' is a Z3 string constant expression.
10072 >>> print (is_string_value(StringVal("a")))
10073 True
10074 >>> print (is_string_value(StringVal("a") + StringVal("b")))
10075 False
10076 """
10077 return isinstance(a, SeqRef) and a.is_string_value()
10078
10079
def is_string_value(a)
Definition: z3py.py:10070

Referenced by is_string_value().

◆ is_sub()

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

2618def is_sub(a):
2619 """Return `True` if `a` is an expression of the form b - c.
2620
2621 >>> x, y = Ints('x y')
2622 >>> is_sub(x - y)
2623 True
2624 >>> is_sub(x + y)
2625 False
2626 """
2627 return is_app_of(a, Z3_OP_SUB)
2628
def is_sub(a)
Definition: z3py.py:2618

Referenced by is_sub().

◆ is_to_int()

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

2736def is_to_int(a):
2737 """Return `True` if `a` is an expression of the form ToInt(b).
2738
2739 >>> x = Real('x')
2740 >>> n = ToInt(x)
2741 >>> n
2742 ToInt(x)
2743 >>> is_to_int(n)
2744 True
2745 >>> is_to_int(x)
2746 False
2747 """
2748 return is_app_of(a, Z3_OP_TO_INT)
2749
def is_to_int(a)
Definition: z3py.py:2736
def ToInt(a)
Definition: z3py.py:3127

Referenced by is_to_int().

◆ is_to_real()

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

2722def is_to_real(a):
2723 """Return `True` if `a` is an expression of the form ToReal(b).
2724
2725 >>> x = Int('x')
2726 >>> n = ToReal(x)
2727 >>> n
2728 ToReal(x)
2729 >>> is_to_real(n)
2730 True
2731 >>> is_to_real(x)
2732 False
2733 """
2734 return is_app_of(a, Z3_OP_TO_REAL)
2735
def ToReal(a)
Definition: z3py.py:3110
def is_to_real(a)
Definition: z3py.py:2722

Referenced by is_to_real().

◆ is_true()

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

1439def is_true(a):
1440 """Return `True` if `a` is the Z3 true expression.
1441
1442 >>> p = Bool('p')
1443 >>> is_true(p)
1444 False
1445 >>> is_true(simplify(p == p))
1446 True
1447 >>> x = Real('x')
1448 >>> is_true(x == 0)
1449 False
1450 >>> # True is a Python Boolean expression
1451 >>> is_true(True)
1452 False
1453 """
1454 return is_app_of(a, Z3_OP_TRUE)
1455

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

◆ is_var()

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

1180def is_var(a):
1181 """Return `True` if `a` is variable.
1182
1183 Z3 uses de-Bruijn indices for representing bound variables in
1184 quantifiers.
1185
1186 >>> x = Int('x')
1187 >>> is_var(x)
1188 False
1189 >>> is_const(x)
1190 True
1191 >>> f = Function('f', IntSort(), IntSort())
1192 >>> # Z3 replaces x with bound variables when ForAll is executed.
1193 >>> q = ForAll(x, f(x) == x)
1194 >>> b = q.body()
1195 >>> b
1196 f(Var(0)) == Var(0)
1197 >>> b.arg(1)
1198 Var(0)
1199 >>> is_var(b.arg(1))
1200 True
1201 """
1202 return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1203

Referenced by get_var_index(), and is_var().

◆ IsInt()

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

3144def IsInt(a):
3145 """ Return the Z3 predicate IsInt(a).
3146
3147 >>> x = Real('x')
3148 >>> IsInt(x + "1/2")
3149 IsInt(x + 1/2)
3150 >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3151 [x = 1/2]
3152 >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3153 no solution
3154 """
3155 if z3_debug():
3156 _z3_assert(a.is_real(), "Z3 real expression expected.")
3157 ctx = a.ctx
3158 return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3159
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 z3py.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 4651 of file z3py.py.

4651def IsMember(e, s):
4652 """ Check if e is a member of set s
4653 >>> a = Const('a', SetSort(IntSort()))
4654 >>> IsMember(1, a)
4655 a[1]
4656 """
4657 ctx = _ctx_from_ast_arg_list([s,e])
4658 e = _py2expr(e, ctx)
4659 return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4660
def IsMember(e, s)
Definition: z3py.py:4651
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 z3py.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 4661 of file z3py.py.

4661def IsSubset(a, b):
4662 """ Check if a is a subset of b
4663 >>> a = Const('a', SetSort(IntSort()))
4664 >>> b = Const('b', SetSort(IntSort()))
4665 >>> IsSubset(a, b)
4666 subset(a, b)
4667 """
4668 ctx = _ctx_from_ast_arg_list([a, b])
4669 return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4670
4671
def IsSubset(a, b)
Definition: z3py.py:4661
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 z3py.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 4501 of file z3py.py.

4501def K(dom, v):
4502 """Return a Z3 constant array expression.
4503
4504 >>> a = K(IntSort(), 10)
4505 >>> a
4506 K(Int, 10)
4507 >>> a.sort()
4508 Array(Int, Int)
4509 >>> i = Int('i')
4510 >>> a[i]
4511 K(Int, 10)[i]
4512 >>> simplify(a[i])
4513 10
4514 """
4515 if z3_debug():
4516 _z3_assert(is_sort(dom), "Z3 sort expected")
4517 ctx = dom.ctx
4518 if not is_expr(v):
4519 v = _py2expr(v, ctx)
4520 return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4521
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(), is_const_array(), is_default(), is_K(), and K().

◆ Lambda()

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

2081def Lambda(vs, body):
2082 """Create a Z3 lambda expression.
2083
2084 >>> f = Function('f', IntSort(), IntSort(), IntSort())
2085 >>> mem0 = Array('mem0', IntSort(), IntSort())
2086 >>> lo, hi, e, i = Ints('lo hi e i')
2087 >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2088 >>> mem1
2089 Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2090 """
2091 ctx = body.ctx
2092 if is_app(vs):
2093 vs = [vs]
2094 num_vars = len(vs)
2095 _vs = (Ast * num_vars)()
2096 for i in range(num_vars):
2097
2098 _vs[i] = vs[i].as_ast()
2099 return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2100
def Lambda(vs, body)
Definition: z3py.py:2081
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 z3py.LastIndexOf (   s,
  substr 
)
Retrieve the last index of substring within a string

Definition at line 10233 of file z3py.py.

10233def LastIndexOf(s, substr):
10234 """Retrieve the last index of substring within a string"""
10235 ctx = None
10236 ctx = _get_ctx2(s, substr, ctx)
10237 s = _coerce_seq(s, ctx)
10238 substr = _coerce_seq(substr, ctx)
10239 return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10240
10241
def LastIndexOf(s, substr)
Definition: z3py.py:10233
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast, Z3_ast substr)
Return the last occurrence of substr in s. If s does not contain substr, then the value is -1,...

◆ Length()

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

Definition at line 10242 of file z3py.py.

10242def Length(s):
10243 """Obtain the length of a sequence 's'
10244 >>> l = Length(StringVal("abc"))
10245 >>> simplify(l)
10246 3
10247 """
10248 s = _coerce_seq(s)
10249 return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10250
def Length(s)
Definition: z3py.py:10242
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 z3py.LinearOrder (   a,
  index 
)

Definition at line 10431 of file z3py.py.

10431def LinearOrder(a, index):
10432 return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10433
def LinearOrder(a, index)
Definition: z3py.py:10431
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 z3py.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 10402 of file z3py.py.

10402def Loop(re, lo, hi=0):
10403 """Create the regular expression accepting between a lower and upper bound repetitions
10404 >>> re = Loop(Re("a"), 1, 3)
10405 >>> print(simplify(InRe("aa", re)))
10406 True
10407 >>> print(simplify(InRe("aaaa", re)))
10408 False
10409 >>> print(simplify(InRe("", re)))
10410 False
10411 """
10412 return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10413
def Loop(re, lo, hi=0)
Definition: z3py.py:10402
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 z3py.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 4013 of file z3py.py.

4013def LShR(a, b):
4014 """Create the Z3 expression logical right shift.
4015
4016 Use the operator >> for the arithmetical right shift.
4017
4018 >>> x, y = BitVecs('x y', 32)
4019 >>> LShR(x, y)
4020 LShR(x, y)
4021 >>> (x >> y).sexpr()
4022 '(bvashr x y)'
4023 >>> LShR(x, y).sexpr()
4024 '(bvlshr x y)'
4025 >>> BitVecVal(4, 3)
4026 4
4027 >>> BitVecVal(4, 3).as_signed_long()
4028 -4
4029 >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4030 -2
4031 >>> simplify(BitVecVal(4, 3) >> 1)
4032 6
4033 >>> simplify(LShR(BitVecVal(4, 3), 1))
4034 2
4035 >>> simplify(BitVecVal(2, 3) >> 1)
4036 1
4037 >>> simplify(LShR(BitVecVal(2, 3), 1))
4038 1
4039 """
4040 _check_bv_args(a, b)
4041 a, b = _coerce_exprs(a, b)
4042 return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4043
def LShR(a, b)
Definition: z3py.py:4013
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 z3py.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 211 of file z3py.py.

211def main_ctx():
212 """Return a reference to the global Z3 context.
213
214 >>> x = Real('x')
215 >>> x.ctx == main_ctx()
216 True
217 >>> c = Context()
218 >>> c == main_ctx()
219 False
220 >>> x2 = Real('x', c)
221 >>> x2.ctx == c
222 True
223 >>> eq(x, x2)
224 False
225 """
226 global _main_ctx
227 if _main_ctx is None:
228 _main_ctx = Context()
229 return _main_ctx
230

Referenced by SeqRef.__gt__(), And(), help_simplify(), main_ctx(), Or(), simplify_param_descrs(), and Goal.translate().

◆ Map()

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

4479def Map(f, *args):
4480 """Return a Z3 map array expression.
4481
4482 >>> f = Function('f', IntSort(), IntSort(), IntSort())
4483 >>> a1 = Array('a1', IntSort(), IntSort())
4484 >>> a2 = Array('a2', IntSort(), IntSort())
4485 >>> b = Map(f, a1, a2)
4486 >>> b
4487 Map(f, a1, a2)
4488 >>> prove(b[0] == f(a1[0], a2[0]))
4489 proved
4490 """
4491 args = _get_args(args)
4492 if z3_debug():
4493 _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4494 _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4495 _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4496 _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4497 _args, sz = _to_ast_array(args)
4498 ctx = f.ctx
4499 return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4500
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 Context.Context(), get_map_func(), is_map(), and Map().

◆ mk_not()

def z3py.mk_not (   a)

Definition at line 1667 of file z3py.py.

1667def mk_not(a):
1668 if is_not(a):
1669 return a.arg(0)
1670 else:
1671 return Not(a)
1672
def mk_not(a)
Definition: z3py.py:1667

◆ Model()

def z3py.Model (   ctx = None)

Definition at line 6236 of file z3py.py.

6236def Model(ctx = None):
6237 ctx = _get_ctx(ctx)
6238 return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6239
def Model(ctx=None)
Definition: z3py.py:6236
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.

Referenced by Goal.convertModel(), Optimize.getModel(), Solver.getModel(), and ModelRef.translate().

◆ MultiPattern()

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

1776def MultiPattern(*args):
1777 """Create a Z3 multi-pattern using the given expressions `*args`
1778
1779 >>> f = Function('f', IntSort(), IntSort())
1780 >>> g = Function('g', IntSort(), IntSort())
1781 >>> x = Int('x')
1782 >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1783 >>> q
1784 ForAll(x, f(x) != g(x))
1785 >>> q.num_patterns()
1786 1
1787 >>> is_pattern(q.pattern(0))
1788 True
1789 >>> q.pattern(0)
1790 MultiPattern(f(Var(0)), g(Var(0)))
1791 """
1792 if z3_debug():
1793 _z3_assert(len(args) > 0, "At least one argument expected")
1794 _z3_assert(all([ is_expr(a) for a in args ]), "Z3 expressions expected")
1795 ctx = args[0].ctx
1796 args, sz = _to_ast_array(args)
1797 return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
1798
def MultiPattern(*args)
Definition: z3py.py:1776
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 MultiPattern().

◆ Not()

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

1649def Not(a, ctx=None):
1650 """Create a Z3 not expression or probe.
1651
1652 >>> p = Bool('p')
1653 >>> Not(Not(p))
1654 Not(Not(p))
1655 >>> simplify(Not(Not(p)))
1656 p
1657 """
1658 ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1659 if is_probe(a):
1660 # Not is also used to build probes
1661 return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1662 else:
1663 s = BoolSort(ctx)
1664 a = s.cast(a)
1665 return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1666
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 AndThen(), ApplyResult.as_expr(), Solver.consequences(), Goal.convert_model(), Distinct(), FailIf(), fpNEQ(), is_not(), mk_not(), Not(), prove(), simplify(), Then(), When(), and Xor().

◆ open_log()

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

Definition at line 101 of file z3py.py.

101def open_log(fname):
102 """Log interaction to a file. This function must be invoked immediately after init(). """
103 Z3_open_log(fname)
104
def open_log(fname)
Definition: z3py.py:101
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.

◆ Option()

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

10374def Option(re):
10375 """Create the regular expression that optionally accepts the argument.
10376 >>> re = Option(Re("a"))
10377 >>> print(simplify(InRe("a", re)))
10378 True
10379 >>> print(simplify(InRe("", re)))
10380 True
10381 >>> print(simplify(InRe("aa", re)))
10382 False
10383 """
10384 return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10385
def Option(re)
Definition: z3py.py:10374
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].

Referenced by Option().

◆ Or()

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

1713def Or(*args):
1714 """Create a Z3 or-expression or or-probe.
1715
1716 >>> p, q, r = Bools('p q r')
1717 >>> Or(p, q, r)
1718 Or(p, q, r)
1719 >>> P = BoolVector('p', 5)
1720 >>> Or(P)
1721 Or(p__0, p__1, p__2, p__3, p__4)
1722 """
1723 last_arg = None
1724 if len(args) > 0:
1725 last_arg = args[len(args)-1]
1726 if isinstance(last_arg, Context):
1727 ctx = args[len(args)-1]
1728 args = args[:len(args)-1]
1729 else:
1730 ctx = main_ctx()
1731 args = _get_args(args)
1732 ctx_args = _ctx_from_ast_arg_list(args, ctx)
1733 if z3_debug():
1734 _z3_assert(ctx_args is None or ctx_args == ctx, "context mismatch")
1735 _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1736 if _has_probe(args):
1737 return _probe_or(args, ctx)
1738 else:
1739 args = _coerce_expr_list(args, ctx)
1740 _args, sz = _to_ast_array(args)
1741 return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1742
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 z3py.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 7778 of file z3py.py.

7778def OrElse(*ts, **ks):
7779 """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7780
7781 >>> x = Int('x')
7782 >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7783 >>> # Tactic split-clause fails if there is no clause in the given goal.
7784 >>> t(x == 0)
7785 [[x == 0]]
7786 >>> t(Or(x == 0, x == 1))
7787 [[x == 0], [x == 1]]
7788 """
7789 if z3_debug():
7790 _z3_assert(len(ts) >= 2, "At least two arguments expected")
7791 ctx = ks.get('ctx', None)
7792 num = len(ts)
7793 r = ts[0]
7794 for i in range(num - 1):
7795 r = _or_else(r, ts[i+1], ctx)
7796 return r
7797

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

◆ ParAndThen()

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

Definition at line 7830 of file z3py.py.

7830def ParAndThen(t1, t2, ctx=None):
7831 """Alias for ParThen(t1, t2, ctx)."""
7832 return ParThen(t1, t2, ctx)
7833
def ParThen(t1, t2, ctx=None)
Definition: z3py.py:7816
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7830

◆ ParOr()

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

7798def ParOr(*ts, **ks):
7799 """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7800
7801 >>> x = Int('x')
7802 >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7803 >>> t(x + 1 == 2)
7804 [[x == 1]]
7805 """
7806 if z3_debug():
7807 _z3_assert(len(ts) >= 2, "At least two arguments expected")
7808 ctx = _get_ctx(ks.get('ctx', None))
7809 ts = [ _to_tactic(t, ctx) for t in ts ]
7810 sz = len(ts)
7811 _args = (TacticObj * sz)()
7812 for i in range(sz):
7813 _args[i] = ts[i].tactic
7814 return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7815
def ParOr(*ts, **ks)
Definition: z3py.py:7798
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 z3py.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 8603 of file z3py.py.

8603def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8604 """Parse a file in SMT 2.0 format using the given sorts and decls.
8605
8606 This function is similar to parse_smt2_string().
8607 """
8608 ctx = _get_ctx(ctx)
8609 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8610 dsz, dnames, ddecls = _dict2darray(decls, ctx)
8611 return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8612
8613
def parse_smt2_string(s, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8583
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8603
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 z3py.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 8583 of file z3py.py.

8583def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8584 """Parse a string in SMT 2.0 format using the given sorts and decls.
8585
8586 The arguments sorts and decls are Python dictionaries used to initialize
8587 the symbol table used for the SMT 2.0 parser.
8588
8589 >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8590 [x > 0, x < 10]
8591 >>> x, y = Ints('x y')
8592 >>> f = Function('f', IntSort(), IntSort())
8593 >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8594 [x + f(y) > 0]
8595 >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8596 [a > 0]
8597 """
8598 ctx = _get_ctx(ctx)
8599 ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8600 dsz, dnames, ddecls = _dict2darray(decls, ctx)
8601 return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8602
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 z3py.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 7816 of file z3py.py.

7816def ParThen(t1, t2, ctx=None):
7817 """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7818
7819 >>> x, y = Ints('x y')
7820 >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7821 >>> t(And(Or(x == 1, x == 2), y == x + 1))
7822 [[x == 1, y == 2], [x == 2, y == 3]]
7823 """
7824 t1 = _to_tactic(t1, ctx)
7825 t2 = _to_tactic(t2, ctx)
7826 if z3_debug():
7827 _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7828 return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7829
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 z3py.PartialOrder (   a,
  index 
)

Definition at line 10428 of file z3py.py.

10428def PartialOrder(a, index):
10429 return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10430
def PartialOrder(a, index)
Definition: z3py.py:10428
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 z3py.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 8390 of file z3py.py.

8390def PbEq(args, k, ctx = None):
8391 """Create a Pseudo-Boolean inequality k constraint.
8392
8393 >>> a, b, c = Bools('a b c')
8394 >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8395 """
8396 _z3_check_cint_overflow(k, "k")
8397 ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8398 return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8399
8400
def PbEq(args, k, ctx=None)
Definition: z3py.py:8390
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 z3py.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 8380 of file z3py.py.

8380def PbGe(args, k):
8381 """Create a Pseudo-Boolean inequality k constraint.
8382
8383 >>> a, b, c = Bools('a b c')
8384 >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8385 """
8386 _z3_check_cint_overflow(k, "k")
8387 ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8388 return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8389
def PbGe(args, k)
Definition: z3py.py:8380
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 z3py.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 8370 of file z3py.py.

8370def PbLe(args, k):
8371 """Create a Pseudo-Boolean inequality k constraint.
8372
8373 >>> a, b, c = Bools('a b c')
8374 >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8375 """
8376 _z3_check_cint_overflow(k, "k")
8377 ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8378 return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8379
def PbLe(args, k)
Definition: z3py.py:8370
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 z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 10437 of file z3py.py.

10437def PiecewiseLinearOrder(a, index):
10438 return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10439
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10437
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 z3py.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 10362 of file z3py.py.

10362def Plus(re):
10363 """Create the regular expression accepting one or more repetitions of argument.
10364 >>> re = Plus(Re("a"))
10365 >>> print(simplify(InRe("aa", re)))
10366 True
10367 >>> print(simplify(InRe("ab", re)))
10368 False
10369 >>> print(simplify(InRe("", re)))
10370 False
10371 """
10372 return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10373
def Plus(re)
Definition: z3py.py:10362
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.

Referenced by Plus().

◆ PrefixOf()

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

10152def PrefixOf(a, b):
10153 """Check if 'a' is a prefix of 'b'
10154 >>> s1 = PrefixOf("ab", "abc")
10155 >>> simplify(s1)
10156 True
10157 >>> s2 = PrefixOf("bc", "abc")
10158 >>> simplify(s2)
10159 False
10160 """
10161 ctx = _get_ctx2(a, b)
10162 a = _coerce_seq(a, ctx)
10163 b = _coerce_seq(b, ctx)
10164 return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10165
def PrefixOf(a, b)
Definition: z3py.py:10152
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 z3py.probe_description (   name,
  ctx = None 
)
Return a short description for the probe named `name`.

>>> d = probe_description('memory')

Definition at line 8088 of file z3py.py.

8088def probe_description(name, ctx=None):
8089 """Return a short description for the probe named `name`.
8090
8091 >>> d = probe_description('memory')
8092 """
8093 ctx = _get_ctx(ctx)
8094 return Z3_probe_get_descr(ctx.ref(), name)
8095
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 z3py.probes (   ctx = None)
Return a list of all available probes in Z3.

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

Definition at line 8078 of file z3py.py.

8078def probes(ctx=None):
8079 """Return a list of all available probes in Z3.
8080
8081 >>> l = probes()
8082 >>> l.count('memory') == 1
8083 True
8084 """
8085 ctx = _get_ctx(ctx)
8086 return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8087
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 z3py.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 8286 of file z3py.py.

8286def Product(*args):
8287 """Create the product of the Z3 expressions.
8288
8289 >>> a, b, c = Ints('a b c')
8290 >>> Product(a, b, c)
8291 a*b*c
8292 >>> Product([a, b, c])
8293 a*b*c
8294 >>> A = IntVector('a', 5)
8295 >>> Product(A)
8296 a__0*a__1*a__2*a__3*a__4
8297 """
8298 args = _get_args(args)
8299 if len(args) == 0:
8300 return 1
8301 ctx = _ctx_from_ast_arg_list(args)
8302 if ctx is None:
8303 return _reduce(lambda a, b: a * b, args, 1)
8304 args = _coerce_expr_list(args, ctx)
8305 if is_bv(args[0]):
8306 return _reduce(lambda a, b: a * b, args, 1)
8307 else:
8308 _args, sz = _to_ast_array(args)
8309 return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8310
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().

◆ prove()

def z3py.prove (   claim,
**  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 8458 of file z3py.py.

8458def prove(claim, **keywords):
8459 """Try to prove the given claim.
8460
8461 This is a simple function for creating demonstrations. It tries to prove
8462 `claim` by showing the negation is unsatisfiable.
8463
8464 >>> p, q = Bools('p q')
8465 >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8466 proved
8467 """
8468 if z3_debug():
8469 _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8470 s = Solver()
8471 s.set(**keywords)
8472 s.add(Not(claim))
8473 if keywords.get('show', False):
8474 print(s)
8475 r = s.check()
8476 if r == unsat:
8477 print("proved")
8478 elif r == unknown:
8479 print("failed to prove")
8480 print(s.model())
8481 else:
8482 print("counterexample")
8483 print(s.model())
8484

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

◆ Q()

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

2998def Q(a, b, ctx=None):
2999 """Return a Z3 rational a/b.
3000
3001 If `ctx=None`, then the global context is used.
3002
3003 >>> Q(3,5)
3004 3/5
3005 >>> Q(3,5).sort()
3006 Real
3007 """
3008 return simplify(RatVal(a, b))
3009
def Q(a, b, ctx=None)
Definition: z3py.py:2998
def RatVal(a, b, ctx=None)
Definition: z3py.py:2983

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

◆ Range()

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

10414def Range(lo, hi, ctx = None):
10415 """Create the range regular expression over two sequences of length 1
10416 >>> range = Range("a","z")
10417 >>> print(simplify(InRe("b", range)))
10418 True
10419 >>> print(simplify(InRe("bb", range)))
10420 False
10421 """
10422 lo = _coerce_seq(lo, ctx)
10423 hi = _coerce_seq(hi, ctx)
10424 return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10425
10426# Special Relations
10427
def Range(lo, hi, ctx=None)
Definition: z3py.py:10414
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 z3py.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 2983 of file z3py.py.

2983def RatVal(a, b, ctx=None):
2984 """Return a Z3 rational a/b.
2985
2986 If `ctx=None`, then the global context is used.
2987
2988 >>> RatVal(3,5)
2989 3/5
2990 >>> RatVal(3,5).sort()
2991 Real
2992 """
2993 if z3_debug():
2994 _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
2995 _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
2996 return simplify(RealVal(a, ctx)/RealVal(b, ctx))
2997

Referenced by Q(), and RatVal().

◆ Re()

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

10274def Re(s, ctx=None):
10275 """The regular expression that accepts sequence 's'
10276 >>> s1 = Re("ab")
10277 >>> s2 = Re(StringVal("ab"))
10278 >>> s3 = Re(Unit(BoolVal(True)))
10279 """
10280 s = _coerce_seq(s, ctx)
10281 return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10282
10283
10284
10285
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 z3py.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 3058 of file z3py.py.

3058def Real(name, ctx=None):
3059 """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3060
3061 >>> x = Real('x')
3062 >>> is_real(x)
3063 True
3064 >>> is_real(x + 1)
3065 True
3066 """
3067 ctx = _get_ctx(ctx)
3068 return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3069

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

3070def Reals(names, ctx=None):
3071 """Return a tuple of real constants.
3072
3073 >>> x, y, z = Reals('x y z')
3074 >>> Sum(x, y, z)
3075 x + y + z
3076 >>> Sum(x, y, z).sort()
3077 Real
3078 """
3079 ctx = _get_ctx(ctx)
3080 if isinstance(names, str):
3081 names = names.split(" ")
3082 return [Real(name, ctx) for name in names]
3083

Referenced by is_div(), and Reals().

◆ RealSort()

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

2923def RealSort(ctx=None):
2924 """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2925
2926 >>> RealSort()
2927 Real
2928 >>> x = Const('x', RealSort())
2929 >>> is_real(x)
2930 True
2931 >>> is_int(x)
2932 False
2933 >>> x.sort() == RealSort()
2934 True
2935 """
2936 ctx = _get_ctx(ctx)
2937 return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2938
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(), Context.getRealSort(), is_arith_sort(), Context.mkRealSort(), FuncDeclRef.range(), Real(), RealSort(), RealVal(), RealVar(), SortRef.subsort(), and QuantifierRef.var_sort().

◆ RealVal()

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

2965def RealVal(val, ctx=None):
2966 """Return a Z3 real value.
2967
2968 `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
2969 If `ctx=None`, then the global context is used.
2970
2971 >>> RealVal(1)
2972 1
2973 >>> RealVal(1).sort()
2974 Real
2975 >>> RealVal("3/5")
2976 3/5
2977 >>> RealVal("1.5")
2978 3/2
2979 """
2980 ctx = _get_ctx(ctx)
2981 return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
2982

Referenced by RatNumRef.as_decimal(), AlgebraicNumRef.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 z3py.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 1343 of file z3py.py.

1343def RealVar(idx, ctx=None):
1344 """
1345 Create a real free variable. Free variables are used to create quantified formulas.
1346 They are also used to create polynomials.
1347
1348 >>> RealVar(0)
1349 Var(0)
1350 """
1351 return Var(idx, RealSort(ctx))
1352
def RealVar(idx, ctx=None)
Definition: z3py.py:1343

Referenced by RealVar(), and RealVarVector().

◆ RealVarVector()

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

1353def RealVarVector(n, ctx=None):
1354 """
1355 Create a list of Real free variables.
1356 The variables have ids: 0, 1, ..., n-1
1357
1358 >>> x0, x1, x2, x3 = RealVarVector(4)
1359 >>> x2
1360 Var(2)
1361 """
1362 return [ RealVar(i, ctx) for i in range(n) ]
1363
def RealVarVector(n, ctx=None)
Definition: z3py.py:1353

Referenced by RealVarVector().

◆ RealVector()

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

3084def RealVector(prefix, sz, ctx=None):
3085 """Return a list of real constants of size `sz`.
3086
3087 >>> X = RealVector('x', 3)
3088 >>> X
3089 [x__0, x__1, x__2]
3090 >>> Sum(X)
3091 x__0 + x__1 + x__2
3092 >>> Sum(X).sort()
3093 Real
3094 """
3095 return [ Real('%s__%s' % (prefix, i)) for i in range(sz) ]
3096
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3084

Referenced by RealVector().

◆ RecAddDefinition()

def z3py.RecAddDefinition (   f,
  args,
  body 
)
Set the body of a recursive function.
   Recursive definitions are only unfolded during search.
>>> 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))
fac(5)
>>> s = Solver(ctx=ctx)
>>> s.add(fac(n) < 3)
>>> s.check()
sat
>>> s.model().eval(fac(5))
120

Definition at line 841 of file z3py.py.

841def RecAddDefinition(f, args, body):
842 """Set the body of a recursive function.
843 Recursive definitions are only unfolded during search.
844 >>> ctx = Context()
845 >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
846 >>> n = Int('n', ctx)
847 >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
848 >>> simplify(fac(5))
849 fac(5)
850 >>> s = Solver(ctx=ctx)
851 >>> s.add(fac(n) < 3)
852 >>> s.check()
853 sat
854 >>> s.model().eval(fac(5))
855 120
856 """
857 if is_app(args):
858 args = [args]
859 ctx = body.ctx
860 args = _get_args(args)
861 n = len(args)
862 _args = (Ast * n)()
863 for i in range(n):
864 _args[i] = args[i].ast
865 Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
866
def RecAddDefinition(f, args, body)
Definition: z3py.py:841
def RecFunction(name, *sig)
Definition: z3py.py:824
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 z3py.RecFunction (   name,
sig 
)
Create a new Z3 recursive with the given sorts.

Definition at line 824 of file z3py.py.

824def RecFunction(name, *sig):
825 """Create a new Z3 recursive with the given sorts."""
826 sig = _get_args(sig)
827 if z3_debug():
828 _z3_assert(len(sig) > 0, "At least two arguments expected")
829 arity = len(sig) - 1
830 rng = sig[arity]
831 if z3_debug():
832 _z3_assert(is_sort(rng), "Z3 sort expected")
833 dom = (Sort * arity)()
834 for i in range(arity):
835 if z3_debug():
836 _z3_assert(is_sort(sig[i]), "Z3 sort expected")
837 dom[i] = sig[i].ast
838 ctx = rng.ctx
839 return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
840
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 z3py.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 7860 of file z3py.py.

7860def Repeat(t, max=4294967295, ctx=None):
7861 """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7862
7863 >>> x, y = Ints('x y')
7864 >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7865 >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7866 >>> r = t(c)
7867 >>> for subgoal in r: print(subgoal)
7868 [x == 0, y == 0, x > y]
7869 [x == 0, y == 1, x > y]
7870 [x == 1, y == 0, x > y]
7871 [x == 1, y == 1, x > y]
7872 >>> t = Then(t, Tactic('propagate-values'))
7873 >>> t(c)
7874 [[x == 1, y == 0]]
7875 """
7876 t = _to_tactic(t, ctx)
7877 return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7878
def Repeat(t, max=4294967295, ctx=None)
Definition: z3py.py:7860
def Then(*ts, **ks)
Definition: z3py.py:7766
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 z3py.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 4130 of file z3py.py.

4130def RepeatBitVec(n, a):
4131 """Return an expression representing `n` copies of `a`.
4132
4133 >>> x = BitVec('x', 8)
4134 >>> n = RepeatBitVec(4, x)
4135 >>> n
4136 RepeatBitVec(4, x)
4137 >>> n.size()
4138 32
4139 >>> v0 = BitVecVal(10, 4)
4140 >>> print("%.x" % v0.as_long())
4141 a
4142 >>> v = simplify(RepeatBitVec(4, v0))
4143 >>> v.size()
4144 16
4145 >>> print("%.x" % v.as_long())
4146 aaaa
4147 """
4148 if z3_debug():
4149 _z3_assert(_is_int(n), "First argument must be an integer")
4150 _z3_assert(is_bv(a), "Second argument must be a Z3 Bitvector expression")
4151 return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4152
def RepeatBitVec(n, a)
Definition: z3py.py:4130
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 z3py.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 10199 of file z3py.py.

10199def Replace(s, src, dst):
10200 """Replace the first occurrence of 'src' by 'dst' in 's'
10201 >>> r = Replace("aaa", "a", "b")
10202 >>> simplify(r)
10203 "baa"
10204 """
10205 ctx = _get_ctx2(dst, s)
10206 if ctx is None and is_expr(src):
10207 ctx = src.ctx
10208 src = _coerce_seq(src, ctx)
10209 dst = _coerce_seq(dst, ctx)
10210 s = _coerce_seq(s, ctx)
10211 return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10212
def Replace(s, src, dst)
Definition: z3py.py:10199
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 z3py.reset_params ( )
Reset all global (or module) parameters.

Definition at line 263 of file z3py.py.

263def reset_params():
264 """Reset all global (or module) parameters.
265 """
267
def reset_params()
Definition: z3py.py:263
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 z3py.ReSort (   s)

Definition at line 10294 of file z3py.py.

10294def ReSort(s):
10295 if is_ast(s):
10296 return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10297 if s is None or isinstance(s, Context):
10298 ctx = _get_ctx(s)
10299 return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10300 raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10301
10302
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 8 bit strings.

Referenced by Empty(), Full(), and Context.mkReSort().

◆ RNA()

def z3py.RNA (   ctx = None)

Definition at line 8992 of file z3py.py.

8992def RNA (ctx=None):
8993 ctx = _get_ctx(ctx)
8994 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
8995
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 z3py.RNE (   ctx = None)

Definition at line 8984 of file z3py.py.

8984def RNE (ctx=None):
8985 ctx = _get_ctx(ctx)
8986 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
8987
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 z3py.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 4044 of file z3py.py.

4044def RotateLeft(a, b):
4045 """Return an expression representing `a` rotated to the left `b` times.
4046
4047 >>> a, b = BitVecs('a b', 16)
4048 >>> RotateLeft(a, b)
4049 RotateLeft(a, b)
4050 >>> simplify(RotateLeft(a, 0))
4051 a
4052 >>> simplify(RotateLeft(a, 16))
4053 a
4054 """
4055 _check_bv_args(a, b)
4056 a, b = _coerce_exprs(a, b)
4057 return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4058
def RotateLeft(a, b)
Definition: z3py.py:4044
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 z3py.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 4059 of file z3py.py.

4059def RotateRight(a, b):
4060 """Return an expression representing `a` rotated to the right `b` times.
4061
4062 >>> a, b = BitVecs('a b', 16)
4063 >>> RotateRight(a, b)
4064 RotateRight(a, b)
4065 >>> simplify(RotateRight(a, 0))
4066 a
4067 >>> simplify(RotateRight(a, 16))
4068 a
4069 """
4070 _check_bv_args(a, b)
4071 a, b = _coerce_exprs(a, b)
4072 return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4073
def RotateRight(a, b)
Definition: z3py.py:4059
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 z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 8988 of file z3py.py.

8988def RoundNearestTiesToAway(ctx=None):
8989 ctx = _get_ctx(ctx)
8990 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
8991
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:8988

◆ RoundNearestTiesToEven()

def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 8980 of file z3py.py.

8980def RoundNearestTiesToEven(ctx=None):
8981 ctx = _get_ctx(ctx)
8982 return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
8983
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:8980

◆ RoundTowardNegative()

def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9004 of file z3py.py.

9004def RoundTowardNegative(ctx=None):
9005 ctx = _get_ctx(ctx)
9006 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9007
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9004
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 z3py.RoundTowardPositive (   ctx = None)

Definition at line 8996 of file z3py.py.

8996def RoundTowardPositive(ctx=None):
8997 ctx = _get_ctx(ctx)
8998 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
8999
def RoundTowardPositive(ctx=None)
Definition: z3py.py:8996
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 z3py.RoundTowardZero (   ctx = None)

Definition at line 9012 of file z3py.py.

9012def RoundTowardZero(ctx=None):
9013 ctx = _get_ctx(ctx)
9014 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9015
def RoundTowardZero(ctx=None)
Definition: z3py.py:9012
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 z3py.RTN (   ctx = None)

Definition at line 9008 of file z3py.py.

9008def RTN(ctx=None):
9009 ctx = _get_ctx(ctx)
9010 return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9011

Referenced by get_default_rounding_mode().

◆ RTP()

def z3py.RTP (   ctx = None)

Definition at line 9000 of file z3py.py.

9000def RTP(ctx=None):
9001 ctx = _get_ctx(ctx)
9002 return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9003

Referenced by get_default_rounding_mode().

◆ RTZ()

def z3py.RTZ (   ctx = None)

Definition at line 9016 of file z3py.py.

9016def RTZ(ctx=None):
9017 ctx = _get_ctx(ctx)
9018 return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9019

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

◆ Select()

def z3py.Select (   a,
  i 
)
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 4464 of file z3py.py.

4464def Select(a, i):
4465 """Return a Z3 select array expression.
4466
4467 >>> a = Array('a', IntSort(), IntSort())
4468 >>> i = Int('i')
4469 >>> Select(a, i)
4470 a[i]
4471 >>> eq(Select(a, i), a[i])
4472 True
4473 """
4474 if z3_debug():
4475 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4476 return a[i]
4477
4478
def Select(a, i)
Definition: z3py.py:4464

Referenced by Select().

◆ SeqSort()

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

Definition at line 9980 of file z3py.py.

9980def SeqSort(s):
9981 """Create a sequence sort over elements provided in the argument
9982 >>> s = SeqSort(IntSort())
9983 >>> s == Unit(IntVal(1)).sort()
9984 True
9985 """
9986 return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
9987
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(), Context.mkSeqSort(), Context.mkStringSort(), and SeqSort().

◆ set_default_fp_sort()

def z3py.set_default_fp_sort (   ebits,
  sbits,
  ctx = None 
)

Definition at line 8656 of file z3py.py.

8656def set_default_fp_sort(ebits, sbits, ctx=None):
8657 global _dflt_fpsort_ebits
8658 global _dflt_fpsort_sbits
8659 _dflt_fpsort_ebits = ebits
8660 _dflt_fpsort_sbits = sbits
8661
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8656

◆ set_default_rounding_mode()

def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 8640 of file z3py.py.

8640def set_default_rounding_mode(rm, ctx=None):
8641 global _dflt_rounding_mode
8642 if is_fprm_value(rm):
8643 _dflt_rounding_mode = rm.decl().kind()
8644 else:
8645 _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8646 _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8647 _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8648 _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8649 _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8650 "illegal rounding mode")
8651 _dflt_rounding_mode = rm
8652
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8640

◆ set_option()

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

Definition at line 268 of file z3py.py.

268def set_option(*args, **kws):
269 """Alias for 'set_param' for backward compatibility.
270 """
271 return set_param(*args, **kws)
272
def set_option(*args, **kws)
Definition: z3py.py:268
def set_param(*args, **kws)
Definition: z3py.py:240

◆ set_param()

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

>>> set_param(precision=10)

Definition at line 240 of file z3py.py.

240def set_param(*args, **kws):
241 """Set Z3 global (or module) parameters.
242
243 >>> set_param(precision=10)
244 """
245 if z3_debug():
246 _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
247 new_kws = {}
248 for k in kws:
249 v = kws[k]
250 if not set_pp_option(k, v):
251 new_kws[k] = v
252 for key in new_kws:
253 value = new_kws[key]
254 Z3_global_param_set(str(key).upper(), _to_param_value(value))
255 prev = None
256 for a in args:
257 if prev is None:
258 prev = a
259 else:
260 Z3_global_param_set(str(prev), _to_param_value(a))
261 prev = None
262
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 z3py.SetAdd (   s,
  e 
)
 Add element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetAdd(a, 1)
Store(a, 1, True)

Definition at line 4612 of file z3py.py.

4612def SetAdd(s, e):
4613 """ Add element e to set s
4614 >>> a = Const('a', SetSort(IntSort()))
4615 >>> SetAdd(a, 1)
4616 Store(a, 1, True)
4617 """
4618 ctx = _ctx_from_ast_arg_list([s,e])
4619 e = _py2expr(e, ctx)
4620 return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4621
def SetAdd(s, e)
Definition: z3py.py:4612
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 z3py.SetComplement (   s)
 The complement of set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetComplement(a)
complement(a)

Definition at line 4632 of file z3py.py.

4632def SetComplement(s):
4633 """ The complement of set s
4634 >>> a = Const('a', SetSort(IntSort()))
4635 >>> SetComplement(a)
4636 complement(a)
4637 """
4638 ctx = s.ctx
4639 return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4640
def SetComplement(s)
Definition: z3py.py:4632
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 z3py.SetDel (   s,
  e 
)
 Remove element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetDel(a, 1)
Store(a, 1, False)

Definition at line 4622 of file z3py.py.

4622def SetDel(s, e):
4623 """ Remove element e to set s
4624 >>> a = Const('a', SetSort(IntSort()))
4625 >>> SetDel(a, 1)
4626 Store(a, 1, False)
4627 """
4628 ctx = _ctx_from_ast_arg_list([s,e])
4629 e = _py2expr(e, ctx)
4630 return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4631
def SetDel(s, e)
Definition: z3py.py:4622
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 z3py.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 4641 of file z3py.py.

4641def SetDifference(a, b):
4642 """ The set difference of a and b
4643 >>> a = Const('a', SetSort(IntSort()))
4644 >>> b = Const('b', SetSort(IntSort()))
4645 >>> SetDifference(a, b)
4646 setminus(a, b)
4647 """
4648 ctx = _ctx_from_ast_arg_list([a, b])
4649 return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4650
def SetDifference(a, b)
Definition: z3py.py:4641
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 z3py.SetHasSize (   a,
  k 
)

Definition at line 4533 of file z3py.py.

4533def SetHasSize(a, k):
4534 ctx = a.ctx
4535 k = _py2expr(k, ctx)
4536 return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4537
def SetHasSize(a, k)
Definition: z3py.py:4533
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 z3py.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 4600 of file z3py.py.

4600def SetIntersect(*args):
4601 """ Take the union of sets
4602 >>> a = Const('a', SetSort(IntSort()))
4603 >>> b = Const('b', SetSort(IntSort()))
4604 >>> SetIntersect(a, b)
4605 intersection(a, b)
4606 """
4607 args = _get_args(args)
4608 ctx = _ctx_from_ast_arg_list(args)
4609 _args, sz = _to_ast_array(args)
4610 return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4611
def SetIntersect(*args)
Definition: z3py.py:4600
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 z3py.SetSort (   s)

Sets.

 Create a set sort over element sort s

Definition at line 4568 of file z3py.py.

4568def SetSort(s):
4569 """ Create a set sort over element sort s"""
4570 return ArraySort(s, BoolSort())
4571

Referenced by Ext(), IsMember(), IsSubset(), Context.mkSetSort(), SetAdd(), SetComplement(), SetDel(), SetDifference(), SetIntersect(), and SetUnion().

◆ SetUnion()

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

4588def SetUnion(*args):
4589 """ Take the union of sets
4590 >>> a = Const('a', SetSort(IntSort()))
4591 >>> b = Const('b', SetSort(IntSort()))
4592 >>> SetUnion(a, b)
4593 union(a, b)
4594 """
4595 args = _get_args(args)
4596 ctx = _ctx_from_ast_arg_list(args)
4597 _args, sz = _to_ast_array(args)
4598 return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4599
def SetUnion(*args)
Definition: z3py.py:4588
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 z3py.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 4074 of file z3py.py.

4074def SignExt(n, a):
4075 """Return a bit-vector expression with `n` extra sign-bits.
4076
4077 >>> x = BitVec('x', 16)
4078 >>> n = SignExt(8, x)
4079 >>> n.size()
4080 24
4081 >>> n
4082 SignExt(8, x)
4083 >>> n.sort()
4084 BitVec(24)
4085 >>> v0 = BitVecVal(2, 2)
4086 >>> v0
4087 2
4088 >>> v0.size()
4089 2
4090 >>> v = simplify(SignExt(6, v0))
4091 >>> v
4092 254
4093 >>> v.size()
4094 8
4095 >>> print("%.x" % v.as_long())
4096 fe
4097 """
4098 if z3_debug():
4099 _z3_assert(_is_int(n), "First argument must be an integer")
4100 _z3_assert(is_bv(a), "Second argument must be a Z3 Bitvector expression")
4101 return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4102
def SignExt(n, a)
Definition: z3py.py:4074
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 z3py.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 6931 of file z3py.py.

6931def SimpleSolver(ctx=None, logFile=None):
6932 """Return a simple general purpose solver with limited amount of preprocessing.
6933
6934 >>> s = SimpleSolver()
6935 >>> x = Int('x')
6936 >>> s.add(x > 0)
6937 >>> s.check()
6938 sat
6939 """
6940 ctx = _get_ctx(ctx)
6941 return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6942
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6931
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 z3py.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 8182 of file z3py.py.

8182def simplify(a, *arguments, **keywords):
8183 """Simplify the expression `a` using the given options.
8184
8185 This function has many options. Use `help_simplify` to obtain the complete list.
8186
8187 >>> x = Int('x')
8188 >>> y = Int('y')
8189 >>> simplify(x + 1 + y + x + 1)
8190 2 + 2*x + y
8191 >>> simplify((x + 1)*(y + 1), som=True)
8192 1 + x + y + x*y
8193 >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8194 And(Not(x == y), Not(x == 1), Not(y == 1))
8195 >>> simplify(And(x == 0, y == 1), elim_and=True)
8196 Not(Or(Not(x == 0), Not(y == 1)))
8197 """
8198 if z3_debug():
8199 _z3_assert(is_expr(a), "Z3 expression expected")
8200 if len(arguments) > 0 or len(keywords) > 0:
8201 p = args2params(arguments, keywords, a.ctx)
8202 return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8203 else:
8204 return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8205
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 z3py.simplify_param_descrs ( )
Return the set of parameter descriptions for Z3 `simplify` procedure.

Definition at line 8210 of file z3py.py.

8211 """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8212 return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8213
def simplify_param_descrs()
Definition: z3py.py:8210
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.

◆ solve()

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

8401def solve(*args, **keywords):
8402 """Solve the constraints `*args`.
8403
8404 This is a simple function for creating demonstrations. It creates a solver,
8405 configure it using the options in `keywords`, adds the constraints
8406 in `args`, and invokes check.
8407
8408 >>> a = Int('a')
8409 >>> solve(a > 0, a < 2)
8410 [a = 1]
8411 """
8412 s = Solver()
8413 s.set(**keywords)
8414 s.add(*args)
8415 if keywords.get('show', False):
8416 print(s)
8417 r = s.check()
8418 if r == unsat:
8419 print("no solution")
8420 elif r == unknown:
8421 print("failed to solve")
8422 try:
8423 print(s.model())
8424 except Z3Exception:
8425 return
8426 else:
8427 print(s.model())
8428

Referenced by BV2Int(), IsInt(), and solve().

◆ solve_using()

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

8429def solve_using(s, *args, **keywords):
8430 """Solve the constraints `*args` using solver `s`.
8431
8432 This is a simple function for creating demonstrations. It is similar to `solve`,
8433 but it uses the given solver `s`.
8434 It configures solver `s` using the options in `keywords`, adds the constraints
8435 in `args`, and invokes check.
8436 """
8437 if z3_debug():
8438 _z3_assert(isinstance(s, Solver), "Solver object expected")
8439 s.set(**keywords)
8440 s.add(*args)
8441 if keywords.get('show', False):
8442 print("Problem:")
8443 print(s)
8444 r = s.check()
8445 if r == unsat:
8446 print("no solution")
8447 elif r == unknown:
8448 print("failed to solve")
8449 try:
8450 print(s.model())
8451 except Z3Exception:
8452 return
8453 else:
8454 if keywords.get('show', False):
8455 print("Solution:")
8456 print(s.model())
8457
def solve_using(s, *args, **keywords)
Definition: z3py.py:8429

◆ SolverFor()

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

6911def SolverFor(logic, ctx=None, logFile=None):
6912 """Create a solver customized for the given logic.
6913
6914 The parameter `logic` is a string. It should be contains
6915 the name of a SMT-LIB logic.
6916 See http://www.smtlib.org/ for the name of all available logics.
6917
6918 >>> s = SolverFor("QF_LIA")
6919 >>> x = Int('x')
6920 >>> s.add(x > 0)
6921 >>> s.add(x < 2)
6922 >>> s.check()
6923 sat
6924 >>> s.model()
6925 [x = 1]
6926 """
6927 ctx = _get_ctx(ctx)
6928 logic = to_symbol(logic)
6929 return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6930
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6911
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 z3py.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 3160 of file z3py.py.

3160def Sqrt(a, ctx=None):
3161 """ Return a Z3 expression which represents the square root of a.
3162
3163 >>> x = Real('x')
3164 >>> Sqrt(x)
3165 x**(1/2)
3166 """
3167 if not is_expr(a):
3168 ctx = _get_ctx(ctx)
3169 a = RealVal(a, ctx)
3170 return a ** "1/2"
3171

Referenced by AlgebraicNumRef.approx(), AlgebraicNumRef.as_decimal(), is_algebraic_value(), and Sqrt().

◆ SRem()

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

3993def SRem(a, b):
3994 """Create the Z3 expression signed remainder.
3995
3996 Use the operator % for signed modulus, and URem() for unsigned remainder.
3997
3998 >>> x = BitVec('x', 32)
3999 >>> y = BitVec('y', 32)
4000 >>> SRem(x, y)
4001 SRem(x, y)
4002 >>> SRem(x, y).sort()
4003 BitVec(32)
4004 >>> (x % y).sexpr()
4005 '(bvsmod x y)'
4006 >>> SRem(x, y).sexpr()
4007 '(bvsrem x y)'
4008 """
4009 _check_bv_args(a, b)
4010 a, b = _coerce_exprs(a, b)
4011 return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4012
def SRem(a, b)
Definition: z3py.py:3993
def URem(a, b)
Definition: z3py.py:3973
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 z3py.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 10390 of file z3py.py.

10390def Star(re):
10391 """Create the regular expression accepting zero or more repetitions of argument.
10392 >>> re = Star(Re("a"))
10393 >>> print(simplify(InRe("aa", re)))
10394 True
10395 >>> print(simplify(InRe("ab", re)))
10396 False
10397 >>> print(simplify(InRe("", re)))
10398 True
10399 """
10400 return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10401
def Star(re)
Definition: z3py.py:10390
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.

Referenced by Star().

◆ Store()

def z3py.Store (   a,
  i,
  v 
)
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 4448 of file z3py.py.

4448def Store(a, i, v):
4449 """Return a Z3 store array expression.
4450
4451 >>> a = Array('a', IntSort(), IntSort())
4452 >>> i, v = Ints('i v')
4453 >>> s = Store(a, i, v)
4454 >>> s.sort()
4455 Array(Int, Int)
4456 >>> prove(s[i] == v)
4457 proved
4458 >>> j = Int('j')
4459 >>> prove(Implies(i != j, s[j] == a[j]))
4460 proved
4461 """
4462 return Update(a, i, v)
4463
def Update(a, i, v)
Definition: z3py.py:4416

Referenced by is_array(), is_store(), SetAdd(), SetDel(), and Store().

◆ String()

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

10085def String(name, ctx=None):
10086 """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10087
10088 >>> x = String('x')
10089 """
10090 ctx = _get_ctx(ctx)
10091 return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10092
def String(name, ctx=None)
Definition: z3py.py:10085

Referenced by Native.applyResultToString(), Native.astMapToString(), Native.astToString(), Native.astVectorToString(), Native.benchmarkToSmtlibString(), Context.Context(), Native.evalSmtlib2String(), Native.fixedpointGetHelp(), Native.fixedpointGetReasonUnknown(), Native.fixedpointToString(), Native.fpaGetNumeralExponentString(), Native.fpaGetNumeralSignificandString(), Native.funcDeclToString(), Native.getDeclRationalParameter(), Statistics.getEntries(), Native.getErrorMsg(), Native.getFullVersion(), Statistics.getKeys(), Native.getLstring(), Native.getNumeralDecimalString(), Native.getNumeralString(), Native.getProbeName(), Context.getProbeNames(), Native.getString(), Native.getSymbolString(), Native.getTacticName(), Context.getTacticNames(), Native.goalToDimacsString(), Native.goalToString(), Native.modelToString(), Native.optimizeGetHelp(), Native.optimizeGetReasonUnknown(), Native.optimizeToString(), Native.paramDescrsGetDocumentation(), Native.paramDescrsToString(), Native.paramsToString(), Native.patternToString(), Native.probeGetDescr(), Native.rcfNumToDecimalString(), Native.rcfNumToString(), Native.simplifyGetHelp(), Native.solverGetHelp(), Native.solverGetReasonUnknown(), Native.solverToDimacsString(), Native.solverToString(), Native.sortToString(), Native.statsGetKey(), Native.statsToString(), String(), Strings(), SubSeq(), Native.tacticGetDescr(), Native.tacticGetHelp(), and FuncInterp.toString().

◆ Strings()

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

Definition at line 10093 of file z3py.py.

10093def Strings(names, ctx=None):
10094 """Return string constants"""
10095 ctx = _get_ctx(ctx)
10096 if isinstance(names, str):
10097 names = names.split(" ")
10098 return [String(name, ctx) for name in names]
10099

Referenced by Contains().

◆ StringSort()

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

Definition at line 9970 of file z3py.py.

9970def StringSort(ctx=None):
9971 """Create a string sort
9972 >>> s = StringSort()
9973 >>> print(s)
9974 String
9975 """
9976 ctx = _get_ctx(ctx)
9977 return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
9978
9979

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

◆ StringVal()

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

Definition at line 10080 of file z3py.py.

10080def StringVal(s, ctx=None):
10081 """create a string expression"""
10082 ctx = _get_ctx(ctx)
10083 return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10084
Z3_ast Z3_API Z3_mk_lstring(Z3_context c, unsigned len, Z3_string s)
Create a string constant out of the string that is passed in It takes the length of the string as wel...

Referenced by SeqRef.__gt__(), Empty(), Extract(), is_seq(), is_string(), is_string_value(), Length(), and Re().

◆ StrToInt()

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

10251def StrToInt(s):
10252 """Convert string expression to integer
10253 >>> a = StrToInt("1")
10254 >>> simplify(1 == a)
10255 True
10256 >>> b = StrToInt("2")
10257 >>> simplify(1 == b)
10258 False
10259 >>> c = StrToInt(IntToStr(2))
10260 >>> simplify(1 == c)
10261 False
10262 """
10263 s = _coerce_seq(s)
10264 return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10265
10266
def StrToInt(s)
Definition: z3py.py:10251
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.

Referenced by StrToInt().

◆ SubSeq()

def z3py.SubSeq (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 10104 of file z3py.py.

10104def SubSeq(s, offset, length):
10105 """Extract substring or subsequence starting at offset"""
10106 return Extract(s, offset, length)
10107
def SubSeq(s, offset, length)
Definition: z3py.py:10104

◆ substitute()

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

8214def substitute(t, *m):
8215 """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.
8216
8217 >>> x = Int('x')
8218 >>> y = Int('y')
8219 >>> substitute(x + 1, (x, y + 1))
8220 y + 1 + 1
8221 >>> f = Function('f', IntSort(), IntSort())
8222 >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8223 1 + 1
8224 """
8225 if isinstance(m, tuple):
8226 m1 = _get_args(m)
8227 if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8228 m = m1
8229 if z3_debug():
8230 _z3_assert(is_expr(t), "Z3 expression expected")
8231 _z3_assert(all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) and p[0].sort().eq(p[1].sort()) for p in m]), "Z3 invalid substitution, expression pairs expected.")
8232 num = len(m)
8233 _from = (Ast * num)()
8234 _to = (Ast * num)()
8235 for i in range(num):
8236 _from[i] = m[i][0].as_ast()
8237 _to[i] = m[i][1].as_ast()
8238 return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8239
def substitute(t, *m)
Definition: z3py.py:8214
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_vars()

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

8240def substitute_vars(t, *m):
8241 """Substitute the free variables in t with the expression in m.
8242
8243 >>> v0 = Var(0, IntSort())
8244 >>> v1 = Var(1, IntSort())
8245 >>> x = Int('x')
8246 >>> f = Function('f', IntSort(), IntSort(), IntSort())
8247 >>> # replace v0 with x+1 and v1 with x
8248 >>> substitute_vars(f(v0, v1), x + 1, x)
8249 f(x + 1, x)
8250 """
8251 if z3_debug():
8252 _z3_assert(is_expr(t), "Z3 expression expected")
8253 _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8254 num = len(m)
8255 _to = (Ast * num)()
8256 for i in range(num):
8257 _to[i] = m[i].as_ast()
8258 return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8259
def substitute_vars(t, *m)
Definition: z3py.py:8240
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the free variables in a with the expressions in to. For every i smaller than num_exprs,...

Referenced by substitute_vars().

◆ SubString()

def z3py.SubString (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 10100 of file z3py.py.

10100def SubString(s, offset, length):
10101 """Extract substring or subsequence starting at offset"""
10102 return Extract(s, offset, length)
10103
def SubString(s, offset, length)
Definition: z3py.py:10100

◆ SuffixOf()

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

10166def SuffixOf(a, b):
10167 """Check if 'a' is a suffix of 'b'
10168 >>> s1 = SuffixOf("ab", "abc")
10169 >>> simplify(s1)
10170 False
10171 >>> s2 = SuffixOf("bc", "abc")
10172 >>> simplify(s2)
10173 True
10174 """
10175 ctx = _get_ctx2(a, b)
10176 a = _coerce_seq(a, ctx)
10177 b = _coerce_seq(b, ctx)
10178 return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10179
def SuffixOf(a, b)
Definition: z3py.py:10166
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 z3py.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 8260 of file z3py.py.

8260def Sum(*args):
8261 """Create the sum of the Z3 expressions.
8262
8263 >>> a, b, c = Ints('a b c')
8264 >>> Sum(a, b, c)
8265 a + b + c
8266 >>> Sum([a, b, c])
8267 a + b + c
8268 >>> A = IntVector('a', 5)
8269 >>> Sum(A)
8270 a__0 + a__1 + a__2 + a__3 + a__4
8271 """
8272 args = _get_args(args)
8273 if len(args) == 0:
8274 return 0
8275 ctx = _ctx_from_ast_arg_list(args)
8276 if ctx is None:
8277 return _reduce(lambda a, b: a + b, args, 0)
8278 args = _coerce_expr_list(args, ctx)
8279 if is_bv(args[0]):
8280 return _reduce(lambda a, b: a + b, args, 0)
8281 else:
8282 _args, sz = _to_ast_array(args)
8283 return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8284
8285
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 z3py.tactic_description (   name,
  ctx = None 
)
Return a short description for the tactic named `name`.

>>> d = tactic_description('simplify')

Definition at line 7897 of file z3py.py.

7897def tactic_description(name, ctx=None):
7898 """Return a short description for the tactic named `name`.
7899
7900 >>> d = tactic_description('simplify')
7901 """
7902 ctx = _get_ctx(ctx)
7903 return Z3_tactic_get_descr(ctx.ref(), name)
7904
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 z3py.tactics (   ctx = None)
Return a list of all available tactics in Z3.

>>> l = tactics()
>>> l.count('simplify') == 1
True

Definition at line 7887 of file z3py.py.

7887def tactics(ctx=None):
7888 """Return a list of all available tactics in Z3.
7889
7890 >>> l = tactics()
7891 >>> l.count('simplify') == 1
7892 True
7893 """
7894 ctx = _get_ctx(ctx)
7895 return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7896
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 z3py.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 7766 of file z3py.py.

7766def Then(*ts, **ks):
7767 """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7768
7769 >>> x, y = Ints('x y')
7770 >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7771 >>> t(And(x == 0, y > x + 1))
7772 [[Not(y <= 1)]]
7773 >>> t(And(x == 0, y > x + 1)).as_expr()
7774 Not(y <= 1)
7775 """
7776 return AndThen(*ts, **ks)
7777

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

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

Definition at line 109 of file z3py.py.

109def to_symbol(s, ctx=None):
110 """Convert an integer or string into a Z3 symbol."""
111 if _is_int(s):
112 return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
113 else:
114 return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
115
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 Fixedpoint.add_rule(), Optimize.add_soft(), Array(), BitVec(), Bool(), Const(), CreateDatatypes(), DeclareSort(), EnumSort(), FiniteDomainSort(), FP(), Function(), ParamDescrsRef.get_documentation(), ParamDescrsRef.get_kind(), Int(), is_quantifier(), prove(), Real(), RecFunction(), ParamsRef.set(), Fixedpoint.set_predicate_representation(), SolverFor(), String(), and Fixedpoint.update_rule().

◆ ToInt()

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

3127def ToInt(a):
3128 """ Return the Z3 expression ToInt(a).
3129
3130 >>> x = Real('x')
3131 >>> x.sort()
3132 Real
3133 >>> n = ToInt(x)
3134 >>> n
3135 ToInt(x)
3136 >>> n.sort()
3137 Int
3138 """
3139 if z3_debug():
3140 _z3_assert(a.is_real(), "Z3 real expression expected.")
3141 ctx = a.ctx
3142 return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3143
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 z3py.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 3110 of file z3py.py.

3110def ToReal(a):
3111 """ Return the Z3 expression ToReal(a).
3112
3113 >>> x = Int('x')
3114 >>> x.sort()
3115 Int
3116 >>> n = ToReal(x)
3117 >>> n
3118 ToReal(x)
3119 >>> n.sort()
3120 Real
3121 """
3122 if z3_debug():
3123 _z3_assert(a.is_int(), "Z3 integer expression expected.")
3124 ctx = a.ctx
3125 return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3126
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 z3py.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 10440 of file z3py.py.

10440def TransitiveClosure(f):
10441 """Given a binary relation R, such that the two arguments have the same sort
10442 create the transitive closure relation R+.
10443 The transitive closure R+ is a new relation.
10444 """
10445 return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
def TransitiveClosure(f)
Definition: z3py.py:10440
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.

◆ TreeOrder()

def z3py.TreeOrder (   a,
  index 
)

Definition at line 10434 of file z3py.py.

10434def TreeOrder(a, index):
10435 return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10436
def TreeOrder(a, index)
Definition: z3py.py:10434
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 z3py.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 7879 of file z3py.py.

7879def TryFor(t, ms, ctx=None):
7880 """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7881
7882 If `t` does not terminate in `ms` milliseconds, then it fails.
7883 """
7884 t = _to_tactic(t, ctx)
7885 return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7886
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7879
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 z3py.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 4971 of file z3py.py.

4971def TupleSort(name, sorts, ctx = None):
4972 """Create a named tuple sort base on a set of underlying sorts
4973 Example:
4974 >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
4975 """
4976 tuple = Datatype(name, ctx)
4977 projects = [ ('project%d' % i, sorts[i]) for i in range(len(sorts)) ]
4978 tuple.declare(name, *projects)
4979 tuple = tuple.create()
4980 return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
4981
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:4971

Referenced by Context.mkTupleSort(), and TupleSort().

◆ UDiv()

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

3953def UDiv(a, b):
3954 """Create the Z3 expression (unsigned) division `self / other`.
3955
3956 Use the operator / for signed division.
3957
3958 >>> x = BitVec('x', 32)
3959 >>> y = BitVec('y', 32)
3960 >>> UDiv(x, y)
3961 UDiv(x, y)
3962 >>> UDiv(x, y).sort()
3963 BitVec(32)
3964 >>> (x / y).sexpr()
3965 '(bvsdiv x y)'
3966 >>> UDiv(x, y).sexpr()
3967 '(bvudiv x y)'
3968 """
3969 _check_bv_args(a, b)
3970 a, b = _coerce_exprs(a, b)
3971 return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3972
def UDiv(a, b)
Definition: z3py.py:3953
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 z3py.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 3919 of file z3py.py.

3919def UGE(a, b):
3920 """Create the Z3 expression (unsigned) `other >= self`.
3921
3922 Use the operator >= for signed greater than or equal to.
3923
3924 >>> x, y = BitVecs('x y', 32)
3925 >>> UGE(x, y)
3926 UGE(x, y)
3927 >>> (x >= y).sexpr()
3928 '(bvsge x y)'
3929 >>> UGE(x, y).sexpr()
3930 '(bvuge x y)'
3931 """
3932 _check_bv_args(a, b)
3933 a, b = _coerce_exprs(a, b)
3934 return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3935
def UGE(a, b)
Definition: z3py.py:3919
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 z3py.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 3936 of file z3py.py.

3936def UGT(a, b):
3937 """Create the Z3 expression (unsigned) `other > self`.
3938
3939 Use the operator > for signed greater than.
3940
3941 >>> x, y = BitVecs('x y', 32)
3942 >>> UGT(x, y)
3943 UGT(x, y)
3944 >>> (x > y).sexpr()
3945 '(bvsgt x y)'
3946 >>> UGT(x, y).sexpr()
3947 '(bvugt x y)'
3948 """
3949 _check_bv_args(a, b)
3950 a, b = _coerce_exprs(a, b)
3951 return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3952
def UGT(a, b)
Definition: z3py.py:3936
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 z3py.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 3885 of file z3py.py.

3885def ULE(a, b):
3886 """Create the Z3 expression (unsigned) `other <= self`.
3887
3888 Use the operator <= for signed less than or equal to.
3889
3890 >>> x, y = BitVecs('x y', 32)
3891 >>> ULE(x, y)
3892 ULE(x, y)
3893 >>> (x <= y).sexpr()
3894 '(bvsle x y)'
3895 >>> ULE(x, y).sexpr()
3896 '(bvule x y)'
3897 """
3898 _check_bv_args(a, b)
3899 a, b = _coerce_exprs(a, b)
3900 return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3901
def ULE(a, b)
Definition: z3py.py:3885
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 z3py.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 3902 of file z3py.py.

3902def ULT(a, b):
3903 """Create the Z3 expression (unsigned) `other < self`.
3904
3905 Use the operator < for signed less than.
3906
3907 >>> x, y = BitVecs('x y', 32)
3908 >>> ULT(x, y)
3909 ULT(x, y)
3910 >>> (x < y).sexpr()
3911 '(bvslt x y)'
3912 >>> ULT(x, y).sexpr()
3913 '(bvult x y)'
3914 """
3915 _check_bv_args(a, b)
3916 a, b = _coerce_exprs(a, b)
3917 return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3918
def ULT(a, b)
Definition: z3py.py:3902
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 z3py.Union ( args)
Create union of regular expressions.
>>> re = Union(Re("a"), Re("b"), Re("c"))
>>> print (simplify(InRe("d", re)))
False

Definition at line 10326 of file z3py.py.

10326def Union(*args):
10327 """Create union of regular expressions.
10328 >>> re = Union(Re("a"), Re("b"), Re("c"))
10329 >>> print (simplify(InRe("d", re)))
10330 False
10331 """
10332 args = _get_args(args)
10333 sz = len(args)
10334 if z3_debug():
10335 _z3_assert(sz > 0, "At least one argument expected.")
10336 _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10337 if sz == 1:
10338 return args[0]
10339 ctx = args[0].ctx
10340 v = (Ast * sz)()
10341 for i in range(sz):
10342 v[i] = args[i].as_ast()
10343 return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10344
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 z3py.Unit (   a)
Create a singleton sequence

Definition at line 10148 of file z3py.py.

10148def Unit(a):
10149 """Create a singleton sequence"""
10150 return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10151
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 z3py.Update (   a,
  i,
  v 
)
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 4416 of file z3py.py.

4416def Update(a, i, v):
4417 """Return a Z3 store array expression.
4418
4419 >>> a = Array('a', IntSort(), IntSort())
4420 >>> i, v = Ints('i v')
4421 >>> s = Update(a, i, v)
4422 >>> s.sort()
4423 Array(Int, Int)
4424 >>> prove(s[i] == v)
4425 proved
4426 >>> j = Int('j')
4427 >>> prove(Implies(i != j, s[j] == a[j]))
4428 proved
4429 """
4430 if z3_debug():
4431 _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4432 i = a.domain().cast(i)
4433 v = a.range().cast(v)
4434 ctx = a.ctx
4435 return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4436
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.

Referenced by Store(), and Update().

◆ URem()

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

3973def URem(a, b):
3974 """Create the Z3 expression (unsigned) remainder `self % other`.
3975
3976 Use the operator % for signed modulus, and SRem() for signed remainder.
3977
3978 >>> x = BitVec('x', 32)
3979 >>> y = BitVec('y', 32)
3980 >>> URem(x, y)
3981 URem(x, y)
3982 >>> URem(x, y).sort()
3983 BitVec(32)
3984 >>> (x % y).sexpr()
3985 '(bvsmod x y)'
3986 >>> URem(x, y).sexpr()
3987 '(bvurem x y)'
3988 """
3989 _check_bv_args(a, b)
3990 a, b = _coerce_exprs(a, b)
3991 return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3992
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().

◆ Var()

def z3py.Var (   idx,
  s 
)
Create a Z3 free variable. Free variables are used to create quantified formulas.

>>> Var(0, IntSort())
Var(0)
>>> eq(Var(0, IntSort()), Var(0, BoolSort()))
False

Definition at line 1331 of file z3py.py.

1331def Var(idx, s):
1332 """Create a Z3 free variable. Free variables are used to create quantified formulas.
1333
1334 >>> Var(0, IntSort())
1335 Var(0)
1336 >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1337 False
1338 """
1339 if z3_debug():
1340 _z3_assert(is_sort(s), "Z3 sort expected")
1341 return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1342
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a bound 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 z3py.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 8148 of file z3py.py.

8148def When(p, t, ctx=None):
8149 """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8150
8151 >>> t = When(Probe('size') > 2, Tactic('simplify'))
8152 >>> x, y = Ints('x y')
8153 >>> g = Goal()
8154 >>> g.add(x > 0)
8155 >>> g.add(y > 0)
8156 >>> t(g)
8157 [[x > 0, y > 0]]
8158 >>> g.add(x == y + 1)
8159 >>> t(g)
8160 [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8161 """
8162 p = _to_probe(p, ctx)
8163 t = _to_tactic(t, ctx)
8164 return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8165
def When(p, t, ctx=None)
Definition: z3py.py:8148
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 z3py.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 7834 of file z3py.py.

7834def With(t, *args, **keys):
7835 """Return a tactic that applies tactic `t` using the given configuration options.
7836
7837 >>> x, y = Ints('x y')
7838 >>> t = With(Tactic('simplify'), som=True)
7839 >>> t((x + 1)*(y + 2) == 0)
7840 [[2*x + y + x*y == -2]]
7841 """
7842 ctx = keys.pop('ctx', None)
7843 t = _to_tactic(t, ctx)
7844 p = args2params(args, keys, t.ctx)
7845 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7846
def With(t, *args, **keys)
Definition: z3py.py:7834
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 z3py.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 7847 of file z3py.py.

7847def WithParams(t, p):
7848 """Return a tactic that applies tactic `t` using the given configuration options.
7849
7850 >>> x, y = Ints('x y')
7851 >>> p = ParamsRef()
7852 >>> p.set("som", True)
7853 >>> t = WithParams(Tactic('simplify'), p)
7854 >>> t((x + 1)*(y + 2) == 0)
7855 [[2*x + y + x*y == -2]]
7856 """
7857 t = _to_tactic(t, None)
7858 return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7859
def WithParams(t, p)
Definition: z3py.py:7847

Referenced by WithParams().

◆ Xor()

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

1634def Xor(a, b, ctx=None):
1635 """Create a Z3 Xor expression.
1636
1637 >>> p, q = Bools('p q')
1638 >>> Xor(p, q)
1639 Xor(p, q)
1640 >>> simplify(Xor(p, q))
1641 Not(p) == q
1642 """
1643 ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1644 s = BoolSort(ctx)
1645 a = s.cast(a)
1646 b = s.cast(b)
1647 return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1648
def Xor(a, b, ctx=None)
Definition: z3py.py:1634
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 z3py.z3_debug ( )

Definition at line 56 of file z3py.py.

56def z3_debug():
57 global Z3_DEBUG
58 return Z3_DEBUG
59

Referenced by FuncDeclRef.__call__(), Probe.__call__(), QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), DatatypeSortRef.accessor(), And(), AndThen(), Tactic.apply(), ExprRef.arg(), args2params(), ArraySort(), AlgebraicNumRef.as_decimal(), IntNumRef.as_long(), AtLeast(), AtMost(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), ExprRef.children(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), describe_probes(), Distinct(), FuncDeclRef.domain(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FiniteDomainVal(), fpIsPositive(), fpNeg(), FPSort(), fpToFPUnsigned(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), Intersect(), is_quantifier(), is_sort(), IsInt(), K(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), OrElse(), Tactic.param_descrs(), ParOr(), ParThen(), QuantifierRef.pattern(), prove(), RatVal(), RealSort(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), simplify(), solve_using(), substitute(), 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 z3py.z3_error_handler (   c,
  e 
)

Definition at line 156 of file z3py.py.

156def z3_error_handler(c, e):
157 # Do nothing error handler, just avoid exit(0)
158 # The wrappers in z3core.py will raise a Z3Exception if an error is detected
159 return
160
def z3_error_handler(c, e)
Definition: z3py.py:156

◆ ZeroExt()

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

4103def ZeroExt(n, a):
4104 """Return a bit-vector expression with `n` extra zero-bits.
4105
4106 >>> x = BitVec('x', 16)
4107 >>> n = ZeroExt(8, x)
4108 >>> n.size()
4109 24
4110 >>> n
4111 ZeroExt(8, x)
4112 >>> n.sort()
4113 BitVec(24)
4114 >>> v0 = BitVecVal(2, 2)
4115 >>> v0
4116 2
4117 >>> v0.size()
4118 2
4119 >>> v = simplify(ZeroExt(6, v0))
4120 >>> v
4121 2
4122 >>> v.size()
4123 8
4124 """
4125 if z3_debug():
4126 _z3_assert(_is_int(n), "First argument must be an integer")
4127 _z3_assert(is_bv(a), "Second argument must be a Z3 Bitvector expression")
4128 return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4129
def ZeroExt(n, a)
Definition: z3py.py:4103
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

◆ sat

Definition at line 6432 of file z3py.py.

◆ unknown

Definition at line 6434 of file z3py.py.

◆ unsat

Definition at line 6433 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 54 of file z3py.py.