Z3
Data Structures | Functions | Variables
z3py Namespace Reference

Data Structures

class  Context
 
class  Z3PPObject
 ASTs base class. More...
 
class  AstRef
 
class  SortRef
 
class  FuncDeclRef
 Function Declarations. More...
 
class  ExprRef
 Expressions. More...
 
class  BoolSortRef
 Booleans. More...
 
class  BoolRef
 
class  PatternRef
 Patterns. More...
 
class  QuantifierRef
 Quantifiers. More...
 
class  ArithSortRef
 Arithmetic. More...
 
class  ArithRef
 
class  IntNumRef
 
class  RatNumRef
 
class  AlgebraicNumRef
 
class  BitVecSortRef
 Bit-Vectors. More...
 
class  BitVecRef
 
class  BitVecNumRef
 
class  ArraySortRef
 Arrays. More...
 
class  ArrayRef
 
class  Datatype
 
class  ScopedConstructor
 
class  ScopedConstructorList
 
class  DatatypeSortRef
 
class  DatatypeRef
 
class  ParamsRef
 Parameter Sets. More...
 
class  ParamDescrsRef
 
class  Goal
 
class  AstVector
 
class  AstMap
 
class  FuncEntry
 
class  FuncInterp
 
class  ModelRef
 
class  Statistics
 Statistics. More...
 
class  CheckSatResult
 
class  Solver
 
class  Fixedpoint
 Fixedpoint. More...
 
class  FiniteDomainSortRef
 
class  FiniteDomainRef
 
class  FiniteDomainNumRef
 
class  OptimizeObjective
 Optimize. More...
 
class  Optimize
 
class  ApplyResult
 
class  Tactic
 
class  Probe
 
class  FPSortRef
 FP Sorts. More...
 
class  FPRMSortRef
 
class  FPRef
 FP Expressions. More...
 
class  FPRMRef
 
class  FPNumRef
 FP Numerals. More...
 
class  SeqSortRef
 Strings, Sequences and Regular expressions. More...
 
class  SeqRef
 
class  ReSortRef
 Regular expressions. More...
 
class  ReRef
 
class  PropClosures
 
class  UserPropagateBase
 

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 FreshFunction (*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)
 
def ensure_prop_closures ()
 
def user_prop_push (ctx)
 
def user_prop_pop (ctx, num_scopes)
 
def user_prop_fresh (id, ctx)
 
def user_prop_fixed (ctx, cb, id, value)
 
def user_prop_final (ctx, cb)
 
def user_prop_eq (ctx, cb, x, y)
 
def user_prop_diseq (ctx, cb, x, y)
 

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

1700 def And(*args):
1701  """Create a Z3 and-expression or and-probe.
1702 
1703  >>> p, q, r = Bools('p q r')
1704  >>> And(p, q, r)
1705  And(p, q, r)
1706  >>> P = BoolVector('p', 5)
1707  >>> And(P)
1708  And(p__0, p__1, p__2, p__3, p__4)
1709  """
1710  last_arg = None
1711  if len(args) > 0:
1712  last_arg = args[len(args)-1]
1713  if isinstance(last_arg, Context):
1714  ctx = args[len(args)-1]
1715  args = args[:len(args)-1]
1716  elif len(args) == 1 and isinstance(args[0], AstVector):
1717  ctx = args[0].ctx
1718  args = [a for a in args[0]]
1719  else:
1720  ctx = None
1721  args = _get_args(args)
1722  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1723  if z3_debug():
1724  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1725  if _has_probe(args):
1726  return _probe_and(args, ctx)
1727  else:
1728  args = _coerce_expr_list(args, ctx)
1729  _args, sz = _to_ast_array(args)
1730  return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1731 
def z3_debug()
Definition: z3py.py:56
def And(*args)
Definition: z3py.py:1700
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 Fixedpoint.add_rule(), Goal.as_expr(), Fixedpoint.query(), Fixedpoint.query_from_lvl(), 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 7789 of file z3py.py.

7789 def AndThen(*ts, **ks):
7790  """Return a tactic that applies the tactics in `*ts` in sequence.
7791 
7792  >>> x, y = Ints('x y')
7793  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7794  >>> t(And(x == 0, y > x + 1))
7795  [[Not(y <= 1)]]
7796  >>> t(And(x == 0, y > x + 1)).as_expr()
7797  Not(y <= 1)
7798  """
7799  if z3_debug():
7800  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7801  ctx = ks.get('ctx', None)
7802  num = len(ts)
7803  r = ts[0]
7804  for i in range(num - 1):
7805  r = _and_then(r, ts[i+1], ctx)
7806  return r
7807 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3515
def AndThen(*ts, **ks)
Definition: z3py.py:7789

Referenced by Then().

◆ append_log()

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

Definition at line 105 of file z3py.py.

105 def append_log(s):
106  """Append user-defined string to interaction log. """
107  Z3_append_log(s)
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 5111 of file z3py.py.

5111 def args2params(arguments, keywords, ctx=None):
5112  """Convert python arguments into a Z3_params object.
5113  A ':' is added to the keywords, and '_' is replaced with '-'
5114 
5115  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5116  (params model true relevancy 2 elim_and true)
5117  """
5118  if z3_debug():
5119  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5120  prev = None
5121  r = ParamsRef(ctx)
5122  for a in arguments:
5123  if prev is None:
5124  prev = a
5125  else:
5126  r.set(prev, a)
5127  prev = None
5128  for k in keywords:
5129  v = keywords[k]
5130  r.set(k, v)
5131  return r
5132 
def args2params(arguments, keywords, ctx=None)
Definition: z3py.py:5111

Referenced by Tactic.apply(), 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 4444 of file z3py.py.

4444 def Array(name, dom, rng):
4445  """Return an array constant named `name` with the given domain and range sorts.
4446 
4447  >>> a = Array('a', IntSort(), IntSort())
4448  >>> a.sort()
4449  Array(Int, Int)
4450  >>> a[0]
4451  a[0]
4452  """
4453  s = ArraySort(dom, rng)
4454  ctx = s.ctx
4455  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4456 
def ArraySort(*sig)
Definition: z3py.py:4412
def to_symbol(s, ctx=None)
Definition: z3py.py:109
def Array(name, dom, rng)
Definition: z3py.py:4444
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.

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

4412 def ArraySort(*sig):
4413  """Return the Z3 array sort with the given domain and range sorts.
4414 
4415  >>> A = ArraySort(IntSort(), BoolSort())
4416  >>> A
4417  Array(Int, Bool)
4418  >>> A.domain()
4419  Int
4420  >>> A.range()
4421  Bool
4422  >>> AA = ArraySort(IntSort(), A)
4423  >>> AA
4424  Array(Int, Array(Int, Bool))
4425  """
4426  sig = _get_args(sig)
4427  if z3_debug():
4428  _z3_assert(len(sig) > 1, "At least two arguments expected")
4429  arity = len(sig) - 1
4430  r = sig[arity]
4431  d = sig[0]
4432  if z3_debug():
4433  for s in sig:
4434  _z3_assert(is_sort(s), "Z3 sort expected")
4435  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4436  ctx = d.ctx
4437  if len(sig) == 2:
4438  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4439  dom = (Sort * arity)()
4440  for i in range(arity):
4441  dom[i] = sig[i].ast
4442  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4443 
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(), 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 8370 of file z3py.py.

8370 def AtLeast(*args):
8371  """Create an at-most Pseudo-Boolean k constraint.
8372 
8373  >>> a, b, c = Bools('a b c')
8374  >>> f = AtLeast(a, b, c, 2)
8375  """
8376  args = _get_args(args)
8377  if z3_debug():
8378  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8379  ctx = _ctx_from_ast_arg_list(args)
8380  if z3_debug():
8381  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8382  args1 = _coerce_expr_list(args[:-1], ctx)
8383  k = args[-1]
8384  _args, sz = _to_ast_array(args1)
8385  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8386 
def AtLeast(*args)
Definition: z3py.py:8370
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.

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

8353 def AtMost(*args):
8354  """Create an at-most Pseudo-Boolean k constraint.
8355 
8356  >>> a, b, c = Bools('a b c')
8357  >>> f = AtMost(a, b, c, 2)
8358  """
8359  args = _get_args(args)
8360  if z3_debug():
8361  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8362  ctx = _ctx_from_ast_arg_list(args)
8363  if z3_debug():
8364  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8365  args1 = _coerce_expr_list(args[:-1], ctx)
8366  k = args[-1]
8367  _args, sz = _to_ast_array(args1)
8368  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8369 
def AtMost(*args)
Definition: z3py.py:8353
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.

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

3811 def BitVec(name, bv, ctx=None):
3812  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
3813  If `ctx=None`, then the global context is used.
3814 
3815  >>> x = BitVec('x', 16)
3816  >>> is_bv(x)
3817  True
3818  >>> x.size()
3819  16
3820  >>> x.sort()
3821  BitVec(16)
3822  >>> word = BitVecSort(16)
3823  >>> x2 = BitVec('x', word)
3824  >>> eq(x, x2)
3825  True
3826  """
3827  if isinstance(bv, BitVecSortRef):
3828  ctx = bv.ctx
3829  else:
3830  ctx = _get_ctx(ctx)
3831  bv = BitVecSort(bv, ctx)
3832  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
3833 
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3811
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3781

Referenced by BitVecs().

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

3834 def BitVecs(names, bv, ctx=None):
3835  """Return a tuple of bit-vector constants of size bv.
3836 
3837  >>> x, y, z = BitVecs('x y z', 16)
3838  >>> x.size()
3839  16
3840  >>> x.sort()
3841  BitVec(16)
3842  >>> Sum(x, y, z)
3843  0 + x + y + z
3844  >>> Product(x, y, z)
3845  1*x*y*z
3846  >>> simplify(Product(x, y, z))
3847  x*y*z
3848  """
3849  ctx = _get_ctx(ctx)
3850  if isinstance(names, str):
3851  names = names.split(" ")
3852  return [BitVec(name, bv, ctx) for name in names]
3853 
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3834

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

3781 def BitVecSort(sz, ctx=None):
3782  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3783 
3784  >>> Byte = BitVecSort(8)
3785  >>> Word = BitVecSort(16)
3786  >>> Byte
3787  BitVec(8)
3788  >>> x = Const('x', Byte)
3789  >>> eq(x, BitVec('x', 8))
3790  True
3791  """
3792  ctx = _get_ctx(ctx)
3793  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
3794 
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.

Referenced by BitVec(), and BitVecVal().

◆ BitVecVal()

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

3795 def BitVecVal(val, bv, ctx=None):
3796  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
3797 
3798  >>> v = BitVecVal(10, 32)
3799  >>> v
3800  10
3801  >>> print("0x%.8x" % v.as_long())
3802  0x0000000a
3803  """
3804  if is_bv_sort(bv):
3805  ctx = bv.ctx
3806  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
3807  else:
3808  ctx = _get_ctx(ctx)
3809  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
3810 
def is_bv_sort(s)
Definition: z3py.py:3259
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3795
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.

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

1588 def Bool(name, ctx=None):
1589  """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1590 
1591  >>> p = Bool('p')
1592  >>> q = Bool('q')
1593  >>> And(p, q)
1594  And(p, q)
1595  """
1596  ctx = _get_ctx(ctx)
1597  return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1598 
def BoolSort(ctx=None)
Definition: z3py.py:1553
def Bool(name, ctx=None)
Definition: z3py.py:1588

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

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

1599 def Bools(names, ctx=None):
1600  """Return a tuple of Boolean constants.
1601 
1602  `names` is a single string containing all names separated by blank spaces.
1603  If `ctx=None`, then the global context is used.
1604 
1605  >>> p, q, r = Bools('p q r')
1606  >>> And(p, Or(q, r))
1607  And(p, Or(q, r))
1608  """
1609  ctx = _get_ctx(ctx)
1610  if isinstance(names, str):
1611  names = names.split(" ")
1612  return [Bool(name, ctx) for name in names]
1613 
def Bools(names, ctx=None)
Definition: z3py.py:1599

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

1553 def BoolSort(ctx=None):
1554  """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1555 
1556  >>> BoolSort()
1557  Bool
1558  >>> p = Const('p', BoolSort())
1559  >>> is_bool(p)
1560  True
1561  >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1562  >>> r(0, 1)
1563  r(0, 1)
1564  >>> is_bool(r(0, 1))
1565  True
1566  """
1567  ctx = _get_ctx(ctx)
1568  return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1569 
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.

Referenced by Goal.assert_exprs(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), Bool(), Solver.check(), FreshBool(), If(), Implies(), Not(), SetSort(), QuantifierRef.sort(), 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 1570 of file z3py.py.

1570 def BoolVal(val, ctx=None):
1571  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1572 
1573  >>> BoolVal(True)
1574  True
1575  >>> is_true(BoolVal(True))
1576  True
1577  >>> is_true(True)
1578  False
1579  >>> is_false(BoolVal(False))
1580  True
1581  """
1582  ctx = _get_ctx(ctx)
1583  if val == False:
1584  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1585  else:
1586  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1587 
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
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 Goal.as_expr(), ApplyResult.as_expr(), BoolSortRef.cast(), UserPropagateBase.conflict(), AlgebraicNumRef.index(), is_quantifier(), 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 1614 of file z3py.py.

1614 def BoolVector(prefix, sz, ctx=None):
1615  """Return a list of Boolean constants of size `sz`.
1616 
1617  The constants are named using the given prefix.
1618  If `ctx=None`, then the global context is used.
1619 
1620  >>> P = BoolVector('p', 3)
1621  >>> P
1622  [p__0, p__1, p__2]
1623  >>> And(P)
1624  And(p__0, p__1, p__2)
1625  """
1626  return [ Bool('%s__%s' % (prefix, i)) for i in range(sz) ]
1627 
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1614

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

3751 def BV2Int(a, is_signed=False):
3752  """Return the Z3 expression BV2Int(a).
3753 
3754  >>> b = BitVec('b', 3)
3755  >>> BV2Int(b).sort()
3756  Int
3757  >>> x = Int('x')
3758  >>> x > BV2Int(b)
3759  x > BV2Int(b)
3760  >>> x > BV2Int(b, is_signed=False)
3761  x > BV2Int(b)
3762  >>> x > BV2Int(b, is_signed=True)
3763  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3764  >>> solve(x > BV2Int(b), b == 1, x < 3)
3765  [x = 2, b = 1]
3766  """
3767  if z3_debug():
3768  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3769  ctx = a.ctx
3770 
3771  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3772 
def is_bv(a)
Definition: z3py.py:3724
def BV2Int(a, is_signed=False)
Definition: z3py.py:3751
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast t1, bool is_signed)
Create an integer from the bit-vector argument t1. If is_signed is false, then the bit-vector t1 is t...

◆ BVAddNoOverflow()

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

Definition at line 4206 of file z3py.py.

4206 def BVAddNoOverflow(a, b, signed):
4207  """A predicate the determines that bit-vector addition does not overflow"""
4208  _check_bv_args(a, b)
4209  a, b = _coerce_exprs(a, b)
4210  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4211 
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4206
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 4212 of file z3py.py.

4212 def BVAddNoUnderflow(a, b):
4213  """A predicate the determines that signed bit-vector addition does not underflow"""
4214  _check_bv_args(a, b)
4215  a, b = _coerce_exprs(a, b)
4216  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4217 
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4212
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 4243 of file z3py.py.

4243 def BVMulNoOverflow(a, b, signed):
4244  """A predicate the determines that bit-vector multiplication does not overflow"""
4245  _check_bv_args(a, b)
4246  a, b = _coerce_exprs(a, b)
4247  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4248 
4249 
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4243
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 4250 of file z3py.py.

4250 def BVMulNoUnderflow(a, b):
4251  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4252  _check_bv_args(a, b)
4253  a, b = _coerce_exprs(a, b)
4254  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4255 
4256 
4257 
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4250
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 4194 of file z3py.py.

4194 def BVRedAnd(a):
4195  """Return the reduction-and expression of `a`."""
4196  if z3_debug():
4197  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4198  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4199 
def BVRedAnd(a)
Definition: z3py.py:4194
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 4200 of file z3py.py.

4200 def BVRedOr(a):
4201  """Return the reduction-or expression of `a`."""
4202  if z3_debug():
4203  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4204  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4205 
def BVRedOr(a)
Definition: z3py.py:4200
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 4231 of file z3py.py.

4231 def BVSDivNoOverflow(a, b):
4232  """A predicate the determines that bit-vector signed division does not overflow"""
4233  _check_bv_args(a, b)
4234  a, b = _coerce_exprs(a, b)
4235  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4236 
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4231
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 4237 of file z3py.py.

4237 def BVSNegNoOverflow(a):
4238  """A predicate the determines that bit-vector unary negation does not overflow"""
4239  if z3_debug():
4240  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4241  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4242 
def BVSNegNoOverflow(a)
Definition: z3py.py:4237
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 4218 of file z3py.py.

4218 def BVSubNoOverflow(a, b):
4219  """A predicate the determines that bit-vector subtraction does not overflow"""
4220  _check_bv_args(a, b)
4221  a, b = _coerce_exprs(a, b)
4222  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4223 
4224 
def BVSubNoOverflow(a, b)
Definition: z3py.py:4218
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 4225 of file z3py.py.

4225 def BVSubNoUnderflow(a, b, signed):
4226  """A predicate the determines that bit-vector subtraction does not underflow"""
4227  _check_bv_args(a, b)
4228  a, b = _coerce_exprs(a, b)
4229  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4230 
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4225
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 3209 of file z3py.py.

3209 def Cbrt(a, ctx=None):
3210  """ Return a Z3 expression which represents the cubic root of a.
3211 
3212  >>> x = Real('x')
3213  >>> Cbrt(x)
3214  x**(1/3)
3215  """
3216  if not is_expr(a):
3217  ctx = _get_ctx(ctx)
3218  a = RealVal(a, ctx)
3219  return a ** "1/3"
3220 
def is_expr(a)
Definition: z3py.py:1135
def Cbrt(a, ctx=None)
Definition: z3py.py:3209
def RealVal(val, ctx=None)
Definition: z3py.py:3000

◆ Complement()

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

Definition at line 10431 of file z3py.py.

10431 def Complement(re):
10432  """Create the complement regular expression."""
10433  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10434 
def Complement(re)
Definition: z3py.py:10431
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 3854 of file z3py.py.

3854 def Concat(*args):
3855  """Create a Z3 bit-vector concatenation expression.
3856 
3857  >>> v = BitVecVal(1, 4)
3858  >>> Concat(v, v+1, v)
3859  Concat(Concat(1, 1 + 1), 1)
3860  >>> simplify(Concat(v, v+1, v))
3861  289
3862  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
3863  121
3864  """
3865  args = _get_args(args)
3866  sz = len(args)
3867  if z3_debug():
3868  _z3_assert(sz >= 2, "At least two arguments expected.")
3869 
3870  ctx = None
3871  for a in args:
3872  if is_expr(a):
3873  ctx = a.ctx
3874  break
3875  if is_seq(args[0]) or isinstance(args[0], str):
3876  args = [_coerce_seq(s, ctx) for s in args]
3877  if z3_debug():
3878  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
3879  v = (Ast * sz)()
3880  for i in range(sz):
3881  v[i] = args[i].as_ast()
3882  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
3883 
3884  if is_re(args[0]):
3885  if z3_debug():
3886  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
3887  v = (Ast * sz)()
3888  for i in range(sz):
3889  v[i] = args[i].as_ast()
3890  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
3891 
3892  if z3_debug():
3893  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
3894  r = args[0]
3895  for i in range(sz - 1):
3896  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i+1].as_ast()), ctx)
3897  return r
3898 
def Concat(*args)
Definition: z3py.py:3854
def is_seq(a)
Definition: z3py.py:10099
def is_re(s)
Definition: z3py.py:10354
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__(), and SeqRef.__radd__().

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

8208 def Cond(p, t1, t2, ctx=None):
8209  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8210 
8211  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8212  """
8213  p = _to_probe(p, ctx)
8214  t1 = _to_tactic(t1, ctx)
8215  t2 = _to_tactic(t2, ctx)
8216  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8217 
def Cond(p, t1, t2, ctx=None)
Definition: z3py.py:8208
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...

Referenced by If().

◆ Const()

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

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

Definition at line 1321 of file z3py.py.

1321 def Const(name, sort):
1322  """Create a constant of the given sort.
1323 
1324  >>> Const('x', IntSort())
1325  x
1326  """
1327  if z3_debug():
1328  _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1329  ctx = sort.ctx
1330  return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1331 
def Const(name, sort)
Definition: z3py.py:1321

Referenced by Consts().

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

1332 def Consts(names, sort):
1333  """Create several constants of the given sort.
1334 
1335  `names` is a string containing the names of all constants to be created.
1336  Blank spaces separate the names of different constants.
1337 
1338  >>> x, y, z = Consts('x y z', IntSort())
1339  >>> x + y + z
1340  x + y + z
1341  """
1342  if isinstance(names, str):
1343  names = names.split(" ")
1344  return [Const(name, sort) for name in names]
1345 
def Consts(names, sort)
Definition: z3py.py:1332

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

10225 def Contains(a, b):
10226  """Check if 'a' contains 'b'
10227  >>> s1 = Contains("abc", "ab")
10228  >>> simplify(s1)
10229  True
10230  >>> s2 = Contains("abc", "bc")
10231  >>> simplify(s2)
10232  True
10233  >>> x, y, z = Strings('x y z')
10234  >>> s3 = Contains(Concat(x,y,z), y)
10235  >>> simplify(s3)
10236  True
10237  """
10238  ctx = _get_ctx2(a, b)
10239  a = _coerce_seq(a, ctx)
10240  b = _coerce_seq(b, ctx)
10241  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10242 
10243 
def Contains(a, b)
Definition: z3py.py:10225
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.

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

4823 def CreateDatatypes(*ds):
4824  """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
4825 
4826  In the following example we define a Tree-List using two mutually recursive datatypes.
4827 
4828  >>> TreeList = Datatype('TreeList')
4829  >>> Tree = Datatype('Tree')
4830  >>> # Tree has two constructors: leaf and node
4831  >>> Tree.declare('leaf', ('val', IntSort()))
4832  >>> # a node contains a list of trees
4833  >>> Tree.declare('node', ('children', TreeList))
4834  >>> TreeList.declare('nil')
4835  >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
4836  >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
4837  >>> Tree.val(Tree.leaf(10))
4838  val(leaf(10))
4839  >>> simplify(Tree.val(Tree.leaf(10)))
4840  10
4841  >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
4842  >>> n1
4843  node(cons(leaf(10), cons(leaf(20), nil)))
4844  >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
4845  >>> simplify(n2 == n1)
4846  False
4847  >>> simplify(TreeList.car(Tree.children(n2)) == n1)
4848  True
4849  """
4850  ds = _get_args(ds)
4851  if z3_debug():
4852  _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
4853  _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
4854  _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
4855  _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
4856  ctx = ds[0].ctx
4857  num = len(ds)
4858  names = (Symbol * num)()
4859  out = (Sort * num)()
4860  clists = (ConstructorList * num)()
4861  to_delete = []
4862  for i in range(num):
4863  d = ds[i]
4864  names[i] = to_symbol(d.name, ctx)
4865  num_cs = len(d.constructors)
4866  cs = (Constructor * num_cs)()
4867  for j in range(num_cs):
4868  c = d.constructors[j]
4869  cname = to_symbol(c[0], ctx)
4870  rname = to_symbol(c[1], ctx)
4871  fs = c[2]
4872  num_fs = len(fs)
4873  fnames = (Symbol * num_fs)()
4874  sorts = (Sort * num_fs)()
4875  refs = (ctypes.c_uint * num_fs)()
4876  for k in range(num_fs):
4877  fname = fs[k][0]
4878  ftype = fs[k][1]
4879  fnames[k] = to_symbol(fname, ctx)
4880  if isinstance(ftype, Datatype):
4881  if z3_debug():
4882  _z3_assert(ds.count(ftype) == 1, "One and only one occurrence of each datatype is expected")
4883  sorts[k] = None
4884  refs[k] = ds.index(ftype)
4885  else:
4886  if z3_debug():
4887  _z3_assert(is_sort(ftype), "Z3 sort expected")
4888  sorts[k] = ftype.ast
4889  refs[k] = 0
4890  cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
4891  to_delete.append(ScopedConstructor(cs[j], ctx))
4892  clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
4893  to_delete.append(ScopedConstructorList(clists[i], ctx))
4894  Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
4895  result = []
4896 
4897  for i in range(num):
4898  dref = DatatypeSortRef(out[i], ctx)
4899  num_cs = dref.num_constructors()
4900  for j in range(num_cs):
4901  cref = dref.constructor(j)
4902  cref_name = cref.name()
4903  cref_arity = cref.arity()
4904  if cref.arity() == 0:
4905  cref = cref()
4906  setattr(dref, cref_name, cref)
4907  rref = dref.recognizer(j)
4908  setattr(dref, "is_" + cref_name, rref)
4909  for k in range(cref_arity):
4910  aref = dref.accessor(j, k)
4911  setattr(dref, aref.name(), aref)
4912  result.append(dref)
4913  return tuple(result)
4914 
def CreateDatatypes(*ds)
Definition: z3py.py:4823
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().

◆ 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.

637 def 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).

◆ Default()

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

Definition at line 4478 of file z3py.py.

4478 def Default(a):
4479  """ Return a default value for array expression.
4480  >>> b = K(IntSort(), 1)
4481  >>> prove(Default(b) == 1)
4482  proved
4483  """
4484  if z3_debug():
4485  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4486  return a.default()
4487 
4488 
def is_array_sort(a)
Definition: z3py.py:4331
def Default(a)
Definition: z3py.py:4478

◆ describe_probes()

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

Definition at line 8138 of file z3py.py.

8138 def describe_probes():
8139  """Display a (tabular) description of all available probes in Z3."""
8140  if in_html_mode():
8141  even = True
8142  print('<table border="1" cellpadding="2" cellspacing="0">')
8143  for p in probes():
8144  if even:
8145  print('<tr style="background-color:#CFCFCF">')
8146  even = False
8147  else:
8148  print('<tr>')
8149  even = True
8150  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8151  print('</table>')
8152  else:
8153  for p in probes():
8154  print('%s : %s' % (p, probe_description(p)))
8155 
def probe_description(name, ctx=None)
Definition: z3py.py:8130
def describe_probes()
Definition: z3py.py:8138
def probes(ctx=None)
Definition: z3py.py:8120

◆ describe_tactics()

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

Definition at line 7947 of file z3py.py.

7947 def describe_tactics():
7948  """Display a (tabular) description of all available tactics in Z3."""
7949  if in_html_mode():
7950  even = True
7951  print('<table border="1" cellpadding="2" cellspacing="0">')
7952  for t in tactics():
7953  if even:
7954  print('<tr style="background-color:#CFCFCF">')
7955  even = False
7956  else:
7957  print('<tr>')
7958  even = True
7959  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7960  print('</table>')
7961  else:
7962  for t in tactics():
7963  print('%s : %s' % (t, tactic_description(t)))
7964 
def tactics(ctx=None)
Definition: z3py.py:7929
def tactic_description(name, ctx=None)
Definition: z3py.py:7939
def describe_tactics()
Definition: z3py.py:7947

◆ disable_trace()

def z3py.disable_trace (   msg)

Definition at line 70 of file z3py.py.

70 def disable_trace(msg):
71  Z3_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 5023 of file z3py.py.

5023 def DisjointSum(name, sorts, ctx=None):
5024  """Create a named tagged union sort base on a set of underlying sorts
5025  Example:
5026  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5027  """
5028  sum = Datatype(name, ctx)
5029  for i in range(len(sorts)):
5030  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5031  sum = sum.create()
5032  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5033 
5034 
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:5023

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

1290 def Distinct(*args):
1291  """Create a Z3 distinct expression.
1292 
1293  >>> x = Int('x')
1294  >>> y = Int('y')
1295  >>> Distinct(x, y)
1296  x != y
1297  >>> z = Int('z')
1298  >>> Distinct(x, y, z)
1299  Distinct(x, y, z)
1300  >>> simplify(Distinct(x, y, z))
1301  Distinct(x, y, z)
1302  >>> simplify(Distinct(x, y, z), blast_distinct=True)
1303  And(Not(x == y), Not(x == z), Not(y == z))
1304  """
1305  args = _get_args(args)
1306  ctx = _ctx_from_ast_arg_list(args)
1307  if z3_debug():
1308  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1309  args = _coerce_expr_list(args, ctx)
1310  _args, sz = _to_ast_array(args)
1311  return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1312 
def Distinct(*args)
Definition: z3py.py:1290
Z3_ast Z3_API Z3_mk_distinct(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing distinct(args[0], ..., args[num_args-1]).

◆ Empty()

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

10160 def Empty(s):
10161  """Create the empty sequence of the given sort
10162  >>> e = Empty(StringSort())
10163  >>> e2 = StringVal("")
10164  >>> print(e.eq(e2))
10165  True
10166  >>> e3 = Empty(SeqSort(IntSort()))
10167  >>> print(e3)
10168  Empty(Seq(Int))
10169  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10170  >>> print(e4)
10171  Empty(ReSort(Seq(Int)))
10172  """
10173  if isinstance(s, SeqSortRef):
10174  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10175  if isinstance(s, ReSortRef):
10176  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10177  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10178 
def Empty(s)
Definition: z3py.py:10160
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.

◆ EmptySet()

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

Definition at line 4613 of file z3py.py.

4613 def EmptySet(s):
4614  """Create the empty set
4615  >>> EmptySet(IntSort())
4616  K(Int, False)
4617  """
4618  ctx = s.ctx
4619  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4620 
def EmptySet(s)
Definition: z3py.py:4613
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.

◆ enable_trace()

def z3py.enable_trace (   msg)

Definition at line 67 of file z3py.py.

67 def enable_trace(msg):
68  Z3_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.

◆ ensure_prop_closures()

def z3py.ensure_prop_closures ( )

Definition at line 10523 of file z3py.py.

10523 def ensure_prop_closures():
10524  global _prop_closures
10525  if _prop_closures is None:
10526  _prop_closures = PropClosures()
10527 
def ensure_prop_closures()
Definition: z3py.py:10523

Referenced by UserPropagateBase.__init__().

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

5035 def EnumSort(name, values, ctx=None):
5036  """Return a new enumeration sort named `name` containing the given values.
5037 
5038  The result is a pair (sort, list of constants).
5039  Example:
5040  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5041  """
5042  if z3_debug():
5043  _z3_assert(isinstance(name, str), "Name must be a string")
5044  _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5045  _z3_assert(len(values) > 0, "At least one value expected")
5046  ctx = _get_ctx(ctx)
5047  num = len(values)
5048  _val_names = (Symbol * num)()
5049  for i in range(num):
5050  _val_names[i] = to_symbol(values[i])
5051  _values = (FuncDecl * num)()
5052  _testers = (FuncDecl * num)()
5053  name = to_symbol(name)
5054  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5055  V = []
5056  for i in range(num):
5057  V.append(FuncDeclRef(_values[i], ctx))
5058  V = [a() for a in V]
5059  return S, V
5060 
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5035
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.

◆ eq()

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.

432 def 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
def eq(a, b)
Definition: z3py.py:432

Referenced by substitute().

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

2082 def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2083  """Create a Z3 exists formula.
2084 
2085  The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2086 
2087 
2088  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2089  >>> x = Int('x')
2090  >>> y = Int('y')
2091  >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2092  >>> q
2093  Exists([x, y], f(x, y) >= x)
2094  >>> is_quantifier(q)
2095  True
2096  >>> r = Tactic('nnf')(q).as_expr()
2097  >>> is_quantifier(r)
2098  False
2099  """
2100  return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2101 
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2082

Referenced by Fixedpoint.abstract().

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

4563 def Ext(a, b):
4564  """Return extensionality index for one-dimensional arrays.
4565  >> a, b = Consts('a b', SetSort(IntSort()))
4566  >> Ext(a, b)
4567  Ext(a, b)
4568  """
4569  ctx = a.ctx
4570  if z3_debug():
4571  _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4572  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4573 
def is_array(a)
Definition: z3py.py:4335
def Ext(a, b)
Definition: z3py.py:4563
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...

◆ Extract()

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

3899 def Extract(high, low, a):
3900  """Create a Z3 bit-vector extraction expression, or create a string extraction expression.
3901 
3902  >>> x = BitVec('x', 8)
3903  >>> Extract(6, 2, x)
3904  Extract(6, 2, x)
3905  >>> Extract(6, 2, x).sort()
3906  BitVec(5)
3907  >>> simplify(Extract(StringVal("abcd"),2,1))
3908  "c"
3909  """
3910  if isinstance(high, str):
3911  high = StringVal(high)
3912  if is_seq(high):
3913  s = high
3914  offset, length = _coerce_exprs(low, a, s.ctx)
3915  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
3916  if z3_debug():
3917  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
3918  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0, "First and second arguments must be non negative integers")
3919  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
3920  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
3921 
def Extract(high, low, a)
Definition: z3py.py:3899
def StringVal(s, ctx=None)
Definition: z3py.py:10125
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 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 8171 of file z3py.py.

8171 def FailIf(p, ctx=None):
8172  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8173 
8174  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8175 
8176  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8177  >>> x, y = Ints('x y')
8178  >>> g = Goal()
8179  >>> g.add(x > 0)
8180  >>> g.add(y > 0)
8181  >>> t(g)
8182  [[x > 0, y > 0]]
8183  >>> g.add(x == y + 1)
8184  >>> t(g)
8185  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8186  """
8187  p = _to_probe(p, ctx)
8188  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8189 
def FailIf(p, ctx=None)
Definition: z3py.py:8171
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.

◆ FiniteDomainSort()

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

Definition at line 7263 of file z3py.py.

7263 def FiniteDomainSort(name, sz, ctx=None):
7264  """Create a named finite domain sort of a given size sz"""
7265  if not isinstance(name, Symbol):
7266  name = to_symbol(name)
7267  ctx = _get_ctx(ctx)
7268  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7269 
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7263
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.

◆ FiniteDomainVal()

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

7331 def FiniteDomainVal(val, sort, ctx=None):
7332  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7333 
7334  >>> s = FiniteDomainSort('S', 256)
7335  >>> FiniteDomainVal(255, s)
7336  255
7337  >>> FiniteDomainVal('100', s)
7338  100
7339  """
7340  if z3_debug():
7341  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7342  ctx = sort.ctx
7343  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7344 
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7331
def is_finite_domain_sort(s)
Definition: z3py.py:7270

◆ Float128()

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

Definition at line 8801 of file z3py.py.

8801 def Float128(ctx=None):
8802  """Floating-point 128-bit (quadruple) sort."""
8803  ctx = _get_ctx(ctx)
8804  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8805 
def Float128(ctx=None)
Definition: z3py.py:8801
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 8771 of file z3py.py.

8771 def Float16(ctx=None):
8772  """Floating-point 16-bit (half) sort."""
8773  ctx = _get_ctx(ctx)
8774  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8775 
def Float16(ctx=None)
Definition: z3py.py:8771
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 8781 of file z3py.py.

8781 def Float32(ctx=None):
8782  """Floating-point 32-bit (single) sort."""
8783  ctx = _get_ctx(ctx)
8784  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8785 
def Float32(ctx=None)
Definition: z3py.py:8781
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.

◆ Float64()

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

Definition at line 8791 of file z3py.py.

8791 def Float64(ctx=None):
8792  """Floating-point 64-bit (double) sort."""
8793  ctx = _get_ctx(ctx)
8794  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8795 
def Float64(ctx=None)
Definition: z3py.py:8791
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.

◆ FloatDouble()

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

Definition at line 8796 of file z3py.py.

8796 def FloatDouble(ctx=None):
8797  """Floating-point 64-bit (double) sort."""
8798  ctx = _get_ctx(ctx)
8799  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8800 
def FloatDouble(ctx=None)
Definition: z3py.py:8796
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 8776 of file z3py.py.

8776 def FloatHalf(ctx=None):
8777  """Floating-point 16-bit (half) sort."""
8778  ctx = _get_ctx(ctx)
8779  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8780 
def FloatHalf(ctx=None)
Definition: z3py.py:8776
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 8806 of file z3py.py.

8806 def FloatQuadruple(ctx=None):
8807  """Floating-point 128-bit (quadruple) sort."""
8808  ctx = _get_ctx(ctx)
8809  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8810 
def FloatQuadruple(ctx=None)
Definition: z3py.py:8806
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 8786 of file z3py.py.

8786 def FloatSingle(ctx=None):
8787  """Floating-point 32-bit (single) sort."""
8788  ctx = _get_ctx(ctx)
8789  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8790 
def FloatSingle(ctx=None)
Definition: z3py.py:8786
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 2065 of file z3py.py.

2065 def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2066  """Create a Z3 forall formula.
2067 
2068  The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2069 
2070  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2071  >>> x = Int('x')
2072  >>> y = Int('y')
2073  >>> ForAll([x, y], f(x, y) >= x)
2074  ForAll([x, y], f(x, y) >= x)
2075  >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2076  ForAll([x, y], f(x, y) >= x)
2077  >>> ForAll([x, y], f(x, y) >= x, weight=10)
2078  ForAll([x, y], f(x, y) >= x)
2079  """
2080  return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2081 
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2065

Referenced by Fixedpoint.abstract().

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

9386 def FP(name, fpsort, ctx=None):
9387  """Return a floating-point constant named `name`.
9388  `fpsort` is the floating-point sort.
9389  If `ctx=None`, then the global context is used.
9390 
9391  >>> x = FP('x', FPSort(8, 24))
9392  >>> is_fp(x)
9393  True
9394  >>> x.ebits()
9395  8
9396  >>> x.sort()
9397  FPSort(8, 24)
9398  >>> word = FPSort(8, 24)
9399  >>> x2 = FP('x', word)
9400  >>> eq(x, x2)
9401  True
9402  """
9403  if isinstance(fpsort, FPSortRef) and ctx is None:
9404  ctx = fpsort.ctx
9405  else:
9406  ctx = _get_ctx(ctx)
9407  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9408 
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9386

Referenced by FPs().

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

9427 def fpAbs(a, ctx=None):
9428  """Create a Z3 floating-point absolute value expression.
9429 
9430  >>> s = FPSort(8, 24)
9431  >>> rm = RNE()
9432  >>> x = FPVal(1.0, s)
9433  >>> fpAbs(x)
9434  fpAbs(1)
9435  >>> y = FPVal(-20.0, s)
9436  >>> y
9437  -1.25*(2**4)
9438  >>> fpAbs(y)
9439  fpAbs(-1.25*(2**4))
9440  >>> fpAbs(-1.25*(2**4))
9441  fpAbs(-1.25*(2**4))
9442  >>> fpAbs(x).sort()
9443  FPSort(8, 24)
9444  """
9445  ctx = _get_ctx(ctx)
9446  [a] = _coerce_fp_expr_list([a], ctx)
9447  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
9448 
def fpAbs(a, ctx=None)
Definition: z3py.py:9427
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.

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

9509 def fpAdd(rm, a, b, ctx=None):
9510  """Create a Z3 floating-point addition expression.
9511 
9512  >>> s = FPSort(8, 24)
9513  >>> rm = RNE()
9514  >>> x = FP('x', s)
9515  >>> y = FP('y', s)
9516  >>> fpAdd(rm, x, y)
9517  fpAdd(RNE(), x, y)
9518  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9519  x + y
9520  >>> fpAdd(rm, x, y).sort()
9521  FPSort(8, 24)
9522  """
9523  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9524 
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9509

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

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

9805 def fpBVToFP(v, sort, ctx=None):
9806  """Create a Z3 floating-point conversion expression that represents the
9807  conversion from a bit-vector term to a floating-point term.
9808 
9809  >>> x_bv = BitVecVal(0x3F800000, 32)
9810  >>> x_fp = fpBVToFP(x_bv, Float32())
9811  >>> x_fp
9812  fpToFP(1065353216)
9813  >>> simplify(x_fp)
9814  1
9815  """
9816  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9817  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9818  ctx = _get_ctx(ctx)
9819  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9820 
def is_fp_sort(s)
Definition: z3py.py:8815
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9805
Z3_ast Z3_API Z3_mk_fpa_to_fp_bv(Z3_context c, Z3_ast bv, Z3_sort s)
Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.

◆ fpDiv()

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

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

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

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

9717 def fpEQ(a, b, ctx=None):
9718  """Create the Z3 floating-point expression `fpEQ(other, self)`.
9719 
9720  >>> x, y = FPs('x y', FPSort(8, 24))
9721  >>> fpEQ(x, y)
9722  fpEQ(x, y)
9723  >>> fpEQ(x, y).sexpr()
9724  '(fp.eq x y)'
9725  """
9726  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9727 
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9717

Referenced by fpNEQ().

◆ fpFMA()

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

Definition at line 9608 of file z3py.py.

9608 def fpFMA(rm, a, b, c, ctx=None):
9609  """Create a Z3 floating-point fused multiply-add expression.
9610  """
9611  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9612 
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9608

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

9739 def fpFP(sgn, exp, sig, ctx=None):
9740  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9741 
9742  >>> s = FPSort(8, 24)
9743  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9744  >>> print(x)
9745  fpFP(1, 127, 4194304)
9746  >>> xv = FPVal(-1.5, s)
9747  >>> print(xv)
9748  -1.5
9749  >>> slvr = Solver()
9750  >>> slvr.add(fpEQ(x, xv))
9751  >>> slvr.check()
9752  sat
9753  >>> xv = FPVal(+1.5, s)
9754  >>> print(xv)
9755  1.5
9756  >>> slvr = Solver()
9757  >>> slvr.add(fpEQ(x, xv))
9758  >>> slvr.check()
9759  unsat
9760  """
9761  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9762  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9763  ctx = _get_ctx(ctx)
9764  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9765  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9766 
def fpFP(sgn, exp, sig, ctx=None)
Definition: z3py.py:9739
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.

◆ fpFPToFP()

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

9821 def fpFPToFP(rm, v, sort, ctx=None):
9822  """Create a Z3 floating-point conversion expression that represents the
9823  conversion from a floating-point term to a floating-point term of different precision.
9824 
9825  >>> x_sgl = FPVal(1.0, Float32())
9826  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9827  >>> x_dbl
9828  fpToFP(RNE(), 1)
9829  >>> simplify(x_dbl)
9830  1
9831  >>> x_dbl.sort()
9832  FPSort(11, 53)
9833  """
9834  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9835  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9836  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9837  ctx = _get_ctx(ctx)
9838  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9839 
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9821
def is_fprm(a)
Definition: z3py.py:9062
def is_fp(a)
Definition: z3py.py:9198
Z3_ast Z3_API Z3_mk_fpa_to_fp_float(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a FloatingPoint term into another term of different FloatingPoint sort.

◆ fpGEQ()

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

9706 def fpGEQ(a, b, ctx=None):
9707  """Create the Z3 floating-point expression `other >= self`.
9708 
9709  >>> x, y = FPs('x y', FPSort(8, 24))
9710  >>> fpGEQ(x, y)
9711  x >= y
9712  >>> (x >= y).sexpr()
9713  '(fp.geq x y)'
9714  """
9715  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9716 
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9706

Referenced by FPRef.__ge__().

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

9695 def fpGT(a, b, ctx=None):
9696  """Create the Z3 floating-point expression `other > self`.
9697 
9698  >>> x, y = FPs('x y', FPSort(8, 24))
9699  >>> fpGT(x, y)
9700  x > y
9701  >>> (x > y).sexpr()
9702  '(fp.gt x y)'
9703  """
9704  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9705 
def fpGT(a, b, ctx=None)
Definition: z3py.py:9695

Referenced by FPRef.__gt__().

◆ fpInfinity()

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

Definition at line 9320 of file z3py.py.

9320 def fpInfinity(s, negative):
9321  """Create a Z3 floating-point +oo or -oo term."""
9322  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9323  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9324  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9325 
def fpInfinity(s, negative)
Definition: z3py.py:9320
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 9634 of file z3py.py.

9634 def fpIsInf(a, ctx=None):
9635  """Create a Z3 floating-point isInfinite expression.
9636 
9637  >>> s = FPSort(8, 24)
9638  >>> x = FP('x', s)
9639  >>> fpIsInf(x)
9640  fpIsInf(x)
9641  """
9642  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9643 
def fpIsInf(a, ctx=None)
Definition: z3py.py:9634

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

9623 def fpIsNaN(a, ctx=None):
9624  """Create a Z3 floating-point isNaN expression.
9625 
9626  >>> s = FPSort(8, 24)
9627  >>> x = FP('x', s)
9628  >>> y = FP('y', s)
9629  >>> fpIsNaN(x)
9630  fpIsNaN(x)
9631  """
9632  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9633 
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9623

◆ fpIsNegative()

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

Definition at line 9659 of file z3py.py.

9659 def fpIsNegative(a, ctx=None):
9660  """Create a Z3 floating-point isNegative expression.
9661  """
9662  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9663 
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9659

◆ fpIsNormal()

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

Definition at line 9649 of file z3py.py.

9649 def fpIsNormal(a, ctx=None):
9650  """Create a Z3 floating-point isNormal expression.
9651  """
9652  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9653 
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9649

◆ fpIsPositive()

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

Definition at line 9664 of file z3py.py.

9664 def fpIsPositive(a, ctx=None):
9665  """Create a Z3 floating-point isPositive expression.
9666  """
9667  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9668 
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9664

◆ fpIsSubnormal()

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

Definition at line 9654 of file z3py.py.

9654 def fpIsSubnormal(a, ctx=None):
9655  """Create a Z3 floating-point isSubnormal expression.
9656  """
9657  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9658 
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9654

◆ fpIsZero()

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

Definition at line 9644 of file z3py.py.

9644 def fpIsZero(a, ctx=None):
9645  """Create a Z3 floating-point isZero expression.
9646  """
9647  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9648 
def fpIsZero(a, ctx=None)
Definition: z3py.py:9644

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

9684 def fpLEQ(a, b, ctx=None):
9685  """Create the Z3 floating-point expression `other <= self`.
9686 
9687  >>> x, y = FPs('x y', FPSort(8, 24))
9688  >>> fpLEQ(x, y)
9689  x <= y
9690  >>> (x <= y).sexpr()
9691  '(fp.leq x y)'
9692  """
9693  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9694 
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9684

Referenced by FPRef.__le__().

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

9673 def fpLT(a, b, ctx=None):
9674  """Create the Z3 floating-point expression `other < self`.
9675 
9676  >>> x, y = FPs('x y', FPSort(8, 24))
9677  >>> fpLT(x, y)
9678  x < y
9679  >>> (x < y).sexpr()
9680  '(fp.lt x y)'
9681  """
9682  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9683 
def fpLT(a, b, ctx=None)
Definition: z3py.py:9673

Referenced by FPRef.__lt__().

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

9594 def fpMax(a, b, ctx=None):
9595  """Create a Z3 floating-point maximum expression.
9596 
9597  >>> s = FPSort(8, 24)
9598  >>> rm = RNE()
9599  >>> x = FP('x', s)
9600  >>> y = FP('y', s)
9601  >>> fpMax(x, y)
9602  fpMax(x, y)
9603  >>> fpMax(x, y).sort()
9604  FPSort(8, 24)
9605  """
9606  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9607 
def fpMax(a, b, ctx=None)
Definition: z3py.py:9594

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

9580 def fpMin(a, b, ctx=None):
9581  """Create a Z3 floating-point minimum expression.
9582 
9583  >>> s = FPSort(8, 24)
9584  >>> rm = RNE()
9585  >>> x = FP('x', s)
9586  >>> y = FP('y', s)
9587  >>> fpMin(x, y)
9588  fpMin(x, y)
9589  >>> fpMin(x, y).sort()
9590  FPSort(8, 24)
9591  """
9592  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9593 
def fpMin(a, b, ctx=None)
Definition: z3py.py:9580

◆ fpMinusInfinity()

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

Definition at line 9315 of file z3py.py.

9315 def fpMinusInfinity(s):
9316  """Create a Z3 floating-point -oo term."""
9317  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9318  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9319 
def fpMinusInfinity(s)
Definition: z3py.py:9315

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 9331 of file z3py.py.

9331 def fpMinusZero(s):
9332  """Create a Z3 floating-point -0.0 term."""
9333  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9334  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9335 
def fpMinusZero(s)
Definition: z3py.py:9331
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 9539 of file z3py.py.

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

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

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

9283 def fpNaN(s):
9284  """Create a Z3 floating-point NaN term.
9285 
9286  >>> s = FPSort(8, 24)
9287  >>> set_fpa_pretty(True)
9288  >>> fpNaN(s)
9289  NaN
9290  >>> pb = get_fpa_pretty()
9291  >>> set_fpa_pretty(False)
9292  >>> fpNaN(s)
9293  fpNaN(FPSort(8, 24))
9294  >>> set_fpa_pretty(pb)
9295  """
9296  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9297  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9298 
def fpNaN(s)
Definition: z3py.py:9283
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.

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

9449 def fpNeg(a, ctx=None):
9450  """Create a Z3 floating-point addition expression.
9451 
9452  >>> s = FPSort(8, 24)
9453  >>> rm = RNE()
9454  >>> x = FP('x', s)
9455  >>> fpNeg(x)
9456  -x
9457  >>> fpNeg(x).sort()
9458  FPSort(8, 24)
9459  """
9460  ctx = _get_ctx(ctx)
9461  [a] = _coerce_fp_expr_list([a], ctx)
9462  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9463 
def fpNeg(a, ctx=None)
Definition: z3py.py:9449
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.

Referenced by FPRef.__neg__().

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

9728 def fpNEQ(a, b, ctx=None):
9729  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9730 
9731  >>> x, y = FPs('x y', FPSort(8, 24))
9732  >>> fpNEQ(x, y)
9733  Not(fpEQ(x, y))
9734  >>> (x != y).sexpr()
9735  '(distinct x y)'
9736  """
9737  return Not(fpEQ(a, b, ctx))
9738 
def Not(a, ctx=None)
Definition: z3py.py:1669
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9728

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

9299 def fpPlusInfinity(s):
9300  """Create a Z3 floating-point +oo term.
9301 
9302  >>> s = FPSort(8, 24)
9303  >>> pb = get_fpa_pretty()
9304  >>> set_fpa_pretty(True)
9305  >>> fpPlusInfinity(s)
9306  +oo
9307  >>> set_fpa_pretty(False)
9308  >>> fpPlusInfinity(s)
9309  fpPlusInfinity(FPSort(8, 24))
9310  >>> set_fpa_pretty(pb)
9311  """
9312  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9313  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9314 
def fpPlusInfinity(s)
Definition: z3py.py:9299

Referenced by FPVal().

◆ fpPlusZero()

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

Definition at line 9326 of file z3py.py.

9326 def fpPlusZero(s):
9327  """Create a Z3 floating-point +0.0 term."""
9328  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9329  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9330 
def fpPlusZero(s)
Definition: z3py.py:9326

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

9840 def fpRealToFP(rm, v, sort, ctx=None):
9841  """Create a Z3 floating-point conversion expression that represents the
9842  conversion from a real term to a floating-point term.
9843 
9844  >>> x_r = RealVal(1.5)
9845  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9846  >>> x_fp
9847  fpToFP(RNE(), 3/2)
9848  >>> simplify(x_fp)
9849  1.5
9850  """
9851  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9852  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9853  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9854  ctx = _get_ctx(ctx)
9855  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9856 
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9840
def is_real(a)
Definition: z3py.py:2536
Z3_ast Z3_API Z3_mk_fpa_to_fp_real(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a term of real sort into a term of FloatingPoint sort.

◆ fpRem()

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

9567 def fpRem(a, b, ctx=None):
9568  """Create a Z3 floating-point remainder expression.
9569 
9570  >>> s = FPSort(8, 24)
9571  >>> x = FP('x', s)
9572  >>> y = FP('y', s)
9573  >>> fpRem(x, y)
9574  fpRem(x, y)
9575  >>> fpRem(x, y).sort()
9576  FPSort(8, 24)
9577  """
9578  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9579 
def fpRem(a, b, ctx=None)
Definition: z3py.py:9567

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

◆ fpRoundToIntegral()

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

Definition at line 9618 of file z3py.py.

9618 def fpRoundToIntegral(rm, a, ctx=None):
9619  """Create a Z3 floating-point roundToIntegral expression.
9620  """
9621  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9622 
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9618

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

9409 def FPs(names, fpsort, ctx=None):
9410  """Return an array of floating-point constants.
9411 
9412  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9413  >>> x.sort()
9414  FPSort(8, 24)
9415  >>> x.sbits()
9416  24
9417  >>> x.ebits()
9418  8
9419  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9420  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9421  """
9422  ctx = _get_ctx(ctx)
9423  if isinstance(names, str):
9424  names = names.split(" ")
9425  return [FP(name, fpsort, ctx) for name in names]
9426 
def FPs(names, fpsort, ctx=None)
Definition: z3py.py:9409

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

9857 def fpSignedToFP(rm, v, sort, ctx=None):
9858  """Create a Z3 floating-point conversion expression that represents the
9859  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9860 
9861  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9862  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9863  >>> x_fp
9864  fpToFP(RNE(), 4294967291)
9865  >>> simplify(x_fp)
9866  -1.25*(2**2)
9867  """
9868  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9869  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9870  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9871  ctx = _get_ctx(ctx)
9872  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9873 
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9857
Z3_ast Z3_API Z3_mk_fpa_to_fp_signed(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort.

◆ FPSort()

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

9225 def FPSort(ebits, sbits, ctx=None):
9226  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9227 
9228  >>> Single = FPSort(8, 24)
9229  >>> Double = FPSort(11, 53)
9230  >>> Single
9231  FPSort(8, 24)
9232  >>> x = Const('x', Single)
9233  >>> eq(x, FP('x', FPSort(8, 24)))
9234  True
9235  """
9236  ctx = _get_ctx(ctx)
9237  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9238 
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9225
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.

Referenced by get_default_fp_sort().

◆ fpSqrt()

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

Definition at line 9613 of file z3py.py.

9613 def fpSqrt(rm, a, ctx=None):
9614  """Create a Z3 floating-point square root expression.
9615  """
9616  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9617 
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9613

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

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

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

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

9767 def fpToFP(a1, a2=None, a3=None, ctx=None):
9768  """Create a Z3 floating-point conversion expression from other term sorts
9769  to floating-point.
9770 
9771  From a bit-vector term in IEEE 754-2008 format:
9772  >>> x = FPVal(1.0, Float32())
9773  >>> x_bv = fpToIEEEBV(x)
9774  >>> simplify(fpToFP(x_bv, Float32()))
9775  1
9776 
9777  From a floating-point term with different precision:
9778  >>> x = FPVal(1.0, Float32())
9779  >>> x_db = fpToFP(RNE(), x, Float64())
9780  >>> x_db.sort()
9781  FPSort(11, 53)
9782 
9783  From a real term:
9784  >>> x_r = RealVal(1.5)
9785  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9786  1.5
9787 
9788  From a signed bit-vector term:
9789  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9790  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9791  -1.25*(2**2)
9792  """
9793  ctx = _get_ctx(ctx)
9794  if is_bv(a1) and is_fp_sort(a2):
9795  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9796  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9797  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9798  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9799  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9800  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9801  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9802  else:
9803  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9804 
def fpToFP(a1, a2=None, a3=None, ctx=None)
Definition: z3py.py:9767

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

9891 def fpToFPUnsigned(rm, x, s, ctx=None):
9892  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
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_bv(x), "Second argument must be a Z3 bit-vector expression")
9896  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9897  ctx = _get_ctx(ctx)
9898  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9899 
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9891
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.

◆ fpToIEEEBV()

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

9961 def fpToIEEEBV(x, ctx=None):
9962  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9963 
9964  The size of the resulting bit-vector is automatically determined.
9965 
9966  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9967  knows only one NaN and it will always produce the same bit-vector representation of
9968  that NaN.
9969 
9970  >>> x = FP('x', FPSort(8, 24))
9971  >>> y = fpToIEEEBV(x)
9972  >>> print(is_fp(x))
9973  True
9974  >>> print(is_bv(y))
9975  True
9976  >>> print(is_fp(y))
9977  False
9978  >>> print(is_bv(x))
9979  False
9980  """
9981  if z3_debug():
9982  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9983  ctx = _get_ctx(ctx)
9984  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
9985 
9986 
9987 
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9961
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.

◆ fpToReal()

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

9942 def fpToReal(x, ctx=None):
9943  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9944 
9945  >>> x = FP('x', FPSort(8, 24))
9946  >>> y = fpToReal(x)
9947  >>> print(is_fp(x))
9948  True
9949  >>> print(is_real(y))
9950  True
9951  >>> print(is_fp(y))
9952  False
9953  >>> print(is_real(x))
9954  False
9955  """
9956  if z3_debug():
9957  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9958  ctx = _get_ctx(ctx)
9959  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9960 
def fpToReal(x, ctx=None)
Definition: z3py.py:9942
Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a real-numbered term.

◆ fpToSBV()

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

9900 def fpToSBV(rm, x, s, ctx=None):
9901  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9902 
9903  >>> x = FP('x', FPSort(8, 24))
9904  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9905  >>> print(is_fp(x))
9906  True
9907  >>> print(is_bv(y))
9908  True
9909  >>> print(is_fp(y))
9910  False
9911  >>> print(is_bv(x))
9912  False
9913  """
9914  if z3_debug():
9915  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9916  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9917  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9918  ctx = _get_ctx(ctx)
9919  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9920 
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9900
Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.

◆ fpToUBV()

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

9921 def fpToUBV(rm, x, s, ctx=None):
9922  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9923 
9924  >>> x = FP('x', FPSort(8, 24))
9925  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9926  >>> print(is_fp(x))
9927  True
9928  >>> print(is_bv(y))
9929  True
9930  >>> print(is_fp(y))
9931  False
9932  >>> print(is_bv(x))
9933  False
9934  """
9935  if z3_debug():
9936  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9937  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9938  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9939  ctx = _get_ctx(ctx)
9940  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9941 
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9921
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.

◆ fpUnsignedToFP()

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

9874 def fpUnsignedToFP(rm, v, sort, ctx=None):
9875  """Create a Z3 floating-point conversion expression that represents the
9876  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9877 
9878  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9879  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9880  >>> x_fp
9881  fpToFPUnsigned(RNE(), 4294967291)
9882  >>> simplify(x_fp)
9883  1*(2**32)
9884  """
9885  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9886  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9887  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9888  ctx = _get_ctx(ctx)
9889  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9890 
def fpUnsignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9874

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

9342 def FPVal(sig, exp=None, fps=None, ctx=None):
9343  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9344 
9345  >>> v = FPVal(20.0, FPSort(8, 24))
9346  >>> v
9347  1.25*(2**4)
9348  >>> print("0x%.8x" % v.exponent_as_long(False))
9349  0x00000004
9350  >>> v = FPVal(2.25, FPSort(8, 24))
9351  >>> v
9352  1.125*(2**1)
9353  >>> v = FPVal(-2.25, FPSort(8, 24))
9354  >>> v
9355  -1.125*(2**1)
9356  >>> FPVal(-0.0, FPSort(8, 24))
9357  -0.0
9358  >>> FPVal(0.0, FPSort(8, 24))
9359  +0.0
9360  >>> FPVal(+0.0, FPSort(8, 24))
9361  +0.0
9362  """
9363  ctx = _get_ctx(ctx)
9364  if is_fp_sort(exp):
9365  fps = exp
9366  exp = None
9367  elif fps is None:
9368  fps = _dflt_fps(ctx)
9369  _z3_assert(is_fp_sort(fps), "sort mismatch")
9370  if exp is None:
9371  exp = 0
9372  val = _to_float_str(sig)
9373  if val == "NaN" or val == "nan":
9374  return fpNaN(fps)
9375  elif val == "-0.0":
9376  return fpMinusZero(fps)
9377  elif val == "0.0" or val == "+0.0":
9378  return fpPlusZero(fps)
9379  elif val == "+oo" or val == "+inf" or val == "+Inf":
9380  return fpPlusInfinity(fps)
9381  elif val == "-oo" or val == "-inf" or val == "-Inf":
9382  return fpMinusInfinity(fps)
9383  else:
9384  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9385 
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9342

Referenced by set_default_fp_sort().

◆ fpZero()

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

Definition at line 9336 of file z3py.py.

9336 def fpZero(s, negative):
9337  """Create a Z3 floating-point +0.0 or -0.0 term."""
9338  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9339  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9340  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9341 
def fpZero(s, negative)
Definition: z3py.py:9336

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

1628 def FreshBool(prefix='b', ctx=None):
1629  """Return a fresh Boolean constant in the given context using the given prefix.
1630 
1631  If `ctx=None`, then the global context is used.
1632 
1633  >>> b1 = FreshBool()
1634  >>> b2 = FreshBool()
1635  >>> eq(b1, b2)
1636  False
1637  """
1638  ctx = _get_ctx(ctx)
1639  return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1640 
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1628
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.

◆ FreshConst()

def z3py.FreshConst (   sort,
  prefix = 'c' 
)
Create a fresh constant of a specified sort

Definition at line 1346 of file z3py.py.

1346 def FreshConst(sort, prefix='c'):
1347  """Create a fresh constant of a specified sort"""
1348  ctx = _get_ctx(sort.ctx)
1349  return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1350 
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346

◆ FreshFunction()

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

Definition at line 821 of file z3py.py.

821 def FreshFunction(*sig):
822  """Create a new fresh Z3 uninterpreted function with the given sorts.
823  """
824  sig = _get_args(sig)
825  if z3_debug():
826  _z3_assert(len(sig) > 0, "At least two arguments expected")
827  arity = len(sig) - 1
828  rng = sig[arity]
829  if z3_debug():
830  _z3_assert(is_sort(rng), "Z3 sort expected")
831  dom = (z3.Sort * arity)()
832  for i in range(arity):
833  if z3_debug():
834  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
835  dom[i] = sig[i].ast
836  ctx = rng.ctx
837  return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), 'f', arity, dom, rng.ast), ctx)
838 
839 
def FreshFunction(*sig)
Definition: z3py.py:821
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.

◆ FreshInt()

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

3081 def FreshInt(prefix='x', ctx=None):
3082  """Return a fresh integer constant in the given context using the given prefix.
3083 
3084  >>> x = FreshInt()
3085  >>> y = FreshInt()
3086  >>> eq(x, y)
3087  False
3088  >>> x.sort()
3089  Int
3090  """
3091  ctx = _get_ctx(ctx)
3092  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3093 
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3081
def IntSort(ctx=None)
Definition: z3py.py:2942

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

3134 def FreshReal(prefix='b', ctx=None):
3135  """Return a fresh real constant in the given context using the given prefix.
3136 
3137  >>> x = FreshReal()
3138  >>> y = FreshReal()
3139  >>> eq(x, y)
3140  False
3141  >>> x.sort()
3142  Real
3143  """
3144  ctx = _get_ctx(ctx)
3145  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3146 
def RealSort(ctx=None)
Definition: z3py.py:2958
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3134

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

10179 def Full(s):
10180  """Create the regular expression that accepts the universal language
10181  >>> e = Full(ReSort(SeqSort(IntSort())))
10182  >>> print(e)
10183  Full(ReSort(Seq(Int)))
10184  >>> e1 = Full(ReSort(StringSort()))
10185  >>> print(e1)
10186  Full(ReSort(String))
10187  """
10188  if isinstance(s, ReSortRef):
10189  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10190  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10191 
10192 
def Full(s)
Definition: z3py.py:10179
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.

◆ FullSet()

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

Definition at line 4621 of file z3py.py.

4621 def FullSet(s):
4622  """Create the full set
4623  >>> FullSet(IntSort())
4624  K(Int, True)
4625  """
4626  ctx = s.ctx
4627  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4628 
def FullSet(s)
Definition: z3py.py:4621
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.

◆ 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.

799 def 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 
def Function(name, *sig)
Definition: z3py.py:799
Z3_func_decl Z3_API Z3_mk_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a constant or function.

◆ get_as_array_func()

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

6285 def get_as_array_func(n):
6286  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6287  if z3_debug():
6288  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6289  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6290 
def is_as_array(n)
Definition: z3py.py:6281
def get_as_array_func(n)
Definition: z3py.py:6285
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.

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

8695 def get_default_fp_sort(ctx=None):
8696  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8697 
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8695

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

8668 def get_default_rounding_mode(ctx=None):
8669  """Retrieves the global default rounding mode."""
8670  global _dflt_rounding_mode
8671  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8672  return RTZ(ctx)
8673  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8674  return RTN(ctx)
8675  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8676  return RTP(ctx)
8677  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8678  return RNE(ctx)
8679  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8680  return RNA(ctx)
8681 
def RNE(ctx=None)
Definition: z3py.py:9026
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8668
def RTZ(ctx=None)
Definition: z3py.py:9058
def RTN(ctx=None)
Definition: z3py.py:9050
def RTP(ctx=None)
Definition: z3py.py:9042
def RNA(ctx=None)
Definition: z3py.py:9034

Referenced by set_default_fp_sort().

◆ get_full_version()

def z3py.get_full_version ( )

Definition at line 89 of file z3py.py.

89 def get_full_version():
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 4395 of file z3py.py.

4395 def get_map_func(a):
4396  """Return the function declaration associated with a Z3 map array expression.
4397 
4398  >>> f = Function('f', IntSort(), IntSort())
4399  >>> b = Array('b', IntSort(), IntSort())
4400  >>> a = Map(f, b)
4401  >>> eq(f, get_map_func(a))
4402  True
4403  >>> get_map_func(a)
4404  f
4405  >>> get_map_func(a)(0)
4406  f(0)
4407  """
4408  if z3_debug():
4409  _z3_assert(is_map(a), "Z3 array map expression expected.")
4410  return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4411 
def is_map(a)
Definition: z3py.py:4372
def get_map_func(a)
Definition: z3py.py:4395
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.

◆ get_param()

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.

273 def 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.

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

1224 def get_var_index(a):
1225  """Return the de-Bruijn index of the Z3 bounded variable `a`.
1226 
1227  >>> x = Int('x')
1228  >>> y = Int('y')
1229  >>> is_var(x)
1230  False
1231  >>> is_const(x)
1232  True
1233  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1234  >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1235  >>> q = ForAll([x, y], f(x, y) == x + y)
1236  >>> q.body()
1237  f(Var(1), Var(0)) == Var(1) + Var(0)
1238  >>> b = q.body()
1239  >>> b.arg(0)
1240  f(Var(1), Var(0))
1241  >>> v1 = b.arg(0).arg(0)
1242  >>> v2 = b.arg(0).arg(1)
1243  >>> v1
1244  Var(1)
1245  >>> v2
1246  Var(0)
1247  >>> get_var_index(v1)
1248  1
1249  >>> get_var_index(v2)
1250  0
1251  """
1252  if z3_debug():
1253  _z3_assert(is_var(a), "Z3 bound variable expected")
1254  return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1255 
def is_var(a)
Definition: z3py.py:1200
def get_var_index(a)
Definition: z3py.py:1224
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.

◆ get_version()

def z3py.get_version ( )

Definition at line 81 of file z3py.py.

81 def 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.

73 def get_version_string():
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 8248 of file z3py.py.

8248 def help_simplify():
8249  """Return a string describing all options available for Z3 `simplify` procedure."""
8250  print(Z3_simplify_get_help(main_ctx().ref()))
8251 
def help_simplify()
Definition: z3py.py:8248
def main_ctx()
Definition: z3py.py:211
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 1268 of file z3py.py.

1268 def If(a, b, c, ctx=None):
1269  """Create a Z3 if-then-else expression.
1270 
1271  >>> x = Int('x')
1272  >>> y = Int('y')
1273  >>> max = If(x > y, x, y)
1274  >>> max
1275  If(x > y, x, y)
1276  >>> simplify(max)
1277  If(x <= y, y, x)
1278  """
1279  if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1280  return Cond(a, b, c, ctx)
1281  else:
1282  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1283  s = BoolSort(ctx)
1284  a = s.cast(a)
1285  b, c = _coerce_exprs(b, c, ctx)
1286  if z3_debug():
1287  _z3_assert(a.ctx == b.ctx, "Context mismatch")
1288  return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1289 
def If(a, b, c, ctx=None)
Definition: z3py.py:1268
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__(), and ArithRef.__mul__().

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

1641 def Implies(a, b, ctx=None):
1642  """Create a Z3 implies expression.
1643 
1644  >>> p, q = Bools('p q')
1645  >>> Implies(p, q)
1646  Implies(p, q)
1647  """
1648  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1649  s = BoolSort(ctx)
1650  a = s.cast(a)
1651  b = s.cast(b)
1652  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1653 
def Implies(a, b, ctx=None)
Definition: z3py.py:1641
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(), and Fixedpoint.update_rule().

◆ IndexOf() [1/2]

def z3py.IndexOf (   s,
  substr 
)

Definition at line 10258 of file z3py.py.

10258 def IndexOf(s, substr):
10259  return IndexOf(s, substr, IntVal(0))
10260 
def IndexOf(s, substr, offset)
Definition: z3py.py:10261
def IntVal(val, ctx=None)
Definition: z3py.py:2989

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

10261 def IndexOf(s, substr, offset):
10262  """Retrieve the index of substring within a string starting at a specified offset.
10263  >>> simplify(IndexOf("abcabc", "bc", 0))
10264  1
10265  >>> simplify(IndexOf("abcabc", "bc", 2))
10266  4
10267  """
10268  ctx = None
10269  if is_expr(offset):
10270  ctx = offset.ctx
10271  ctx = _get_ctx2(s, substr, ctx)
10272  s = _coerce_seq(s, ctx)
10273  substr = _coerce_seq(substr, ctx)
10274  if _is_int(offset):
10275  offset = IntVal(offset, ctx)
10276  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10277 
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 10358 of file z3py.py.

10358 def InRe(s, re):
10359  """Create regular expression membership test
10360  >>> re = Union(Re("a"),Re("b"))
10361  >>> print (simplify(InRe("a", re)))
10362  True
10363  >>> print (simplify(InRe("b", re)))
10364  True
10365  >>> print (simplify(InRe("c", re)))
10366  False
10367  """
10368  s = _coerce_seq(s, re.ctx)
10369  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10370 
def InRe(s, re)
Definition: z3py.py:10358
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.

◆ Int()

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

3045 def Int(name, ctx=None):
3046  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3047 
3048  >>> x = Int('x')
3049  >>> is_int(x)
3050  True
3051  >>> is_int(x + 1)
3052  True
3053  """
3054  ctx = _get_ctx(ctx)
3055  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3056 
def Int(name, ctx=None)
Definition: z3py.py:3045

Referenced by Ints(), and IntVector().

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

3773 def Int2BV(a, num_bits):
3774  """Return the z3 expression Int2BV(a, num_bits).
3775  It is a bit-vector of width num_bits and represents the
3776  modulo of a by 2^num_bits
3777  """
3778  ctx = a.ctx
3779  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3780 
def Int2BV(a, num_bits)
Definition: z3py.py:3773
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 10390 of file z3py.py.

10390 def Intersect(*args):
10391  """Create intersection of regular expressions.
10392  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10393  """
10394  args = _get_args(args)
10395  sz = len(args)
10396  if z3_debug():
10397  _z3_assert(sz > 0, "At least one argument expected.")
10398  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10399  if sz == 1:
10400  return args[0]
10401  ctx = args[0].ctx
10402  v = (Ast * sz)()
10403  for i in range(sz):
10404  v[i] = args[i].as_ast()
10405  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10406 
def Intersect(*args)
Definition: z3py.py:10390
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.

◆ Ints()

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

3057 def Ints(names, ctx=None):
3058  """Return a tuple of Integer constants.
3059 
3060  >>> x, y, z = Ints('x y z')
3061  >>> Sum(x, y, z)
3062  x + y + z
3063  """
3064  ctx = _get_ctx(ctx)
3065  if isinstance(names, str):
3066  names = names.split(" ")
3067  return [Int(name, ctx) for name in names]
3068 
def Ints(names, ctx=None)
Definition: z3py.py:3057

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

2942 def IntSort(ctx=None):
2943  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2944 
2945  >>> IntSort()
2946  Int
2947  >>> x = Const('x', IntSort())
2948  >>> is_int(x)
2949  True
2950  >>> x.sort() == IntSort()
2951  True
2952  >>> x.sort() == BoolSort()
2953  False
2954  """
2955  ctx = _get_ctx(ctx)
2956  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2957 
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.

Referenced by FreshInt(), Int(), and IntVal().

◆ IntToStr()

def z3py.IntToStr (   s)
Convert integer expression to string

Definition at line 10312 of file z3py.py.

10312 def IntToStr(s):
10313  """Convert integer expression to string"""
10314  if not is_expr(s):
10315  s = _py2expr(s)
10316  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10317 
10318 
def IntToStr(s)
Definition: z3py.py:10312
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.

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

2989 def IntVal(val, ctx=None):
2990  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
2991 
2992  >>> IntVal(1)
2993  1
2994  >>> IntVal("100")
2995  100
2996  """
2997  ctx = _get_ctx(ctx)
2998  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
2999 

Referenced by SeqRef.__getitem__(), SeqRef.at(), AlgebraicNumRef.index(), and IndexOf().

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

3069 def IntVector(prefix, sz, ctx=None):
3070  """Return a list of integer constants of size `sz`.
3071 
3072  >>> X = IntVector('x', 3)
3073  >>> X
3074  [x__0, x__1, x__2]
3075  >>> Sum(X)
3076  x__0 + x__1 + x__2
3077  """
3078  ctx = _get_ctx(ctx)
3079  return [ Int('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3080 
def IntVector(prefix, sz, ctx=None)
Definition: z3py.py:3069

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

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

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

2604 def is_algebraic_value(a):
2605  """Return `True` if `a` is an algebraic value of sort Real.
2606 
2607  >>> is_algebraic_value(RealVal("3/5"))
2608  False
2609  >>> n = simplify(Sqrt(2))
2610  >>> n
2611  1.4142135623?
2612  >>> is_algebraic_value(n)
2613  True
2614  """
2615  return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2616 
def is_algebraic_value(a)
Definition: z3py.py:2604
def is_arith(a)
Definition: z3py.py:2498

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

1489 def is_and(a):
1490  """Return `True` if `a` is a Z3 and expression.
1491 
1492  >>> p, q = Bools('p q')
1493  >>> is_and(And(p, q))
1494  True
1495  >>> is_and(Or(p, q))
1496  False
1497  """
1498  return is_app_of(a, Z3_OP_AND)
1499 
def is_and(a)
Definition: z3py.py:1489

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

1157 def is_app(a):
1158  """Return `True` if `a` is a Z3 function application.
1159 
1160  Note that, constants are function applications with 0 arguments.
1161 
1162  >>> a = Int('a')
1163  >>> is_app(a)
1164  True
1165  >>> is_app(a + 1)
1166  True
1167  >>> is_app(IntSort())
1168  False
1169  >>> is_app(1)
1170  False
1171  >>> is_app(IntVal(1))
1172  True
1173  >>> x = Int('x')
1174  >>> is_app(ForAll(x, x >= 0))
1175  False
1176  """
1177  if not isinstance(a, ExprRef):
1178  return False
1179  k = _ast_kind(a.ctx, a)
1180  return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1181 
def is_app(a)
Definition: z3py.py:1157

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

1256 def is_app_of(a, k):
1257  """Return `True` if `a` is an application of the given kind `k`.
1258 
1259  >>> x = Int('x')
1260  >>> n = x + 1
1261  >>> is_app_of(n, Z3_OP_ADD)
1262  True
1263  >>> is_app_of(n, Z3_OP_MUL)
1264  False
1265  """
1266  return is_app(a) and a.decl().kind() == k
1267 

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

◆ is_arith()

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

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

Referenced by is_algebraic_value(), 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 2199 of file z3py.py.

2199 def is_arith_sort(s):
2200  """Return `True` if s is an arithmetical sort (type).
2201 
2202  >>> is_arith_sort(IntSort())
2203  True
2204  >>> is_arith_sort(RealSort())
2205  True
2206  >>> is_arith_sort(BoolSort())
2207  False
2208  >>> n = Int('x') + 1
2209  >>> is_arith_sort(n.sort())
2210  True
2211  """
2212  return isinstance(s, ArithSortRef)
2213 
def is_arith_sort(s)
Definition: z3py.py:2199

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

4335 def is_array(a):
4336  """Return `True` if `a` is a Z3 array expression.
4337 
4338  >>> a = Array('a', IntSort(), IntSort())
4339  >>> is_array(a)
4340  True
4341  >>> is_array(Store(a, 0, 1))
4342  True
4343  >>> is_array(a[0])
4344  False
4345  """
4346  return isinstance(a, ArrayRef)
4347 

Referenced by Ext(), and Map().

◆ is_array_sort()

def z3py.is_array_sort (   a)

Definition at line 4331 of file z3py.py.

4331 def is_array_sort(a):
4332  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4333 
4334 
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 6281 of file z3py.py.

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

412 def 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(), 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 1442 of file z3py.py.

1442 def is_bool(a):
1443  """Return `True` if `a` is a Z3 Boolean expression.
1444 
1445  >>> p = Bool('p')
1446  >>> is_bool(p)
1447  True
1448  >>> q = Bool('q')
1449  >>> is_bool(And(p, q))
1450  True
1451  >>> x = Real('x')
1452  >>> is_bool(x)
1453  False
1454  >>> is_bool(x == 0)
1455  True
1456  """
1457  return isinstance(a, BoolRef)
1458 
def is_bool(a)
Definition: z3py.py:1442

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

3724 def is_bv(a):
3725  """Return `True` if `a` is a Z3 bit-vector expression.
3726 
3727  >>> b = BitVec('b', 32)
3728  >>> is_bv(b)
3729  True
3730  >>> is_bv(b + 10)
3731  True
3732  >>> is_bv(Int('x'))
3733  False
3734  """
3735  return isinstance(a, BitVecRef)
3736 

Referenced by BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), Concat(), Extract(), fpBVToFP(), fpFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpUnsignedToFP(), 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 3259 of file z3py.py.

3259 def is_bv_sort(s):
3260  """Return True if `s` is a Z3 bit-vector sort.
3261 
3262  >>> is_bv_sort(BitVecSort(32))
3263  True
3264  >>> is_bv_sort(IntSort())
3265  False
3266  """
3267  return isinstance(s, BitVecSortRef)
3268 

Referenced by BitVecVal(), fpToSBV(), fpToUBV(), 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 3737 of file z3py.py.

3737 def is_bv_value(a):
3738  """Return `True` if `a` is a Z3 bit-vector numeral value.
3739 
3740  >>> b = BitVec('b', 32)
3741  >>> is_bv_value(b)
3742  False
3743  >>> b = BitVecVal(10, 32)
3744  >>> b
3745  10
3746  >>> is_bv_value(b)
3747  True
3748  """
3749  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3750 
def is_bv_value(a)
Definition: z3py.py:3737

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

1182 def is_const(a):
1183  """Return `True` if `a` is Z3 constant/variable expression.
1184 
1185  >>> a = Int('a')
1186  >>> is_const(a)
1187  True
1188  >>> is_const(a + 1)
1189  False
1190  >>> is_const(1)
1191  False
1192  >>> is_const(IntVal(1))
1193  True
1194  >>> x = Int('x')
1195  >>> is_const(ForAll(x, x >= 0))
1196  False
1197  """
1198  return is_app(a) and a.num_args() == 0
1199 
def is_const(a)
Definition: z3py.py:1182

Referenced by ModelRef.__getitem__(), Solver.assert_and_track(), Optimize.assert_and_track(), ModelRef.get_interp(), is_quantifier(), 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 4348 of file z3py.py.

4348 def is_const_array(a):
4349  """Return `True` if `a` is a Z3 constant array.
4350 
4351  >>> a = K(IntSort(), 10)
4352  >>> is_const_array(a)
4353  True
4354  >>> a = Array('a', IntSort(), IntSort())
4355  >>> is_const_array(a)
4356  False
4357  """
4358  return is_app_of(a, Z3_OP_CONST_ARRAY)
4359 
def is_const_array(a)
Definition: z3py.py:4348

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

4387 def is_default(a):
4388  """Return `True` if `a` is a Z3 default array expression.
4389  >>> d = Default(K(IntSort(), 10))
4390  >>> is_default(d)
4391  True
4392  """
4393  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4394 
def is_default(a)
Definition: z3py.py:4387

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

1542 def is_distinct(a):
1543  """Return `True` if `a` is a Z3 distinct expression.
1544 
1545  >>> x, y, z = Ints('x y z')
1546  >>> is_distinct(x == y)
1547  False
1548  >>> is_distinct(Distinct(x, y, z))
1549  True
1550  """
1551  return is_app_of(a, Z3_OP_DISTINCT)
1552 
def is_distinct(a)
Definition: z3py.py:1542

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

2650 def is_div(a):
2651  """Return `True` if `a` is an expression of the form b / c.
2652 
2653  >>> x, y = Reals('x y')
2654  >>> is_div(x / y)
2655  True
2656  >>> is_div(x + y)
2657  False
2658  >>> x, y = Ints('x y')
2659  >>> is_div(x / y)
2660  False
2661  >>> is_idiv(x / y)
2662  True
2663  """
2664  return is_app_of(a, Z3_OP_DIV)
2665 
def is_div(a)
Definition: z3py.py:2650

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

1533 def is_eq(a):
1534  """Return `True` if `a` is a Z3 equality expression.
1535 
1536  >>> x, y = Ints('x y')
1537  >>> is_eq(x == y)
1538  True
1539  """
1540  return is_app_of(a, Z3_OP_EQ)
1541 
def is_eq(a)
Definition: z3py.py:1533

Referenced by AstRef.__bool__().

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

1135 def is_expr(a):
1136  """Return `True` if `a` is a Z3 expression.
1137 
1138  >>> a = Int('a')
1139  >>> is_expr(a)
1140  True
1141  >>> is_expr(a + 1)
1142  True
1143  >>> is_expr(IntSort())
1144  False
1145  >>> is_expr(1)
1146  False
1147  >>> is_expr(IntVal(1))
1148  True
1149  >>> x = Int('x')
1150  >>> is_expr(ForAll(x, x >= 0))
1151  True
1152  >>> is_expr(FPVal(1.0))
1153  True
1154  """
1155  return isinstance(a, ExprRef)
1156 

Referenced by SeqRef.__gt__(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), Cbrt(), ExprRef.children(), Concat(), AlgebraicNumRef.index(), IndexOf(), IntToStr(), is_quantifier(), 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 1476 of file z3py.py.

1476 def is_false(a):
1477  """Return `True` if `a` is the Z3 false expression.
1478 
1479  >>> p = Bool('p')
1480  >>> is_false(p)
1481  False
1482  >>> is_false(False)
1483  False
1484  >>> is_false(BoolVal(False))
1485  True
1486  """
1487  return is_app_of(a, Z3_OP_FALSE)
1488 
def is_false(a)
Definition: z3py.py:1476

Referenced by AstRef.__bool__().

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

7292 def is_finite_domain(a):
7293  """Return `True` if `a` is a Z3 finite-domain expression.
7294 
7295  >>> s = FiniteDomainSort('S', 100)
7296  >>> b = Const('b', s)
7297  >>> is_finite_domain(b)
7298  True
7299  >>> is_finite_domain(Int('x'))
7300  False
7301  """
7302  return isinstance(a, FiniteDomainRef)
7303 
7304 
def is_finite_domain(a)
Definition: z3py.py:7292

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

7270 def is_finite_domain_sort(s):
7271  """Return True if `s` is a Z3 finite-domain sort.
7272 
7273  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7274  True
7275  >>> is_finite_domain_sort(IntSort())
7276  False
7277  """
7278  return isinstance(s, FiniteDomainSortRef)
7279 
7280 

Referenced by FiniteDomainVal().

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

7345 def is_finite_domain_value(a):
7346  """Return `True` if `a` is a Z3 finite-domain value.
7347 
7348  >>> s = FiniteDomainSort('S', 100)
7349  >>> b = Const('b', s)
7350  >>> is_finite_domain_value(b)
7351  False
7352  >>> b = FiniteDomainVal(10, s)
7353  >>> b
7354  10
7355  >>> is_finite_domain_value(b)
7356  True
7357  """
7358  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7359 
7360 
def is_finite_domain_value(a)
Definition: z3py.py:7345

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

9198 def is_fp(a):
9199  """Return `True` if `a` is a Z3 floating-point expression.
9200 
9201  >>> b = FP('b', FPSort(8, 24))
9202  >>> is_fp(b)
9203  True
9204  >>> is_fp(b + 1.0)
9205  True
9206  >>> is_fp(Int('x'))
9207  False
9208  """
9209  return isinstance(a, FPRef)
9210 

Referenced by fpFPToFP(), fpIsPositive(), fpNeg(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), 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 8815 of file z3py.py.

8815 def is_fp_sort(s):
8816  """Return True if `s` is a Z3 floating-point sort.
8817 
8818  >>> is_fp_sort(FPSort(8, 24))
8819  True
8820  >>> is_fp_sort(IntSort())
8821  False
8822  """
8823  return isinstance(s, FPSortRef)
8824 

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

9211 def is_fp_value(a):
9212  """Return `True` if `a` is a Z3 floating-point numeral value.
9213 
9214  >>> b = FP('b', FPSort(8, 24))
9215  >>> is_fp_value(b)
9216  False
9217  >>> b = FPVal(1.0, FPSort(8, 24))
9218  >>> b
9219  1
9220  >>> is_fp_value(b)
9221  True
9222  """
9223  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9224 
def is_fp_value(a)
Definition: z3py.py:9211

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

9062 def is_fprm(a):
9063  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9064 
9065  >>> rm = RNE()
9066  >>> is_fprm(rm)
9067  True
9068  >>> rm = 1.0
9069  >>> is_fprm(rm)
9070  False
9071  """
9072  return isinstance(a, FPRMRef)
9073 

Referenced by fpFPToFP(), fpNeg(), fpRealToFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), 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 8825 of file z3py.py.

8825 def is_fprm_sort(s):
8826  """Return True if `s` is a Z3 floating-point rounding mode sort.
8827 
8828  >>> is_fprm_sort(FPSort(8, 24))
8829  False
8830  >>> is_fprm_sort(RNE().sort())
8831  True
8832  """
8833  return isinstance(s, FPRMSortRef)
8834 
def is_fprm_sort(s)
Definition: z3py.py:8825

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

9074 def is_fprm_value(a):
9075  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9076  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9077 
def is_fprm_value(a)
Definition: z3py.py:9074

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.

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

2710 def is_ge(a):
2711  """Return `True` if `a` is an expression of the form b >= c.
2712 
2713  >>> x, y = Ints('x y')
2714  >>> is_ge(x >= y)
2715  True
2716  >>> is_ge(x == y)
2717  False
2718  """
2719  return is_app_of(a, Z3_OP_GE)
2720 
def is_ge(a)
Definition: z3py.py:2710

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

2721 def is_gt(a):
2722  """Return `True` if `a` is an expression of the form b > c.
2723 
2724  >>> x, y = Ints('x y')
2725  >>> is_gt(x > y)
2726  True
2727  >>> is_gt(x == y)
2728  False
2729  """
2730  return is_app_of(a, Z3_OP_GT)
2731 
def is_gt(a)
Definition: z3py.py:2721

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

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

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

1511 def is_implies(a):
1512  """Return `True` if `a` is a Z3 implication expression.
1513 
1514  >>> p, q = Bools('p q')
1515  >>> is_implies(Implies(p, q))
1516  True
1517  >>> is_implies(And(p, q))
1518  False
1519  """
1520  return is_app_of(a, Z3_OP_IMPLIES)
1521 
def is_implies(a)
Definition: z3py.py:1511

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

2518 def is_int(a):
2519  """Return `True` if `a` is an integer expression.
2520 
2521  >>> x = Int('x')
2522  >>> is_int(x + 1)
2523  True
2524  >>> is_int(1)
2525  False
2526  >>> is_int(IntVal(1))
2527  True
2528  >>> y = Real('y')
2529  >>> is_int(y)
2530  False
2531  >>> is_int(y + 1)
2532  False
2533  """
2534  return is_arith(a) and a.is_int()
2535 
def is_int(a)
Definition: z3py.py:2518

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

2560 def is_int_value(a):
2561  """Return `True` if `a` is an integer value of sort Int.
2562 
2563  >>> is_int_value(IntVal(1))
2564  True
2565  >>> is_int_value(1)
2566  False
2567  >>> is_int_value(Int('x'))
2568  False
2569  >>> n = Int('x') + 1
2570  >>> n
2571  x + 1
2572  >>> n.arg(1)
2573  1
2574  >>> is_int_value(n.arg(1))
2575  True
2576  >>> is_int_value(RealVal("1/3"))
2577  False
2578  >>> is_int_value(RealVal(1))
2579  False
2580  """
2581  return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2582 
def is_int_value(a)
Definition: z3py.py:2560

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

2732 def is_is_int(a):
2733  """Return `True` if `a` is an expression of the form IsInt(b).
2734 
2735  >>> x = Real('x')
2736  >>> is_is_int(IsInt(x))
2737  True
2738  >>> is_is_int(x)
2739  False
2740  """
2741  return is_app_of(a, Z3_OP_IS_INT)
2742 
def is_is_int(a)
Definition: z3py.py:2732

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

4360 def is_K(a):
4361  """Return `True` if `a` is a Z3 constant array.
4362 
4363  >>> a = K(IntSort(), 10)
4364  >>> is_K(a)
4365  True
4366  >>> a = Array('a', IntSort(), IntSort())
4367  >>> is_K(a)
4368  False
4369  """
4370  return is_app_of(a, Z3_OP_CONST_ARRAY)
4371 
def is_K(a)
Definition: z3py.py:4360

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

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

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

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

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

4372 def is_map(a):
4373  """Return `True` if `a` is a Z3 map array expression.
4374 
4375  >>> f = Function('f', IntSort(), IntSort())
4376  >>> b = Array('b', IntSort(), IntSort())
4377  >>> a = Map(f, b)
4378  >>> a
4379  Map(f, b)
4380  >>> is_map(a)
4381  True
4382  >>> is_map(b)
4383  False
4384  """
4385  return is_app_of(a, Z3_OP_ARRAY_MAP)
4386 

Referenced by get_map_func().

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

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

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

2628 def is_mul(a):
2629  """Return `True` if `a` is an expression of the form b * c.
2630 
2631  >>> x, y = Ints('x y')
2632  >>> is_mul(x * y)
2633  True
2634  >>> is_mul(x - y)
2635  False
2636  """
2637  return is_app_of(a, Z3_OP_MUL)
2638 
def is_mul(a)
Definition: z3py.py:2628

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

1522 def is_not(a):
1523  """Return `True` if `a` is a Z3 not expression.
1524 
1525  >>> p = Bool('p')
1526  >>> is_not(p)
1527  False
1528  >>> is_not(Not(p))
1529  True
1530  """
1531  return is_app_of(a, Z3_OP_NOT)
1532 
def is_not(a)
Definition: z3py.py:1522

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

1500 def is_or(a):
1501  """Return `True` if `a` is a Z3 or expression.
1502 
1503  >>> p, q = Bools('p q')
1504  >>> is_or(Or(p, q))
1505  True
1506  >>> is_or(And(p, q))
1507  False
1508  """
1509  return is_app_of(a, Z3_OP_OR)
1510 
def is_or(a)
Definition: z3py.py:1500

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

1780 def is_pattern(a):
1781  """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1782 
1783  >>> f = Function('f', IntSort(), IntSort())
1784  >>> x = Int('x')
1785  >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1786  >>> q
1787  ForAll(x, f(x) == 0)
1788  >>> q.num_patterns()
1789  1
1790  >>> is_pattern(q.pattern(0))
1791  True
1792  >>> q.pattern(0)
1793  f(Var(0))
1794  """
1795  return isinstance(a, PatternRef)
1796 
def is_pattern(a)
Definition: z3py.py:1780

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

8104 def is_probe(p):
8105  """Return `True` if `p` is a Z3 probe.
8106 
8107  >>> is_probe(Int('x'))
8108  False
8109  >>> is_probe(Probe('memory'))
8110  True
8111  """
8112  return isinstance(p, Probe)
8113 
def is_probe(p)
Definition: z3py.py:8104

Referenced by eq(), 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 2018 of file z3py.py.

2018 def is_quantifier(a):
2019  """Return `True` if `a` is a Z3 quantifier.
2020 
2021  >>> f = Function('f', IntSort(), IntSort())
2022  >>> x = Int('x')
2023  >>> q = ForAll(x, f(x) == 0)
2024  >>> is_quantifier(q)
2025  True
2026  >>> is_quantifier(f(x))
2027  False
2028  """
2029  return isinstance(a, QuantifierRef)
2030 
def is_quantifier(a)
Definition: z3py.py:2018

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

2583 def is_rational_value(a):
2584  """Return `True` if `a` is rational value of sort Real.
2585 
2586  >>> is_rational_value(RealVal(1))
2587  True
2588  >>> is_rational_value(RealVal("3/5"))
2589  True
2590  >>> is_rational_value(IntVal(1))
2591  False
2592  >>> is_rational_value(1)
2593  False
2594  >>> n = Real('x') + 1
2595  >>> n.arg(1)
2596  1
2597  >>> is_rational_value(n.arg(1))
2598  True
2599  >>> is_rational_value(Real('x'))
2600  False
2601  """
2602  return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2603 
def is_rational_value(a)
Definition: z3py.py:2583

◆ is_re()

def z3py.is_re (   s)

Definition at line 10354 of file z3py.py.

10354 def is_re(s):
10355  return isinstance(s, ReRef)
10356 
10357 

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

2536 def is_real(a):
2537  """Return `True` if `a` is a real expression.
2538 
2539  >>> x = Int('x')
2540  >>> is_real(x + 1)
2541  False
2542  >>> y = Real('y')
2543  >>> is_real(y)
2544  True
2545  >>> is_real(y + 1)
2546  True
2547  >>> is_real(1)
2548  False
2549  >>> is_real(RealVal(1))
2550  True
2551  """
2552  return is_arith(a) and a.is_real()
2553 

Referenced by fpRealToFP(), and fpToFP().

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

4579 def is_select(a):
4580  """Return `True` if `a` is a Z3 array select application.
4581 
4582  >>> a = Array('a', IntSort(), IntSort())
4583  >>> is_select(a)
4584  False
4585  >>> i = Int('i')
4586  >>> is_select(a[i])
4587  True
4588  """
4589  return is_app_of(a, Z3_OP_SELECT)
4590 
def is_select(a)
Definition: z3py.py:4579

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

10099 def is_seq(a):
10100  """Return `True` if `a` is a Z3 sequence expression.
10101  >>> print (is_seq(Unit(IntVal(0))))
10102  True
10103  >>> print (is_seq(StringVal("abc")))
10104  True
10105  """
10106  return isinstance(a, SeqRef)
10107 

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

◆ 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.

596 def 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(), FreshFunction(), Function(), 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 4591 of file z3py.py.

4591 def is_store(a):
4592  """Return `True` if `a` is a Z3 array store application.
4593 
4594  >>> a = Array('a', IntSort(), IntSort())
4595  >>> is_store(a)
4596  False
4597  >>> is_store(Store(a, 0, 1))
4598  True
4599  """
4600  return is_app_of(a, Z3_OP_STORE)
4601 
def is_store(a)
Definition: z3py.py:4591

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

10108 def is_string(a):
10109  """Return `True` if `a` is a Z3 string expression.
10110  >>> print (is_string(StringVal("ab")))
10111  True
10112  """
10113  return isinstance(a, SeqRef) and a.is_string()
10114 
def is_string(a)
Definition: z3py.py:10108

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

10115 def is_string_value(a):
10116  """return 'True' if 'a' is a Z3 string constant expression.
10117  >>> print (is_string_value(StringVal("a")))
10118  True
10119  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10120  False
10121  """
10122  return isinstance(a, SeqRef) and a.is_string_value()
10123 
10124 
def is_string_value(a)
Definition: z3py.py:10115

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

2639 def is_sub(a):
2640  """Return `True` if `a` is an expression of the form b - c.
2641 
2642  >>> x, y = Ints('x y')
2643  >>> is_sub(x - y)
2644  True
2645  >>> is_sub(x + y)
2646  False
2647  """
2648  return is_app_of(a, Z3_OP_SUB)
2649 
def is_sub(a)
Definition: z3py.py:2639

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

2757 def is_to_int(a):
2758  """Return `True` if `a` is an expression of the form ToInt(b).
2759 
2760  >>> x = Real('x')
2761  >>> n = ToInt(x)
2762  >>> n
2763  ToInt(x)
2764  >>> is_to_int(n)
2765  True
2766  >>> is_to_int(x)
2767  False
2768  """
2769  return is_app_of(a, Z3_OP_TO_INT)
2770 
def is_to_int(a)
Definition: z3py.py:2757

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

2743 def is_to_real(a):
2744  """Return `True` if `a` is an expression of the form ToReal(b).
2745 
2746  >>> x = Int('x')
2747  >>> n = ToReal(x)
2748  >>> n
2749  ToReal(x)
2750  >>> is_to_real(n)
2751  True
2752  >>> is_to_real(x)
2753  False
2754  """
2755  return is_app_of(a, Z3_OP_TO_REAL)
2756 
def is_to_real(a)
Definition: z3py.py:2743

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

1459 def is_true(a):
1460  """Return `True` if `a` is the Z3 true expression.
1461 
1462  >>> p = Bool('p')
1463  >>> is_true(p)
1464  False
1465  >>> is_true(simplify(p == p))
1466  True
1467  >>> x = Real('x')
1468  >>> is_true(x == 0)
1469  False
1470  >>> # True is a Python Boolean expression
1471  >>> is_true(True)
1472  False
1473  """
1474  return is_app_of(a, Z3_OP_TRUE)
1475 
def is_true(a)
Definition: z3py.py:1459

Referenced by AstRef.__bool__().

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

1200 def is_var(a):
1201  """Return `True` if `a` is variable.
1202 
1203  Z3 uses de-Bruijn indices for representing bound variables in
1204  quantifiers.
1205 
1206  >>> x = Int('x')
1207  >>> is_var(x)
1208  False
1209  >>> is_const(x)
1210  True
1211  >>> f = Function('f', IntSort(), IntSort())
1212  >>> # Z3 replaces x with bound variables when ForAll is executed.
1213  >>> q = ForAll(x, f(x) == x)
1214  >>> b = q.body()
1215  >>> b
1216  f(Var(0)) == Var(0)
1217  >>> b.arg(1)
1218  Var(0)
1219  >>> is_var(b.arg(1))
1220  True
1221  """
1222  return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1223 

Referenced by get_var_index().

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

3181 def IsInt(a):
3182  """ Return the Z3 predicate IsInt(a).
3183 
3184  >>> x = Real('x')
3185  >>> IsInt(x + "1/2")
3186  IsInt(x + 1/2)
3187  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3188  [x = 1/2]
3189  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3190  no solution
3191  """
3192  if z3_debug():
3193  _z3_assert(a.is_real(), "Z3 real expression expected.")
3194  ctx = a.ctx
3195  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3196 
def IsInt(a)
Definition: z3py.py:3181
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.

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

4692 def IsMember(e, s):
4693  """ Check if e is a member of set s
4694  >>> a = Const('a', SetSort(IntSort()))
4695  >>> IsMember(1, a)
4696  a[1]
4697  """
4698  ctx = _ctx_from_ast_arg_list([s,e])
4699  e = _py2expr(e, ctx)
4700  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4701 
def IsMember(e, s)
Definition: z3py.py:4692
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.

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

4702 def IsSubset(a, b):
4703  """ Check if a is a subset of b
4704  >>> a = Const('a', SetSort(IntSort()))
4705  >>> b = Const('b', SetSort(IntSort()))
4706  >>> IsSubset(a, b)
4707  subset(a, b)
4708  """
4709  ctx = _ctx_from_ast_arg_list([a, b])
4710  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4711 
4712 
def IsSubset(a, b)
Definition: z3py.py:4702
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.

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

4542 def K(dom, v):
4543  """Return a Z3 constant array expression.
4544 
4545  >>> a = K(IntSort(), 10)
4546  >>> a
4547  K(Int, 10)
4548  >>> a.sort()
4549  Array(Int, Int)
4550  >>> i = Int('i')
4551  >>> a[i]
4552  K(Int, 10)[i]
4553  >>> simplify(a[i])
4554  10
4555  """
4556  if z3_debug():
4557  _z3_assert(is_sort(dom), "Z3 sort expected")
4558  ctx = dom.ctx
4559  if not is_expr(v):
4560  v = _py2expr(v, ctx)
4561  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4562 
def K(dom, v)
Definition: z3py.py:4542
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.

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

2102 def Lambda(vs, body):
2103  """Create a Z3 lambda expression.
2104 
2105  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2106  >>> mem0 = Array('mem0', IntSort(), IntSort())
2107  >>> lo, hi, e, i = Ints('lo hi e i')
2108  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2109  >>> mem1
2110  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2111  """
2112  ctx = body.ctx
2113  if is_app(vs):
2114  vs = [vs]
2115  num_vars = len(vs)
2116  _vs = (Ast * num_vars)()
2117  for i in range(num_vars):
2118 
2119  _vs[i] = vs[i].as_ast()
2120  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2121 
def Lambda(vs, body)
Definition: z3py.py:2102
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, unsigned num_bound, Z3_app const bound[], Z3_ast body)
Create a lambda expression using a list of constants that form the set of bound variables.

◆ LastIndexOf()

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

Definition at line 10278 of file z3py.py.

10278 def LastIndexOf(s, substr):
10279  """Retrieve the last index of substring within a string"""
10280  ctx = None
10281  ctx = _get_ctx2(s, substr, ctx)
10282  s = _coerce_seq(s, ctx)
10283  substr = _coerce_seq(substr, ctx)
10284  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10285 
10286 
def LastIndexOf(s, substr)
Definition: z3py.py:10278
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 10287 of file z3py.py.

10287 def Length(s):
10288  """Obtain the length of a sequence 's'
10289  >>> l = Length(StringVal("abc"))
10290  >>> simplify(l)
10291  3
10292  """
10293  s = _coerce_seq(s)
10294  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10295 
def Length(s)
Definition: z3py.py:10287
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.

◆ LinearOrder()

def z3py.LinearOrder (   a,
  index 
)

Definition at line 10476 of file z3py.py.

10476 def LinearOrder(a, index):
10477  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10478 
def LinearOrder(a, index)
Definition: z3py.py:10476
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 10447 of file z3py.py.

10447 def Loop(re, lo, hi=0):
10448  """Create the regular expression accepting between a lower and upper bound repetitions
10449  >>> re = Loop(Re("a"), 1, 3)
10450  >>> print(simplify(InRe("aa", re)))
10451  True
10452  >>> print(simplify(InRe("aaaa", re)))
10453  False
10454  >>> print(simplify(InRe("", re)))
10455  False
10456  """
10457  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10458 
def Loop(re, lo, hi=0)
Definition: z3py.py:10447
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...

◆ LShR()

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

4054 def LShR(a, b):
4055  """Create the Z3 expression logical right shift.
4056 
4057  Use the operator >> for the arithmetical right shift.
4058 
4059  >>> x, y = BitVecs('x y', 32)
4060  >>> LShR(x, y)
4061  LShR(x, y)
4062  >>> (x >> y).sexpr()
4063  '(bvashr x y)'
4064  >>> LShR(x, y).sexpr()
4065  '(bvlshr x y)'
4066  >>> BitVecVal(4, 3)
4067  4
4068  >>> BitVecVal(4, 3).as_signed_long()
4069  -4
4070  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4071  -2
4072  >>> simplify(BitVecVal(4, 3) >> 1)
4073  6
4074  >>> simplify(LShR(BitVecVal(4, 3), 1))
4075  2
4076  >>> simplify(BitVecVal(2, 3) >> 1)
4077  1
4078  >>> simplify(LShR(BitVecVal(2, 3), 1))
4079  1
4080  """
4081  _check_bv_args(a, b)
4082  a, b = _coerce_exprs(a, b)
4083  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4084 
def LShR(a, b)
Definition: z3py.py:4054
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.

◆ 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.

211 def 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__(), help_simplify(), and simplify_param_descrs().

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

4520 def Map(f, *args):
4521  """Return a Z3 map array expression.
4522 
4523  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4524  >>> a1 = Array('a1', IntSort(), IntSort())
4525  >>> a2 = Array('a2', IntSort(), IntSort())
4526  >>> b = Map(f, a1, a2)
4527  >>> b
4528  Map(f, a1, a2)
4529  >>> prove(b[0] == f(a1[0], a2[0]))
4530  proved
4531  """
4532  args = _get_args(args)
4533  if z3_debug():
4534  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4535  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4536  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4537  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4538  _args, sz = _to_ast_array(args)
4539  ctx = f.ctx
4540  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4541 
def Map(f, *args)
Definition: z3py.py:4520
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const *args)
Map f on the argument arrays.

◆ mk_not()

def z3py.mk_not (   a)

Definition at line 1687 of file z3py.py.

1687 def mk_not(a):
1688  if is_not(a):
1689  return a.arg(0)
1690  else:
1691  return Not(a)
1692 
def mk_not(a)
Definition: z3py.py:1687

◆ Model()

def z3py.Model (   ctx = None)

Definition at line 6277 of file z3py.py.

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

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

1797 def MultiPattern(*args):
1798  """Create a Z3 multi-pattern using the given expressions `*args`
1799 
1800  >>> f = Function('f', IntSort(), IntSort())
1801  >>> g = Function('g', IntSort(), IntSort())
1802  >>> x = Int('x')
1803  >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1804  >>> q
1805  ForAll(x, f(x) != g(x))
1806  >>> q.num_patterns()
1807  1
1808  >>> is_pattern(q.pattern(0))
1809  True
1810  >>> q.pattern(0)
1811  MultiPattern(f(Var(0)), g(Var(0)))
1812  """
1813  if z3_debug():
1814  _z3_assert(len(args) > 0, "At least one argument expected")
1815  _z3_assert(all([ is_expr(a) for a in args ]), "Z3 expressions expected")
1816  ctx = args[0].ctx
1817  args, sz = _to_ast_array(args)
1818  return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
1819 
def MultiPattern(*args)
Definition: z3py.py:1797
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.

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

1669 def Not(a, ctx=None):
1670  """Create a Z3 not expression or probe.
1671 
1672  >>> p = Bool('p')
1673  >>> Not(Not(p))
1674  Not(Not(p))
1675  >>> simplify(Not(Not(p)))
1676  p
1677  """
1678  ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1679  if is_probe(a):
1680  # Not is also used to build probes
1681  return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1682  else:
1683  s = BoolSort(ctx)
1684  a = s.cast(a)
1685  return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1686 
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 fpNEQ(), mk_not(), and prove().

◆ 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.

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

10419 def Option(re):
10420  """Create the regular expression that optionally accepts the argument.
10421  >>> re = Option(Re("a"))
10422  >>> print(simplify(InRe("a", re)))
10423  True
10424  >>> print(simplify(InRe("", re)))
10425  True
10426  >>> print(simplify(InRe("aa", re)))
10427  False
10428  """
10429  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10430 
def Option(re)
Definition: z3py.py:10419
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].

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

1732 def Or(*args):
1733  """Create a Z3 or-expression or or-probe.
1734 
1735  >>> p, q, r = Bools('p q r')
1736  >>> Or(p, q, r)
1737  Or(p, q, r)
1738  >>> P = BoolVector('p', 5)
1739  >>> Or(P)
1740  Or(p__0, p__1, p__2, p__3, p__4)
1741  """
1742  last_arg = None
1743  if len(args) > 0:
1744  last_arg = args[len(args)-1]
1745  if isinstance(last_arg, Context):
1746  ctx = args[len(args)-1]
1747  args = args[:len(args)-1]
1748  elif len(args) == 1 and isinstance(args[0], AstVector):
1749  ctx = args[0].ctx
1750  args = [a for a in args[0]]
1751  else:
1752  ctx = None
1753  args = _get_args(args)
1754  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1755  if z3_debug():
1756  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1757  if _has_probe(args):
1758  return _probe_or(args, ctx)
1759  else:
1760  args = _coerce_expr_list(args, ctx)
1761  _args, sz = _to_ast_array(args)
1762  return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1763 
def Or(*args)
Definition: z3py.py:1732
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.as_expr().

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

7820 def OrElse(*ts, **ks):
7821  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7822 
7823  >>> x = Int('x')
7824  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7825  >>> # Tactic split-clause fails if there is no clause in the given goal.
7826  >>> t(x == 0)
7827  [[x == 0]]
7828  >>> t(Or(x == 0, x == 1))
7829  [[x == 0], [x == 1]]
7830  """
7831  if z3_debug():
7832  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7833  ctx = ks.get('ctx', None)
7834  num = len(ts)
7835  r = ts[0]
7836  for i in range(num - 1):
7837  r = _or_else(r, ts[i+1], ctx)
7838  return r
7839 
def OrElse(*ts, **ks)
Definition: z3py.py:7820

◆ ParAndThen()

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

Definition at line 7872 of file z3py.py.

7872 def ParAndThen(t1, t2, ctx=None):
7873  """Alias for ParThen(t1, t2, ctx)."""
7874  return ParThen(t1, t2, ctx)
7875 
def ParThen(t1, t2, ctx=None)
Definition: z3py.py:7858
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7872

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

7840 def ParOr(*ts, **ks):
7841  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7842 
7843  >>> x = Int('x')
7844  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7845  >>> t(x + 1 == 2)
7846  [[x == 1]]
7847  """
7848  if z3_debug():
7849  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7850  ctx = _get_ctx(ks.get('ctx', None))
7851  ts = [ _to_tactic(t, ctx) for t in ts ]
7852  sz = len(ts)
7853  _args = (TacticObj * sz)()
7854  for i in range(sz):
7855  _args[i] = ts[i].tactic
7856  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7857 
def ParOr(*ts, **ks)
Definition: z3py.py:7840
Z3_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[])
Return a tactic that applies the given tactics in parallel.

◆ parse_smt2_file()

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

8645 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8646  """Parse a file in SMT 2.0 format using the given sorts and decls.
8647 
8648  This function is similar to parse_smt2_string().
8649  """
8650  ctx = _get_ctx(ctx)
8651  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8652  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8653  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8654 
8655 
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8645
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 8625 of file z3py.py.

8625 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8626  """Parse a string in SMT 2.0 format using the given sorts and decls.
8627 
8628  The arguments sorts and decls are Python dictionaries used to initialize
8629  the symbol table used for the SMT 2.0 parser.
8630 
8631  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8632  [x > 0, x < 10]
8633  >>> x, y = Ints('x y')
8634  >>> f = Function('f', IntSort(), IntSort())
8635  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8636  [x + f(y) > 0]
8637  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8638  [a > 0]
8639  """
8640  ctx = _get_ctx(ctx)
8641  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8642  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8643  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8644 
def parse_smt2_string(s, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8625
Z3_ast_vector Z3_API Z3_parse_smtlib2_string(Z3_context c, Z3_string str, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Parse the given string using the SMT-LIB2 parser.

◆ ParThen()

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

7858 def ParThen(t1, t2, ctx=None):
7859  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7860 
7861  >>> x, y = Ints('x y')
7862  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7863  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7864  [[x == 1, y == 2], [x == 2, y == 3]]
7865  """
7866  t1 = _to_tactic(t1, ctx)
7867  t2 = _to_tactic(t2, ctx)
7868  if z3_debug():
7869  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7870  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7871 
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().

◆ PartialOrder()

def z3py.PartialOrder (   a,
  index 
)

Definition at line 10473 of file z3py.py.

10473 def PartialOrder(a, index):
10474  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10475 
def PartialOrder(a, index)
Definition: z3py.py:10473
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 8432 of file z3py.py.

8432 def PbEq(args, k, ctx = None):
8433  """Create a Pseudo-Boolean inequality k constraint.
8434 
8435  >>> a, b, c = Bools('a b c')
8436  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8437  """
8438  _z3_check_cint_overflow(k, "k")
8439  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8440  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8441 
8442 
def PbEq(args, k, ctx=None)
Definition: z3py.py:8432
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.

◆ PbGe()

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

8422 def PbGe(args, k):
8423  """Create a Pseudo-Boolean inequality k constraint.
8424 
8425  >>> a, b, c = Bools('a b c')
8426  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8427  """
8428  _z3_check_cint_overflow(k, "k")
8429  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8430  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8431 
def PbGe(args, k)
Definition: z3py.py:8422
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.

◆ PbLe()

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

8412 def PbLe(args, k):
8413  """Create a Pseudo-Boolean inequality k constraint.
8414 
8415  >>> a, b, c = Bools('a b c')
8416  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8417  """
8418  _z3_check_cint_overflow(k, "k")
8419  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8420  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8421 
def PbLe(args, k)
Definition: z3py.py:8412
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.

◆ PiecewiseLinearOrder()

def z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 10482 of file z3py.py.

10482 def PiecewiseLinearOrder(a, index):
10483  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10484 
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10482
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 10407 of file z3py.py.

10407 def Plus(re):
10408  """Create the regular expression accepting one or more repetitions of argument.
10409  >>> re = Plus(Re("a"))
10410  >>> print(simplify(InRe("aa", re)))
10411  True
10412  >>> print(simplify(InRe("ab", re)))
10413  False
10414  >>> print(simplify(InRe("", re)))
10415  False
10416  """
10417  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10418 
def Plus(re)
Definition: z3py.py:10407
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.

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

10197 def PrefixOf(a, b):
10198  """Check if 'a' is a prefix of 'b'
10199  >>> s1 = PrefixOf("ab", "abc")
10200  >>> simplify(s1)
10201  True
10202  >>> s2 = PrefixOf("bc", "abc")
10203  >>> simplify(s2)
10204  False
10205  """
10206  ctx = _get_ctx2(a, b)
10207  a = _coerce_seq(a, ctx)
10208  b = _coerce_seq(b, ctx)
10209  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10210 
def PrefixOf(a, b)
Definition: z3py.py:10197
Z3_ast Z3_API Z3_mk_seq_prefix(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if prefix is a prefix of s.

◆ probe_description()

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

>>> d = probe_description('memory')

Definition at line 8130 of file z3py.py.

8130 def probe_description(name, ctx=None):
8131  """Return a short description for the probe named `name`.
8132 
8133  >>> d = probe_description('memory')
8134  """
8135  ctx = _get_ctx(ctx)
8136  return Z3_probe_get_descr(ctx.ref(), name)
8137 
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().

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

8120 def probes(ctx=None):
8121  """Return a list of all available probes in Z3.
8122 
8123  >>> l = probes()
8124  >>> l.count('memory') == 1
8125  True
8126  """
8127  ctx = _get_ctx(ctx)
8128  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8129 
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().

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

8328 def Product(*args):
8329  """Create the product of the Z3 expressions.
8330 
8331  >>> a, b, c = Ints('a b c')
8332  >>> Product(a, b, c)
8333  a*b*c
8334  >>> Product([a, b, c])
8335  a*b*c
8336  >>> A = IntVector('a', 5)
8337  >>> Product(A)
8338  a__0*a__1*a__2*a__3*a__4
8339  """
8340  args = _get_args(args)
8341  if len(args) == 0:
8342  return 1
8343  ctx = _ctx_from_ast_arg_list(args)
8344  if ctx is None:
8345  return _reduce(lambda a, b: a * b, args, 1)
8346  args = _coerce_expr_list(args, ctx)
8347  if is_bv(args[0]):
8348  return _reduce(lambda a, b: a * b, args, 1)
8349  else:
8350  _args, sz = _to_ast_array(args)
8351  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8352 
def Product(*args)
Definition: z3py.py:8328
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].

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

8500 def prove(claim, **keywords):
8501  """Try to prove the given claim.
8502 
8503  This is a simple function for creating demonstrations. It tries to prove
8504  `claim` by showing the negation is unsatisfiable.
8505 
8506  >>> p, q = Bools('p q')
8507  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8508  proved
8509  """
8510  if z3_debug():
8511  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8512  s = Solver()
8513  s.set(**keywords)
8514  s.add(Not(claim))
8515  if keywords.get('show', False):
8516  print(s)
8517  r = s.check()
8518  if r == unsat:
8519  print("proved")
8520  elif r == unknown:
8521  print("failed to prove")
8522  print(s.model())
8523  else:
8524  print("counterexample")
8525  print(s.model())
8526 
def prove(claim, **keywords)
Definition: z3py.py:8500

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

3033 def Q(a, b, ctx=None):
3034  """Return a Z3 rational a/b.
3035 
3036  If `ctx=None`, then the global context is used.
3037 
3038  >>> Q(3,5)
3039  3/5
3040  >>> Q(3,5).sort()
3041  Real
3042  """
3043  return simplify(RatVal(a, b))
3044 
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8224
def Q(a, b, ctx=None)
Definition: z3py.py:3033
def RatVal(a, b, ctx=None)
Definition: z3py.py:3018

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

10459 def Range(lo, hi, ctx = None):
10460  """Create the range regular expression over two sequences of length 1
10461  >>> range = Range("a","z")
10462  >>> print(simplify(InRe("b", range)))
10463  True
10464  >>> print(simplify(InRe("bb", range)))
10465  False
10466  """
10467  lo = _coerce_seq(lo, ctx)
10468  hi = _coerce_seq(hi, ctx)
10469  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10470 
10471 # Special Relations
10472 
def Range(lo, hi, ctx=None)
Definition: z3py.py:10459
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.

◆ RatVal()

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

3018 def RatVal(a, b, ctx=None):
3019  """Return a Z3 rational a/b.
3020 
3021  If `ctx=None`, then the global context is used.
3022 
3023  >>> RatVal(3,5)
3024  3/5
3025  >>> RatVal(3,5).sort()
3026  Real
3027  """
3028  if z3_debug():
3029  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3030  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3031  return simplify(RealVal(a, ctx)/RealVal(b, ctx))
3032 

Referenced by Q().

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

10319 def Re(s, ctx=None):
10320  """The regular expression that accepts sequence 's'
10321  >>> s1 = Re("ab")
10322  >>> s2 = Re(StringVal("ab"))
10323  >>> s3 = Re(Unit(BoolVal(True)))
10324  """
10325  s = _coerce_seq(s, ctx)
10326  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10327 
10328 
10329 
10330 
def Re(s, ctx=None)
Definition: z3py.py:10319
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.

◆ Real()

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

3094 def Real(name, ctx=None):
3095  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3096 
3097  >>> x = Real('x')
3098  >>> is_real(x)
3099  True
3100  >>> is_real(x + 1)
3101  True
3102  """
3103  ctx = _get_ctx(ctx)
3104  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3105 
def Real(name, ctx=None)
Definition: z3py.py:3094

Referenced by Reals(), and RealVector().

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

3106 def Reals(names, ctx=None):
3107  """Return a tuple of real constants.
3108 
3109  >>> x, y, z = Reals('x y z')
3110  >>> Sum(x, y, z)
3111  x + y + z
3112  >>> Sum(x, y, z).sort()
3113  Real
3114  """
3115  ctx = _get_ctx(ctx)
3116  if isinstance(names, str):
3117  names = names.split(" ")
3118  return [Real(name, ctx) for name in names]
3119 
def Reals(names, ctx=None)
Definition: z3py.py:3106

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

2958 def RealSort(ctx=None):
2959  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2960 
2961  >>> RealSort()
2962  Real
2963  >>> x = Const('x', RealSort())
2964  >>> is_real(x)
2965  True
2966  >>> is_int(x)
2967  False
2968  >>> x.sort() == RealSort()
2969  True
2970  """
2971  ctx = _get_ctx(ctx)
2972  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2973 
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.

Referenced by FreshReal(), Real(), RealVal(), and RealVar().

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

3000 def RealVal(val, ctx=None):
3001  """Return a Z3 real value.
3002 
3003  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3004  If `ctx=None`, then the global context is used.
3005 
3006  >>> RealVal(1)
3007  1
3008  >>> RealVal(1).sort()
3009  Real
3010  >>> RealVal("3/5")
3011  3/5
3012  >>> RealVal("1.5")
3013  3/2
3014  """
3015  ctx = _get_ctx(ctx)
3016  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3017 

Referenced by Cbrt(), AlgebraicNumRef.index(), RatVal(), 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 1363 of file z3py.py.

1363 def RealVar(idx, ctx=None):
1364  """
1365  Create a real free variable. Free variables are used to create quantified formulas.
1366  They are also used to create polynomials.
1367 
1368  >>> RealVar(0)
1369  Var(0)
1370  """
1371  return Var(idx, RealSort(ctx))
1372 
def Var(idx, s)
Definition: z3py.py:1351
def RealVar(idx, ctx=None)
Definition: z3py.py:1363

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

1373 def RealVarVector(n, ctx=None):
1374  """
1375  Create a list of Real free variables.
1376  The variables have ids: 0, 1, ..., n-1
1377 
1378  >>> x0, x1, x2, x3 = RealVarVector(4)
1379  >>> x2
1380  Var(2)
1381  """
1382  return [ RealVar(i, ctx) for i in range(n) ]
1383 
def RealVarVector(n, ctx=None)
Definition: z3py.py:1373

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

3120 def RealVector(prefix, sz, ctx=None):
3121  """Return a list of real constants of size `sz`.
3122 
3123  >>> X = RealVector('x', 3)
3124  >>> X
3125  [x__0, x__1, x__2]
3126  >>> Sum(X)
3127  x__0 + x__1 + x__2
3128  >>> Sum(X).sort()
3129  Real
3130  """
3131  ctx = _get_ctx(ctx)
3132  return [ Real('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3133 
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3120

◆ RecAddDefinition()

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

Definition at line 860 of file z3py.py.

860 def RecAddDefinition(f, args, body):
861  """Set the body of a recursive function.
862  Recursive definitions can be simplified if they are applied to ground
863  arguments.
864  >>> ctx = Context()
865  >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
866  >>> n = Int('n', ctx)
867  >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
868  >>> simplify(fac(5))
869  120
870  >>> s = Solver(ctx=ctx)
871  >>> s.add(fac(n) < 3)
872  >>> s.check()
873  sat
874  >>> s.model().eval(fac(5))
875  120
876  """
877  if is_app(args):
878  args = [args]
879  ctx = body.ctx
880  args = _get_args(args)
881  n = len(args)
882  _args = (Ast * n)()
883  for i in range(n):
884  _args[i] = args[i].ast
885  Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
886 
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body)
Define the body of a recursive function.

◆ RecFunction()

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

Definition at line 843 of file z3py.py.

843 def RecFunction(name, *sig):
844  """Create a new Z3 recursive with the given sorts."""
845  sig = _get_args(sig)
846  if z3_debug():
847  _z3_assert(len(sig) > 0, "At least two arguments expected")
848  arity = len(sig) - 1
849  rng = sig[arity]
850  if z3_debug():
851  _z3_assert(is_sort(rng), "Z3 sort expected")
852  dom = (Sort * arity)()
853  for i in range(arity):
854  if z3_debug():
855  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
856  dom[i] = sig[i].ast
857  ctx = rng.ctx
858  return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
859 
def RecFunction(name, *sig)
Definition: z3py.py:843
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a recursive function.

◆ Repeat()

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

7902 def Repeat(t, max=4294967295, ctx=None):
7903  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7904 
7905  >>> x, y = Ints('x y')
7906  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7907  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7908  >>> r = t(c)
7909  >>> for subgoal in r: print(subgoal)
7910  [x == 0, y == 0, x > y]
7911  [x == 0, y == 1, x > y]
7912  [x == 1, y == 0, x > y]
7913  [x == 1, y == 1, x > y]
7914  >>> t = Then(t, Tactic('propagate-values'))
7915  >>> t(c)
7916  [[x == 1, y == 0]]
7917  """
7918  t = _to_tactic(t, ctx)
7919  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7920 
def Repeat(t, max=4294967295, ctx=None)
Definition: z3py.py:7902
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...

◆ RepeatBitVec()

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

4171 def RepeatBitVec(n, a):
4172  """Return an expression representing `n` copies of `a`.
4173 
4174  >>> x = BitVec('x', 8)
4175  >>> n = RepeatBitVec(4, x)
4176  >>> n
4177  RepeatBitVec(4, x)
4178  >>> n.size()
4179  32
4180  >>> v0 = BitVecVal(10, 4)
4181  >>> print("%.x" % v0.as_long())
4182  a
4183  >>> v = simplify(RepeatBitVec(4, v0))
4184  >>> v.size()
4185  16
4186  >>> print("%.x" % v.as_long())
4187  aaaa
4188  """
4189  if z3_debug():
4190  _z3_assert(_is_int(n), "First argument must be an integer")
4191  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4192  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4193 
def RepeatBitVec(n, a)
Definition: z3py.py:4171
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.

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

10244 def Replace(s, src, dst):
10245  """Replace the first occurrence of 'src' by 'dst' in 's'
10246  >>> r = Replace("aaa", "a", "b")
10247  >>> simplify(r)
10248  "baa"
10249  """
10250  ctx = _get_ctx2(dst, s)
10251  if ctx is None and is_expr(src):
10252  ctx = src.ctx
10253  src = _coerce_seq(src, ctx)
10254  dst = _coerce_seq(dst, ctx)
10255  s = _coerce_seq(s, ctx)
10256  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10257 
def Replace(s, src, dst)
Definition: z3py.py:10244
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.

◆ reset_params()

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

Definition at line 263 of file z3py.py.

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

10339 def ReSort(s):
10340  if is_ast(s):
10341  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10342  if s is None or isinstance(s, Context):
10343  ctx = _get_ctx(s)
10344  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10345  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10346 
10347 
def ReSort(s)
Definition: z3py.py:10339
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.

◆ RNA()

def z3py.RNA (   ctx = None)

Definition at line 9034 of file z3py.py.

9034 def RNA (ctx=None):
9035  ctx = _get_ctx(ctx)
9036  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9037 
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 9026 of file z3py.py.

9026 def RNE (ctx=None):
9027  ctx = _get_ctx(ctx)
9028  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9029 
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 get_default_rounding_mode().

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

4085 def RotateLeft(a, b):
4086  """Return an expression representing `a` rotated to the left `b` times.
4087 
4088  >>> a, b = BitVecs('a b', 16)
4089  >>> RotateLeft(a, b)
4090  RotateLeft(a, b)
4091  >>> simplify(RotateLeft(a, 0))
4092  a
4093  >>> simplify(RotateLeft(a, 16))
4094  a
4095  """
4096  _check_bv_args(a, b)
4097  a, b = _coerce_exprs(a, b)
4098  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4099 
def RotateLeft(a, b)
Definition: z3py.py:4085
Z3_ast Z3_API Z3_mk_ext_rotate_left(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the left t2 times.

◆ RotateRight()

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

4100 def RotateRight(a, b):
4101  """Return an expression representing `a` rotated to the right `b` times.
4102 
4103  >>> a, b = BitVecs('a b', 16)
4104  >>> RotateRight(a, b)
4105  RotateRight(a, b)
4106  >>> simplify(RotateRight(a, 0))
4107  a
4108  >>> simplify(RotateRight(a, 16))
4109  a
4110  """
4111  _check_bv_args(a, b)
4112  a, b = _coerce_exprs(a, b)
4113  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4114 
def RotateRight(a, b)
Definition: z3py.py:4100
Z3_ast Z3_API Z3_mk_ext_rotate_right(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the right t2 times.

◆ RoundNearestTiesToAway()

def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 9030 of file z3py.py.

9030 def RoundNearestTiesToAway(ctx=None):
9031  ctx = _get_ctx(ctx)
9032  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9033 
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9030

◆ RoundNearestTiesToEven()

def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 9022 of file z3py.py.

9022 def RoundNearestTiesToEven(ctx=None):
9023  ctx = _get_ctx(ctx)
9024  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9025 
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9022

◆ RoundTowardNegative()

def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9046 of file z3py.py.

9046 def RoundTowardNegative(ctx=None):
9047  ctx = _get_ctx(ctx)
9048  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9049 
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9046
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 9038 of file z3py.py.

9038 def RoundTowardPositive(ctx=None):
9039  ctx = _get_ctx(ctx)
9040  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9041 
def RoundTowardPositive(ctx=None)
Definition: z3py.py:9038
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 9054 of file z3py.py.

9054 def RoundTowardZero(ctx=None):
9055  ctx = _get_ctx(ctx)
9056  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9057 
def RoundTowardZero(ctx=None)
Definition: z3py.py:9054
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 9050 of file z3py.py.

9050 def RTN(ctx=None):
9051  ctx = _get_ctx(ctx)
9052  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9053 

Referenced by get_default_rounding_mode().

◆ RTP()

def z3py.RTP (   ctx = None)

Definition at line 9042 of file z3py.py.

9042 def RTP(ctx=None):
9043  ctx = _get_ctx(ctx)
9044  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9045 

Referenced by get_default_rounding_mode().

◆ RTZ()

def z3py.RTZ (   ctx = None)

Definition at line 9058 of file z3py.py.

9058 def RTZ(ctx=None):
9059  ctx = _get_ctx(ctx)
9060  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9061 

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

4505 def Select(a, i):
4506  """Return a Z3 select array expression.
4507 
4508  >>> a = Array('a', IntSort(), IntSort())
4509  >>> i = Int('i')
4510  >>> Select(a, i)
4511  a[i]
4512  >>> eq(Select(a, i), a[i])
4513  True
4514  """
4515  if z3_debug():
4516  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4517  return a[i]
4518 
4519 
def Select(a, i)
Definition: z3py.py:4505

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

10022 def SeqSort(s):
10023  """Create a sequence sort over elements provided in the argument
10024  >>> s = SeqSort(IntSort())
10025  >>> s == Unit(IntVal(1)).sort()
10026  True
10027  """
10028  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10029 
def SeqSort(s)
Definition: z3py.py:10022
Z3_sort Z3_API Z3_mk_seq_sort(Z3_context c, Z3_sort s)
Create a sequence sort out of the sort for the elements.

◆ set_default_fp_sort()

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

Definition at line 8698 of file z3py.py.

8698 def set_default_fp_sort(ebits, sbits, ctx=None):
8699  global _dflt_fpsort_ebits
8700  global _dflt_fpsort_sbits
8701  _dflt_fpsort_ebits = ebits
8702  _dflt_fpsort_sbits = sbits
8703 
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8698

◆ set_default_rounding_mode()

def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 8682 of file z3py.py.

8682 def set_default_rounding_mode(rm, ctx=None):
8683  global _dflt_rounding_mode
8684  if is_fprm_value(rm):
8685  _dflt_rounding_mode = rm.decl().kind()
8686  else:
8687  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8688  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8689  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8690  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8691  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8692  "illegal rounding mode")
8693  _dflt_rounding_mode = rm
8694 
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8682

◆ set_option()

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

Definition at line 268 of file z3py.py.

268 def 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.

240 def 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().

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

4653 def SetAdd(s, e):
4654  """ Add element e to set s
4655  >>> a = Const('a', SetSort(IntSort()))
4656  >>> SetAdd(a, 1)
4657  Store(a, 1, True)
4658  """
4659  ctx = _ctx_from_ast_arg_list([s,e])
4660  e = _py2expr(e, ctx)
4661  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4662 
def SetAdd(s, e)
Definition: z3py.py:4653
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.

◆ SetComplement()

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

Definition at line 4673 of file z3py.py.

4673 def SetComplement(s):
4674  """ The complement of set s
4675  >>> a = Const('a', SetSort(IntSort()))
4676  >>> SetComplement(a)
4677  complement(a)
4678  """
4679  ctx = s.ctx
4680  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4681 
def SetComplement(s)
Definition: z3py.py:4673
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.

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

4663 def SetDel(s, e):
4664  """ Remove element e to set s
4665  >>> a = Const('a', SetSort(IntSort()))
4666  >>> SetDel(a, 1)
4667  Store(a, 1, False)
4668  """
4669  ctx = _ctx_from_ast_arg_list([s,e])
4670  e = _py2expr(e, ctx)
4671  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4672 
def SetDel(s, e)
Definition: z3py.py:4663
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.

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

4682 def SetDifference(a, b):
4683  """ The set difference of a and b
4684  >>> a = Const('a', SetSort(IntSort()))
4685  >>> b = Const('b', SetSort(IntSort()))
4686  >>> SetDifference(a, b)
4687  setminus(a, b)
4688  """
4689  ctx = _ctx_from_ast_arg_list([a, b])
4690  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4691 
def SetDifference(a, b)
Definition: z3py.py:4682
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.

◆ SetHasSize()

def z3py.SetHasSize (   a,
  k 
)

Definition at line 4574 of file z3py.py.

4574 def SetHasSize(a, k):
4575  ctx = a.ctx
4576  k = _py2expr(k, ctx)
4577  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4578 
def SetHasSize(a, k)
Definition: z3py.py:4574
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 4641 of file z3py.py.

4641 def SetIntersect(*args):
4642  """ Take the union of sets
4643  >>> a = Const('a', SetSort(IntSort()))
4644  >>> b = Const('b', SetSort(IntSort()))
4645  >>> SetIntersect(a, b)
4646  intersection(a, b)
4647  """
4648  args = _get_args(args)
4649  ctx = _ctx_from_ast_arg_list(args)
4650  _args, sz = _to_ast_array(args)
4651  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4652 
def SetIntersect(*args)
Definition: z3py.py:4641
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.

◆ SetSort()

def z3py.SetSort (   s)

Sets.

 Create a set sort over element sort s

Definition at line 4609 of file z3py.py.

4609 def SetSort(s):
4610  """ Create a set sort over element sort s"""
4611  return ArraySort(s, BoolSort())
4612 
def SetSort(s)
Sets.
Definition: z3py.py:4609

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

4629 def SetUnion(*args):
4630  """ Take the union of sets
4631  >>> a = Const('a', SetSort(IntSort()))
4632  >>> b = Const('b', SetSort(IntSort()))
4633  >>> SetUnion(a, b)
4634  union(a, b)
4635  """
4636  args = _get_args(args)
4637  ctx = _ctx_from_ast_arg_list(args)
4638  _args, sz = _to_ast_array(args)
4639  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4640 
def SetUnion(*args)
Definition: z3py.py:4629
Z3_ast Z3_API Z3_mk_set_union(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the union of a list of sets.

◆ SignExt()

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

4115 def SignExt(n, a):
4116  """Return a bit-vector expression with `n` extra sign-bits.
4117 
4118  >>> x = BitVec('x', 16)
4119  >>> n = SignExt(8, x)
4120  >>> n.size()
4121  24
4122  >>> n
4123  SignExt(8, x)
4124  >>> n.sort()
4125  BitVec(24)
4126  >>> v0 = BitVecVal(2, 2)
4127  >>> v0
4128  2
4129  >>> v0.size()
4130  2
4131  >>> v = simplify(SignExt(6, v0))
4132  >>> v
4133  254
4134  >>> v.size()
4135  8
4136  >>> print("%.x" % v.as_long())
4137  fe
4138  """
4139  if z3_debug():
4140  _z3_assert(_is_int(n), "First argument must be an integer")
4141  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4142  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4143 
def SignExt(n, a)
Definition: z3py.py:4115
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...

◆ SimpleSolver()

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

6973 def SimpleSolver(ctx=None, logFile=None):
6974  """Return a simple general purpose solver with limited amount of preprocessing.
6975 
6976  >>> s = SimpleSolver()
6977  >>> x = Int('x')
6978  >>> s.add(x > 0)
6979  >>> s.check()
6980  sat
6981  """
6982  ctx = _get_ctx(ctx)
6983  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6984 
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6973
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.

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

8224 def simplify(a, *arguments, **keywords):
8225  """Simplify the expression `a` using the given options.
8226 
8227  This function has many options. Use `help_simplify` to obtain the complete list.
8228 
8229  >>> x = Int('x')
8230  >>> y = Int('y')
8231  >>> simplify(x + 1 + y + x + 1)
8232  2 + 2*x + y
8233  >>> simplify((x + 1)*(y + 1), som=True)
8234  1 + x + y + x*y
8235  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8236  And(Not(x == y), Not(x == 1), Not(y == 1))
8237  >>> simplify(And(x == 0, y == 1), elim_and=True)
8238  Not(Or(Not(x == 0), Not(y == 1)))
8239  """
8240  if z3_debug():
8241  _z3_assert(is_expr(a), "Z3 expression expected")
8242  if len(arguments) > 0 or len(keywords) > 0:
8243  p = args2params(arguments, keywords, a.ctx)
8244  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8245  else:
8246  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8247 
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.

Referenced by Q(), and RatVal().

◆ simplify_param_descrs()

def z3py.simplify_param_descrs ( )
Return the set of parameter descriptions for Z3 `simplify` procedure.

Definition at line 8252 of file z3py.py.

8252 def simplify_param_descrs():
8253  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8254  return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8255 
def simplify_param_descrs()
Definition: z3py.py:8252
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 8443 of file z3py.py.

8443 def solve(*args, **keywords):
8444  """Solve the constraints `*args`.
8445 
8446  This is a simple function for creating demonstrations. It creates a solver,
8447  configure it using the options in `keywords`, adds the constraints
8448  in `args`, and invokes check.
8449 
8450  >>> a = Int('a')
8451  >>> solve(a > 0, a < 2)
8452  [a = 1]
8453  """
8454  s = Solver()
8455  s.set(**keywords)
8456  s.add(*args)
8457  if keywords.get('show', False):
8458  print(s)
8459  r = s.check()
8460  if r == unsat:
8461  print("no solution")
8462  elif r == unknown:
8463  print("failed to solve")
8464  try:
8465  print(s.model())
8466  except Z3Exception:
8467  return
8468  else:
8469  print(s.model())
8470 
def solve(*args, **keywords)
Definition: z3py.py:8443

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

8471 def solve_using(s, *args, **keywords):
8472  """Solve the constraints `*args` using solver `s`.
8473 
8474  This is a simple function for creating demonstrations. It is similar to `solve`,
8475  but it uses the given solver `s`.
8476  It configures solver `s` using the options in `keywords`, adds the constraints
8477  in `args`, and invokes check.
8478  """
8479  if z3_debug():
8480  _z3_assert(isinstance(s, Solver), "Solver object expected")
8481  s.set(**keywords)
8482  s.add(*args)
8483  if keywords.get('show', False):
8484  print("Problem:")
8485  print(s)
8486  r = s.check()
8487  if r == unsat:
8488  print("no solution")
8489  elif r == unknown:
8490  print("failed to solve")
8491  try:
8492  print(s.model())
8493  except Z3Exception:
8494  return
8495  else:
8496  if keywords.get('show', False):
8497  print("Solution:")
8498  print(s.model())
8499 
def solve_using(s, *args, **keywords)
Definition: z3py.py:8471

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

6953 def SolverFor(logic, ctx=None, logFile=None):
6954  """Create a solver customized for the given logic.
6955 
6956  The parameter `logic` is a string. It should be contains
6957  the name of a SMT-LIB logic.
6958  See http://www.smtlib.org/ for the name of all available logics.
6959 
6960  >>> s = SolverFor("QF_LIA")
6961  >>> x = Int('x')
6962  >>> s.add(x > 0)
6963  >>> s.add(x < 2)
6964  >>> s.check()
6965  sat
6966  >>> s.model()
6967  [x = 1]
6968  """
6969  ctx = _get_ctx(ctx)
6970  logic = to_symbol(logic)
6971  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6972 
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6953
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic)
Create a new solver customized for the given logic. It behaves like Z3_mk_solver if the logic is unkn...

◆ Sqrt()

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

3197 def Sqrt(a, ctx=None):
3198  """ Return a Z3 expression which represents the square root of a.
3199 
3200  >>> x = Real('x')
3201  >>> Sqrt(x)
3202  x**(1/2)
3203  """
3204  if not is_expr(a):
3205  ctx = _get_ctx(ctx)
3206  a = RealVal(a, ctx)
3207  return a ** "1/2"
3208 
def Sqrt(a, ctx=None)
Definition: z3py.py:3197

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

4034 def SRem(a, b):
4035  """Create the Z3 expression signed remainder.
4036 
4037  Use the operator % for signed modulus, and URem() for unsigned remainder.
4038 
4039  >>> x = BitVec('x', 32)
4040  >>> y = BitVec('y', 32)
4041  >>> SRem(x, y)
4042  SRem(x, y)
4043  >>> SRem(x, y).sort()
4044  BitVec(32)
4045  >>> (x % y).sexpr()
4046  '(bvsmod x y)'
4047  >>> SRem(x, y).sexpr()
4048  '(bvsrem x y)'
4049  """
4050  _check_bv_args(a, b)
4051  a, b = _coerce_exprs(a, b)
4052  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4053 
def SRem(a, b)
Definition: z3py.py:4034
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).

◆ Star()

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

10435 def Star(re):
10436  """Create the regular expression accepting zero or more repetitions of argument.
10437  >>> re = Star(Re("a"))
10438  >>> print(simplify(InRe("aa", re)))
10439  True
10440  >>> print(simplify(InRe("ab", re)))
10441  False
10442  >>> print(simplify(InRe("", re)))
10443  True
10444  """
10445  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10446 
def Star(re)
Definition: z3py.py:10435
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.

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

4489 def Store(a, i, v):
4490  """Return a Z3 store array expression.
4491 
4492  >>> a = Array('a', IntSort(), IntSort())
4493  >>> i, v = Ints('i v')
4494  >>> s = Store(a, i, v)
4495  >>> s.sort()
4496  Array(Int, Int)
4497  >>> prove(s[i] == v)
4498  proved
4499  >>> j = Int('j')
4500  >>> prove(Implies(i != j, s[j] == a[j]))
4501  proved
4502  """
4503  return Update(a, i, v)
4504 
def Update(a, i, v)
Definition: z3py.py:4457
def Store(a, i, v)
Definition: z3py.py:4489

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

10130 def String(name, ctx=None):
10131  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10132 
10133  >>> x = String('x')
10134  """
10135  ctx = _get_ctx(ctx)
10136  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10137 
def StringSort(ctx=None)
Definition: z3py.py:10012
def String(name, ctx=None)
Definition: z3py.py:10130

Referenced by Strings(), and SubSeq().

◆ Strings()

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

Definition at line 10138 of file z3py.py.

10138 def Strings(names, ctx=None):
10139  """Return string constants"""
10140  ctx = _get_ctx(ctx)
10141  if isinstance(names, str):
10142  names = names.split(" ")
10143  return [String(name, ctx) for name in names]
10144 
def Strings(names, ctx=None)
Definition: z3py.py:10138

Referenced by SubSeq().

◆ StringSort()

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

Definition at line 10012 of file z3py.py.

10012 def StringSort(ctx=None):
10013  """Create a string sort
10014  >>> s = StringSort()
10015  >>> print(s)
10016  String
10017  """
10018  ctx = _get_ctx(ctx)
10019  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10020 
10021 

Referenced by String().

◆ StringVal()

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

Definition at line 10125 of file z3py.py.

10125 def StringVal(s, ctx=None):
10126  """create a string expression"""
10127  ctx = _get_ctx(ctx)
10128  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10129 
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__(), and Extract().

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

10296 def StrToInt(s):
10297  """Convert string expression to integer
10298  >>> a = StrToInt("1")
10299  >>> simplify(1 == a)
10300  True
10301  >>> b = StrToInt("2")
10302  >>> simplify(1 == b)
10303  False
10304  >>> c = StrToInt(IntToStr(2))
10305  >>> simplify(1 == c)
10306  False
10307  """
10308  s = _coerce_seq(s)
10309  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10310 
10311 
def StrToInt(s)
Definition: z3py.py:10296
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.

◆ SubSeq()

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

Definition at line 10149 of file z3py.py.

10149 def SubSeq(s, offset, length):
10150  """Extract substring or subsequence starting at offset"""
10151  return Extract(s, offset, length)
10152 
def SubSeq(s, offset, length)
Definition: z3py.py:10149

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

8256 def substitute(t, *m):
8257  """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.
8258 
8259  >>> x = Int('x')
8260  >>> y = Int('y')
8261  >>> substitute(x + 1, (x, y + 1))
8262  y + 1 + 1
8263  >>> f = Function('f', IntSort(), IntSort())
8264  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8265  1 + 1
8266  """
8267  if isinstance(m, tuple):
8268  m1 = _get_args(m)
8269  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8270  m = m1
8271  if z3_debug():
8272  _z3_assert(is_expr(t), "Z3 expression expected")
8273  _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.")
8274  num = len(m)
8275  _from = (Ast * num)()
8276  _to = (Ast * num)()
8277  for i in range(num):
8278  _from[i] = m[i][0].as_ast()
8279  _to[i] = m[i][1].as_ast()
8280  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8281 
def substitute(t, *m)
Definition: z3py.py:8256
Z3_ast Z3_API Z3_substitute(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const from[], Z3_ast const to[])
Substitute every occurrence of from[i] in a with to[i], for i smaller than num_exprs....

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

8282 def substitute_vars(t, *m):
8283  """Substitute the free variables in t with the expression in m.
8284 
8285  >>> v0 = Var(0, IntSort())
8286  >>> v1 = Var(1, IntSort())
8287  >>> x = Int('x')
8288  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8289  >>> # replace v0 with x+1 and v1 with x
8290  >>> substitute_vars(f(v0, v1), x + 1, x)
8291  f(x + 1, x)
8292  """
8293  if z3_debug():
8294  _z3_assert(is_expr(t), "Z3 expression expected")
8295  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8296  num = len(m)
8297  _to = (Ast * num)()
8298  for i in range(num):
8299  _to[i] = m[i].as_ast()
8300  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8301 
def substitute_vars(t, *m)
Definition: z3py.py:8282
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,...

◆ SubString()

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

Definition at line 10145 of file z3py.py.

10145 def SubString(s, offset, length):
10146  """Extract substring or subsequence starting at offset"""
10147  return Extract(s, offset, length)
10148 
def SubString(s, offset, length)
Definition: z3py.py:10145

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

10211 def SuffixOf(a, b):
10212  """Check if 'a' is a suffix of 'b'
10213  >>> s1 = SuffixOf("ab", "abc")
10214  >>> simplify(s1)
10215  False
10216  >>> s2 = SuffixOf("bc", "abc")
10217  >>> simplify(s2)
10218  True
10219  """
10220  ctx = _get_ctx2(a, b)
10221  a = _coerce_seq(a, ctx)
10222  b = _coerce_seq(b, ctx)
10223  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10224 
def SuffixOf(a, b)
Definition: z3py.py:10211
Z3_ast Z3_API Z3_mk_seq_suffix(Z3_context c, Z3_ast suffix, Z3_ast s)
Check if suffix is a suffix of s.

◆ Sum()

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

8302 def Sum(*args):
8303  """Create the sum of the Z3 expressions.
8304 
8305  >>> a, b, c = Ints('a b c')
8306  >>> Sum(a, b, c)
8307  a + b + c
8308  >>> Sum([a, b, c])
8309  a + b + c
8310  >>> A = IntVector('a', 5)
8311  >>> Sum(A)
8312  a__0 + a__1 + a__2 + a__3 + a__4
8313  """
8314  args = _get_args(args)
8315  if len(args) == 0:
8316  return 0
8317  ctx = _ctx_from_ast_arg_list(args)
8318  if ctx is None:
8319  return _reduce(lambda a, b: a + b, args, 0)
8320  args = _coerce_expr_list(args, ctx)
8321  if is_bv(args[0]):
8322  return _reduce(lambda a, b: a + b, args, 0)
8323  else:
8324  _args, sz = _to_ast_array(args)
8325  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8326 
8327 
def Sum(*args)
Definition: z3py.py:8302
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].

◆ tactic_description()

def z3py.tactic_description (   name,
  ctx = None 
)
Return a short description for the tactic named `name`.

>>> d = tactic_description('simplify')

Definition at line 7939 of file z3py.py.

7939 def tactic_description(name, ctx=None):
7940  """Return a short description for the tactic named `name`.
7941 
7942  >>> d = tactic_description('simplify')
7943  """
7944  ctx = _get_ctx(ctx)
7945  return Z3_tactic_get_descr(ctx.ref(), name)
7946 
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().

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

7929 def tactics(ctx=None):
7930  """Return a list of all available tactics in Z3.
7931 
7932  >>> l = tactics()
7933  >>> l.count('simplify') == 1
7934  True
7935  """
7936  ctx = _get_ctx(ctx)
7937  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7938 
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().

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

7808 def Then(*ts, **ks):
7809  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7810 
7811  >>> x, y = Ints('x y')
7812  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7813  >>> t(And(x == 0, y > x + 1))
7814  [[Not(y <= 1)]]
7815  >>> t(And(x == 0, y > x + 1)).as_expr()
7816  Not(y <= 1)
7817  """
7818  return AndThen(*ts, **ks)
7819 
def Then(*ts, **ks)
Definition: z3py.py:7808

◆ 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.

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

3164 def ToInt(a):
3165  """ Return the Z3 expression ToInt(a).
3166 
3167  >>> x = Real('x')
3168  >>> x.sort()
3169  Real
3170  >>> n = ToInt(x)
3171  >>> n
3172  ToInt(x)
3173  >>> n.sort()
3174  Int
3175  """
3176  if z3_debug():
3177  _z3_assert(a.is_real(), "Z3 real expression expected.")
3178  ctx = a.ctx
3179  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3180 
def ToInt(a)
Definition: z3py.py:3164
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.

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

3147 def ToReal(a):
3148  """ Return the Z3 expression ToReal(a).
3149 
3150  >>> x = Int('x')
3151  >>> x.sort()
3152  Int
3153  >>> n = ToReal(x)
3154  >>> n
3155  ToReal(x)
3156  >>> n.sort()
3157  Real
3158  """
3159  if z3_debug():
3160  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3161  ctx = a.ctx
3162  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3163 
def ToReal(a)
Definition: z3py.py:3147
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.

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

10485 def TransitiveClosure(f):
10486  """Given a binary relation R, such that the two arguments have the same sort
10487  create the transitive closure relation R+.
10488  The transitive closure R+ is a new relation.
10489  """
10490  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
10491 
10492 
def TransitiveClosure(f)
Definition: z3py.py:10485
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 10479 of file z3py.py.

10479 def TreeOrder(a, index):
10480  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10481 
def TreeOrder(a, index)
Definition: z3py.py:10479
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 7921 of file z3py.py.

7921 def TryFor(t, ms, ctx=None):
7922  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7923 
7924  If `t` does not terminate in `ms` milliseconds, then it fails.
7925  """
7926  t = _to_tactic(t, ctx)
7927  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7928 
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7921
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 5012 of file z3py.py.

5012 def TupleSort(name, sorts, ctx = None):
5013  """Create a named tuple sort base on a set of underlying sorts
5014  Example:
5015  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5016  """
5017  tuple = Datatype(name, ctx)
5018  projects = [ ('project%d' % i, sorts[i]) for i in range(len(sorts)) ]
5019  tuple.declare(name, *projects)
5020  tuple = tuple.create()
5021  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5022 
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:5012

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

3994 def UDiv(a, b):
3995  """Create the Z3 expression (unsigned) division `self / other`.
3996 
3997  Use the operator / for signed division.
3998 
3999  >>> x = BitVec('x', 32)
4000  >>> y = BitVec('y', 32)
4001  >>> UDiv(x, y)
4002  UDiv(x, y)
4003  >>> UDiv(x, y).sort()
4004  BitVec(32)
4005  >>> (x / y).sexpr()
4006  '(bvsdiv x y)'
4007  >>> UDiv(x, y).sexpr()
4008  '(bvudiv x y)'
4009  """
4010  _check_bv_args(a, b)
4011  a, b = _coerce_exprs(a, b)
4012  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4013 
def UDiv(a, b)
Definition: z3py.py:3994
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.

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

3960 def UGE(a, b):
3961  """Create the Z3 expression (unsigned) `other >= self`.
3962 
3963  Use the operator >= for signed greater than or equal to.
3964 
3965  >>> x, y = BitVecs('x y', 32)
3966  >>> UGE(x, y)
3967  UGE(x, y)
3968  >>> (x >= y).sexpr()
3969  '(bvsge x y)'
3970  >>> UGE(x, y).sexpr()
3971  '(bvuge x y)'
3972  """
3973  _check_bv_args(a, b)
3974  a, b = _coerce_exprs(a, b)
3975  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3976 
def UGE(a, b)
Definition: z3py.py:3960
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.

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

3977 def UGT(a, b):
3978  """Create the Z3 expression (unsigned) `other > self`.
3979 
3980  Use the operator > for signed greater than.
3981 
3982  >>> x, y = BitVecs('x y', 32)
3983  >>> UGT(x, y)
3984  UGT(x, y)
3985  >>> (x > y).sexpr()
3986  '(bvsgt x y)'
3987  >>> UGT(x, y).sexpr()
3988  '(bvugt x y)'
3989  """
3990  _check_bv_args(a, b)
3991  a, b = _coerce_exprs(a, b)
3992  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3993 
def UGT(a, b)
Definition: z3py.py:3977
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.

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

3926 def ULE(a, b):
3927  """Create the Z3 expression (unsigned) `other <= self`.
3928 
3929  Use the operator <= for signed less than or equal to.
3930 
3931  >>> x, y = BitVecs('x y', 32)
3932  >>> ULE(x, y)
3933  ULE(x, y)
3934  >>> (x <= y).sexpr()
3935  '(bvsle x y)'
3936  >>> ULE(x, y).sexpr()
3937  '(bvule x y)'
3938  """
3939  _check_bv_args(a, b)
3940  a, b = _coerce_exprs(a, b)
3941  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3942 
def ULE(a, b)
Definition: z3py.py:3926
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.

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

3943 def ULT(a, b):
3944  """Create the Z3 expression (unsigned) `other < self`.
3945 
3946  Use the operator < for signed less than.
3947 
3948  >>> x, y = BitVecs('x y', 32)
3949  >>> ULT(x, y)
3950  ULT(x, y)
3951  >>> (x < y).sexpr()
3952  '(bvslt x y)'
3953  >>> ULT(x, y).sexpr()
3954  '(bvult x y)'
3955  """
3956  _check_bv_args(a, b)
3957  a, b = _coerce_exprs(a, b)
3958  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3959 
def ULT(a, b)
Definition: z3py.py:3943
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.

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

10371 def Union(*args):
10372  """Create union of regular expressions.
10373  >>> re = Union(Re("a"), Re("b"), Re("c"))
10374  >>> print (simplify(InRe("d", re)))
10375  False
10376  """
10377  args = _get_args(args)
10378  sz = len(args)
10379  if z3_debug():
10380  _z3_assert(sz > 0, "At least one argument expected.")
10381  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10382  if sz == 1:
10383  return args[0]
10384  ctx = args[0].ctx
10385  v = (Ast * sz)()
10386  for i in range(sz):
10387  v[i] = args[i].as_ast()
10388  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10389 
def Union(*args)
Definition: z3py.py:10371
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__().

◆ Unit()

def z3py.Unit (   a)
Create a singleton sequence

Definition at line 10193 of file z3py.py.

10193 def Unit(a):
10194  """Create a singleton sequence"""
10195  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10196 
def Unit(a)
Definition: z3py.py:10193
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.

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

4457 def Update(a, i, v):
4458  """Return a Z3 store array expression.
4459 
4460  >>> a = Array('a', IntSort(), IntSort())
4461  >>> i, v = Ints('i v')
4462  >>> s = Update(a, i, v)
4463  >>> s.sort()
4464  Array(Int, Int)
4465  >>> prove(s[i] == v)
4466  proved
4467  >>> j = Int('j')
4468  >>> prove(Implies(i != j, s[j] == a[j]))
4469  proved
4470  """
4471  if z3_debug():
4472  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4473  i = a.sort().domain().cast(i)
4474  v = a.sort().range().cast(v)
4475  ctx = a.ctx
4476  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4477 
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.

Referenced by Store().

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

4014 def URem(a, b):
4015  """Create the Z3 expression (unsigned) remainder `self % other`.
4016 
4017  Use the operator % for signed modulus, and SRem() for signed remainder.
4018 
4019  >>> x = BitVec('x', 32)
4020  >>> y = BitVec('y', 32)
4021  >>> URem(x, y)
4022  URem(x, y)
4023  >>> URem(x, y).sort()
4024  BitVec(32)
4025  >>> (x % y).sexpr()
4026  '(bvsmod x y)'
4027  >>> URem(x, y).sexpr()
4028  '(bvurem x y)'
4029  """
4030  _check_bv_args(a, b)
4031  a, b = _coerce_exprs(a, b)
4032  return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4033 
def URem(a, b)
Definition: z3py.py:4014
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.

◆ user_prop_diseq()

def z3py.user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 10559 of file z3py.py.

10559 def user_prop_diseq(ctx, cb, x, y):
10560  prop = _prop_closures.get(ctx)
10561  prop.cb = cb
10562  prop.diseq(x, y)
10563  prop.cb = None
10564 
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:10559

◆ user_prop_eq()

def z3py.user_prop_eq (   ctx,
  cb,
  x,
  y 
)

Definition at line 10553 of file z3py.py.

10553 def user_prop_eq(ctx, cb, x, y):
10554  prop = _prop_closures.get(ctx)
10555  prop.cb = cb
10556  prop.eq(x, y)
10557  prop.cb = None
10558 
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:10553

◆ user_prop_final()

def z3py.user_prop_final (   ctx,
  cb 
)

Definition at line 10547 of file z3py.py.

10547 def user_prop_final(ctx, cb):
10548  prop = _prop_closures.get(ctx)
10549  prop.cb = cb
10550  prop.final()
10551  prop.cb = None
10552 
def user_prop_final(ctx, cb)
Definition: z3py.py:10547

◆ user_prop_fixed()

def z3py.user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 10541 of file z3py.py.

10541 def user_prop_fixed(ctx, cb, id, value):
10542  prop = _prop_closures.get(ctx)
10543  prop.cb = cb
10544  prop.fixed(id, _to_expr_ref(ctypes.c_void_p(value), prop.ctx()))
10545  prop.cb = None
10546 
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:10541

◆ user_prop_fresh()

def z3py.user_prop_fresh (   id,
  ctx 
)

Definition at line 10534 of file z3py.py.

10534 def user_prop_fresh(id, ctx):
10535  prop = _prop_closures.get(id)
10536  _prop_closures.set_threaded()
10537  new_prop = UsePropagateBase(None, ctx)
10538  _prop_closures.set(new_prop.id, new_prop.fresh())
10539  return ctypes.c_void_p(new_prop.id)
10540 
def user_prop_fresh(id, ctx)
Definition: z3py.py:10534

◆ user_prop_pop()

def z3py.user_prop_pop (   ctx,
  num_scopes 
)

Definition at line 10531 of file z3py.py.

10531 def user_prop_pop(ctx, num_scopes):
10532  _prop_closures.get(ctx).pop(num_scopes)
10533 
def user_prop_pop(ctx, num_scopes)
Definition: z3py.py:10531

◆ user_prop_push()

def z3py.user_prop_push (   ctx)

Definition at line 10528 of file z3py.py.

10528 def user_prop_push(ctx):
10529  _prop_closures.get(ctx).push();
10530 
def user_prop_push(ctx)
Definition: z3py.py:10528

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

1351 def Var(idx, s):
1352  """Create a Z3 free variable. Free variables are used to create quantified formulas.
1353 
1354  >>> Var(0, IntSort())
1355  Var(0)
1356  >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1357  False
1358  """
1359  if z3_debug():
1360  _z3_assert(is_sort(s), "Z3 sort expected")
1361  return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1362 
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a bound variable.

Referenced by RealVar().

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

8190 def When(p, t, ctx=None):
8191  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8192 
8193  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8194  >>> x, y = Ints('x y')
8195  >>> g = Goal()
8196  >>> g.add(x > 0)
8197  >>> g.add(y > 0)
8198  >>> t(g)
8199  [[x > 0, y > 0]]
8200  >>> g.add(x == y + 1)
8201  >>> t(g)
8202  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8203  """
8204  p = _to_probe(p, ctx)
8205  t = _to_tactic(t, ctx)
8206  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8207 
def When(p, t, ctx=None)
Definition: z3py.py:8190
Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t)
Return a tactic that applies t to a given goal is the probe p evaluates to true. If p evaluates to fa...

◆ With()

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

7876 def With(t, *args, **keys):
7877  """Return a tactic that applies tactic `t` using the given configuration options.
7878 
7879  >>> x, y = Ints('x y')
7880  >>> t = With(Tactic('simplify'), som=True)
7881  >>> t((x + 1)*(y + 2) == 0)
7882  [[2*x + y + x*y == -2]]
7883  """
7884  ctx = keys.pop('ctx', None)
7885  t = _to_tactic(t, ctx)
7886  p = args2params(args, keys, t.ctx)
7887  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7888 
def With(t, *args, **keys)
Definition: z3py.py:7876
Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p)
Return a tactic that applies t using the given set of parameters.

◆ WithParams()

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

7889 def WithParams(t, p):
7890  """Return a tactic that applies tactic `t` using the given configuration options.
7891 
7892  >>> x, y = Ints('x y')
7893  >>> p = ParamsRef()
7894  >>> p.set("som", True)
7895  >>> t = WithParams(Tactic('simplify'), p)
7896  >>> t((x + 1)*(y + 2) == 0)
7897  [[2*x + y + x*y == -2]]
7898  """
7899  t = _to_tactic(t, None)
7900  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7901 
def WithParams(t, p)
Definition: z3py.py:7889

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

1654 def Xor(a, b, ctx=None):
1655  """Create a Z3 Xor expression.
1656 
1657  >>> p, q = Bools('p q')
1658  >>> Xor(p, q)
1659  Xor(p, q)
1660  >>> simplify(Xor(p, q))
1661  Not(p) == q
1662  """
1663  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1664  s = BoolSort(ctx)
1665  a = s.cast(a)
1666  b = s.cast(b)
1667  return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1668 
def Xor(a, b, ctx=None)
Definition: z3py.py:1654
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.

◆ z3_debug()

def z3py.z3_debug ( )

Definition at line 56 of file z3py.py.

56 def 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(), 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(), FreshFunction(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), AlgebraicNumRef.index(), 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.

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

4144 def ZeroExt(n, a):
4145  """Return a bit-vector expression with `n` extra zero-bits.
4146 
4147  >>> x = BitVec('x', 16)
4148  >>> n = ZeroExt(8, x)
4149  >>> n.size()
4150  24
4151  >>> n
4152  ZeroExt(8, x)
4153  >>> n.sort()
4154  BitVec(24)
4155  >>> v0 = BitVecVal(2, 2)
4156  >>> v0
4157  2
4158  >>> v0.size()
4159  2
4160  >>> v = simplify(ZeroExt(6, v0))
4161  >>> v
4162  2
4163  >>> v.size()
4164  8
4165  """
4166  if z3_debug():
4167  _z3_assert(_is_int(n), "First argument must be an integer")
4168  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4169  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4170 
def ZeroExt(n, a)
Definition: z3py.py:4144
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i,...

Variable Documentation

◆ sat

Definition at line 6473 of file z3py.py.

◆ unknown

Definition at line 6475 of file z3py.py.

◆ unsat

Definition at line 6474 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 54 of file z3py.py.