Z3
Data Structures | Functions | Variables
z3py Namespace Reference

Data Structures

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

Functions

def z3_debug ()
 
def enable_trace (msg)
 
def disable_trace (msg)
 
def get_version_string ()
 
def get_version ()
 
def get_full_version ()
 
def open_log (fname)
 
def append_log (s)
 
def to_symbol (s, ctx=None)
 
def z3_error_handler (c, e)
 
def main_ctx ()
 
def get_ctx (ctx)
 
def set_param (*args, **kws)
 
def reset_params ()
 
def set_option (*args, **kws)
 
def get_param (name)
 
def is_ast (a)
 
def eq (a, b)
 
def is_sort (s)
 
def DeclareSort (name, ctx=None)
 
def is_func_decl (a)
 
def Function (name, *sig)
 
def 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 

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

7804 def AndThen(*ts, **ks):
7805  """Return a tactic that applies the tactics in `*ts` in sequence.
7806 
7807  >>> x, y = Ints('x y')
7808  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7809  >>> t(And(x == 0, y > x + 1))
7810  [[Not(y <= 1)]]
7811  >>> t(And(x == 0, y > x + 1)).as_expr()
7812  Not(y <= 1)
7813  """
7814  if z3_debug():
7815  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7816  ctx = ks.get('ctx', None)
7817  num = len(ts)
7818  r = ts[0]
7819  for i in range(num - 1):
7820  r = _and_then(r, ts[i+1], ctx)
7821  return r
7822 

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 

◆ 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 

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 

◆ 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 

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

8385 def AtLeast(*args):
8386  """Create an at-most Pseudo-Boolean k constraint.
8387 
8388  >>> a, b, c = Bools('a b c')
8389  >>> f = AtLeast(a, b, c, 2)
8390  """
8391  args = _get_args(args)
8392  if z3_debug():
8393  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8394  ctx = _ctx_from_ast_arg_list(args)
8395  if z3_debug():
8396  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8397  args1 = _coerce_expr_list(args[:-1], ctx)
8398  k = args[-1]
8399  _args, sz = _to_ast_array(args1)
8400  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8401 

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

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

◆ 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 

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 

◆ 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 

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 

◆ 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 

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 

◆ 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 

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 

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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ Complement()

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

Definition at line 10446 of file z3py.py.

10446 def Complement(re):
10447  """Create the complement regular expression."""
10448  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10449 

◆ 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 

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

8223 def Cond(p, t1, t2, ctx=None):
8224  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8225 
8226  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8227  """
8228  p = _to_probe(p, ctx)
8229  t1 = _to_tactic(t1, ctx)
8230  t2 = _to_tactic(t2, ctx)
8231  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8232 

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 

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 

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

10240 def Contains(a, b):
10241  """Check if 'a' contains 'b'
10242  >>> s1 = Contains("abc", "ab")
10243  >>> simplify(s1)
10244  True
10245  >>> s2 = Contains("abc", "bc")
10246  >>> simplify(s2)
10247  True
10248  >>> x, y, z = Strings('x y z')
10249  >>> s3 = Contains(Concat(x,y,z), y)
10250  >>> simplify(s3)
10251  True
10252  """
10253  ctx = _get_ctx2(a, b)
10254  a = _coerce_seq(a, ctx)
10255  b = _coerce_seq(b, ctx)
10256  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10257 
10258 

◆ 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 

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 

◆ 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 

◆ describe_probes()

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

Definition at line 8153 of file z3py.py.

8153 def describe_probes():
8154  """Display a (tabular) description of all available probes in Z3."""
8155  if in_html_mode():
8156  even = True
8157  print('<table border="1" cellpadding="2" cellspacing="0">')
8158  for p in probes():
8159  if even:
8160  print('<tr style="background-color:#CFCFCF">')
8161  even = False
8162  else:
8163  print('<tr>')
8164  even = True
8165  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8166  print('</table>')
8167  else:
8168  for p in probes():
8169  print('%s : %s' % (p, probe_description(p)))
8170 

◆ describe_tactics()

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

Definition at line 7962 of file z3py.py.

7962 def describe_tactics():
7963  """Display a (tabular) description of all available tactics in Z3."""
7964  if in_html_mode():
7965  even = True
7966  print('<table border="1" cellpadding="2" cellspacing="0">')
7967  for t in tactics():
7968  if even:
7969  print('<tr style="background-color:#CFCFCF">')
7970  even = False
7971  else:
7972  print('<tr>')
7973  even = True
7974  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7975  print('</table>')
7976  else:
7977  for t in tactics():
7978  print('%s : %s' % (t, tactic_description(t)))
7979 

◆ 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 

◆ 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 

◆ 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 

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

10175 def Empty(s):
10176  """Create the empty sequence of the given sort
10177  >>> e = Empty(StringSort())
10178  >>> e2 = StringVal("")
10179  >>> print(e.eq(e2))
10180  True
10181  >>> e3 = Empty(SeqSort(IntSort()))
10182  >>> print(e3)
10183  Empty(Seq(Int))
10184  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10185  >>> print(e4)
10186  Empty(ReSort(Seq(Int)))
10187  """
10188  if isinstance(s, SeqSortRef):
10189  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10190  if isinstance(s, ReSortRef):
10191  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10192  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10193 

◆ 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 

◆ 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 

◆ ensure_prop_closures()

def z3py.ensure_prop_closures ( )

Definition at line 10538 of file z3py.py.

10538 def ensure_prop_closures():
10539  global _prop_closures
10540  if _prop_closures is None:
10541  _prop_closures = PropClosures()
10542 

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 

◆ 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 

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 

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 

◆ 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 

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

8186 def FailIf(p, ctx=None):
8187  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8188 
8189  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8190 
8191  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8192  >>> x, y = Ints('x y')
8193  >>> g = Goal()
8194  >>> g.add(x > 0)
8195  >>> g.add(y > 0)
8196  >>> t(g)
8197  [[x > 0, y > 0]]
8198  >>> g.add(x == y + 1)
8199  >>> t(g)
8200  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8201  """
8202  p = _to_probe(p, ctx)
8203  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8204 

◆ FiniteDomainSort()

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

Definition at line 7278 of file z3py.py.

7278 def FiniteDomainSort(name, sz, ctx=None):
7279  """Create a named finite domain sort of a given size sz"""
7280  if not isinstance(name, Symbol):
7281  name = to_symbol(name)
7282  ctx = _get_ctx(ctx)
7283  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7284 

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

7346 def FiniteDomainVal(val, sort, ctx=None):
7347  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7348 
7349  >>> s = FiniteDomainSort('S', 256)
7350  >>> FiniteDomainVal(255, s)
7351  255
7352  >>> FiniteDomainVal('100', s)
7353  100
7354  """
7355  if z3_debug():
7356  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7357  ctx = sort.ctx
7358  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7359 

◆ Float128()

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

Definition at line 8816 of file z3py.py.

8816 def Float128(ctx=None):
8817  """Floating-point 128-bit (quadruple) sort."""
8818  ctx = _get_ctx(ctx)
8819  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8820 

◆ Float16()

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

Definition at line 8786 of file z3py.py.

8786 def Float16(ctx=None):
8787  """Floating-point 16-bit (half) sort."""
8788  ctx = _get_ctx(ctx)
8789  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8790 

◆ Float32()

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

Definition at line 8796 of file z3py.py.

8796 def Float32(ctx=None):
8797  """Floating-point 32-bit (single) sort."""
8798  ctx = _get_ctx(ctx)
8799  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8800 

◆ Float64()

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

Definition at line 8806 of file z3py.py.

8806 def Float64(ctx=None):
8807  """Floating-point 64-bit (double) sort."""
8808  ctx = _get_ctx(ctx)
8809  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8810 

◆ FloatDouble()

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

Definition at line 8811 of file z3py.py.

8811 def FloatDouble(ctx=None):
8812  """Floating-point 64-bit (double) sort."""
8813  ctx = _get_ctx(ctx)
8814  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8815 

◆ FloatHalf()

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

Definition at line 8791 of file z3py.py.

8791 def FloatHalf(ctx=None):
8792  """Floating-point 16-bit (half) sort."""
8793  ctx = _get_ctx(ctx)
8794  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8795 

◆ FloatQuadruple()

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

Definition at line 8821 of file z3py.py.

8821 def FloatQuadruple(ctx=None):
8822  """Floating-point 128-bit (quadruple) sort."""
8823  ctx = _get_ctx(ctx)
8824  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8825 

◆ FloatSingle()

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

Definition at line 8801 of file z3py.py.

8801 def FloatSingle(ctx=None):
8802  """Floating-point 32-bit (single) sort."""
8803  ctx = _get_ctx(ctx)
8804  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8805 

◆ 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 

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

9401 def FP(name, fpsort, ctx=None):
9402  """Return a floating-point constant named `name`.
9403  `fpsort` is the floating-point sort.
9404  If `ctx=None`, then the global context is used.
9405 
9406  >>> x = FP('x', FPSort(8, 24))
9407  >>> is_fp(x)
9408  True
9409  >>> x.ebits()
9410  8
9411  >>> x.sort()
9412  FPSort(8, 24)
9413  >>> word = FPSort(8, 24)
9414  >>> x2 = FP('x', word)
9415  >>> eq(x, x2)
9416  True
9417  """
9418  if isinstance(fpsort, FPSortRef) and ctx is None:
9419  ctx = fpsort.ctx
9420  else:
9421  ctx = _get_ctx(ctx)
9422  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9423 

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

9442 def fpAbs(a, ctx=None):
9443  """Create a Z3 floating-point absolute value expression.
9444 
9445  >>> s = FPSort(8, 24)
9446  >>> rm = RNE()
9447  >>> x = FPVal(1.0, s)
9448  >>> fpAbs(x)
9449  fpAbs(1)
9450  >>> y = FPVal(-20.0, s)
9451  >>> y
9452  -1.25*(2**4)
9453  >>> fpAbs(y)
9454  fpAbs(-1.25*(2**4))
9455  >>> fpAbs(-1.25*(2**4))
9456  fpAbs(-1.25*(2**4))
9457  >>> fpAbs(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_abs(ctx.ref(), a.as_ast()), ctx)
9463 

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

9524 def fpAdd(rm, a, b, ctx=None):
9525  """Create a Z3 floating-point addition expression.
9526 
9527  >>> s = FPSort(8, 24)
9528  >>> rm = RNE()
9529  >>> x = FP('x', s)
9530  >>> y = FP('y', s)
9531  >>> fpAdd(rm, x, y)
9532  fpAdd(RNE(), x, y)
9533  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9534  x + y
9535  >>> fpAdd(rm, x, y).sort()
9536  FPSort(8, 24)
9537  """
9538  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9539 

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

9820 def fpBVToFP(v, sort, ctx=None):
9821  """Create a Z3 floating-point conversion expression that represents the
9822  conversion from a bit-vector term to a floating-point term.
9823 
9824  >>> x_bv = BitVecVal(0x3F800000, 32)
9825  >>> x_fp = fpBVToFP(x_bv, Float32())
9826  >>> x_fp
9827  fpToFP(1065353216)
9828  >>> simplify(x_fp)
9829  1
9830  """
9831  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9832  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9833  ctx = _get_ctx(ctx)
9834  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9835 

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

9568 def fpDiv(rm, a, b, ctx=None):
9569  """Create a Z3 floating-point division expression.
9570 
9571  >>> s = FPSort(8, 24)
9572  >>> rm = RNE()
9573  >>> x = FP('x', s)
9574  >>> y = FP('y', s)
9575  >>> fpDiv(rm, x, y)
9576  fpDiv(RNE(), x, y)
9577  >>> fpDiv(rm, x, y).sort()
9578  FPSort(8, 24)
9579  """
9580  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9581 

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

9732 def fpEQ(a, b, ctx=None):
9733  """Create the Z3 floating-point expression `fpEQ(other, self)`.
9734 
9735  >>> x, y = FPs('x y', FPSort(8, 24))
9736  >>> fpEQ(x, y)
9737  fpEQ(x, y)
9738  >>> fpEQ(x, y).sexpr()
9739  '(fp.eq x y)'
9740  """
9741  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9742 

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

9623 def fpFMA(rm, a, b, c, ctx=None):
9624  """Create a Z3 floating-point fused multiply-add expression.
9625  """
9626  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9627 

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

9754 def fpFP(sgn, exp, sig, ctx=None):
9755  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9756 
9757  >>> s = FPSort(8, 24)
9758  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9759  >>> print(x)
9760  fpFP(1, 127, 4194304)
9761  >>> xv = FPVal(-1.5, s)
9762  >>> print(xv)
9763  -1.5
9764  >>> slvr = Solver()
9765  >>> slvr.add(fpEQ(x, xv))
9766  >>> slvr.check()
9767  sat
9768  >>> xv = FPVal(+1.5, s)
9769  >>> print(xv)
9770  1.5
9771  >>> slvr = Solver()
9772  >>> slvr.add(fpEQ(x, xv))
9773  >>> slvr.check()
9774  unsat
9775  """
9776  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9777  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9778  ctx = _get_ctx(ctx)
9779  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9780  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9781 

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

9836 def fpFPToFP(rm, v, sort, ctx=None):
9837  """Create a Z3 floating-point conversion expression that represents the
9838  conversion from a floating-point term to a floating-point term of different precision.
9839 
9840  >>> x_sgl = FPVal(1.0, Float32())
9841  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9842  >>> x_dbl
9843  fpToFP(RNE(), 1)
9844  >>> simplify(x_dbl)
9845  1
9846  >>> x_dbl.sort()
9847  FPSort(11, 53)
9848  """
9849  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9850  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9851  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9852  ctx = _get_ctx(ctx)
9853  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9854 

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

9721 def fpGEQ(a, b, ctx=None):
9722  """Create the Z3 floating-point expression `other >= self`.
9723 
9724  >>> x, y = FPs('x y', FPSort(8, 24))
9725  >>> fpGEQ(x, y)
9726  x >= y
9727  >>> (x >= y).sexpr()
9728  '(fp.geq x y)'
9729  """
9730  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9731 

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

9710 def fpGT(a, b, ctx=None):
9711  """Create the Z3 floating-point expression `other > self`.
9712 
9713  >>> x, y = FPs('x y', FPSort(8, 24))
9714  >>> fpGT(x, y)
9715  x > y
9716  >>> (x > y).sexpr()
9717  '(fp.gt x y)'
9718  """
9719  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9720 

Referenced by FPRef.__gt__().

◆ fpInfinity()

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

Definition at line 9335 of file z3py.py.

9335 def fpInfinity(s, negative):
9336  """Create a Z3 floating-point +oo or -oo term."""
9337  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9338  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9339  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9340 

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

9649 def fpIsInf(a, ctx=None):
9650  """Create a Z3 floating-point isInfinite expression.
9651 
9652  >>> s = FPSort(8, 24)
9653  >>> x = FP('x', s)
9654  >>> fpIsInf(x)
9655  fpIsInf(x)
9656  """
9657  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9658 

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

9638 def fpIsNaN(a, ctx=None):
9639  """Create a Z3 floating-point isNaN expression.
9640 
9641  >>> s = FPSort(8, 24)
9642  >>> x = FP('x', s)
9643  >>> y = FP('y', s)
9644  >>> fpIsNaN(x)
9645  fpIsNaN(x)
9646  """
9647  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9648 

◆ fpIsNegative()

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

Definition at line 9674 of file z3py.py.

9674 def fpIsNegative(a, ctx=None):
9675  """Create a Z3 floating-point isNegative expression.
9676  """
9677  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9678 

◆ fpIsNormal()

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

Definition at line 9664 of file z3py.py.

9664 def fpIsNormal(a, ctx=None):
9665  """Create a Z3 floating-point isNormal expression.
9666  """
9667  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9668 

◆ fpIsPositive()

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

Definition at line 9679 of file z3py.py.

9679 def fpIsPositive(a, ctx=None):
9680  """Create a Z3 floating-point isPositive expression.
9681  """
9682  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9683 

◆ fpIsSubnormal()

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

Definition at line 9669 of file z3py.py.

9669 def fpIsSubnormal(a, ctx=None):
9670  """Create a Z3 floating-point isSubnormal expression.
9671  """
9672  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9673 

◆ fpIsZero()

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

Definition at line 9659 of file z3py.py.

9659 def fpIsZero(a, ctx=None):
9660  """Create a Z3 floating-point isZero expression.
9661  """
9662  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9663 

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

9699 def fpLEQ(a, b, ctx=None):
9700  """Create the Z3 floating-point expression `other <= self`.
9701 
9702  >>> x, y = FPs('x y', FPSort(8, 24))
9703  >>> fpLEQ(x, y)
9704  x <= y
9705  >>> (x <= y).sexpr()
9706  '(fp.leq x y)'
9707  """
9708  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9709 

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

9688 def fpLT(a, b, ctx=None):
9689  """Create the Z3 floating-point expression `other < self`.
9690 
9691  >>> x, y = FPs('x y', FPSort(8, 24))
9692  >>> fpLT(x, y)
9693  x < y
9694  >>> (x < y).sexpr()
9695  '(fp.lt x y)'
9696  """
9697  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9698 

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

9609 def fpMax(a, b, ctx=None):
9610  """Create a Z3 floating-point maximum expression.
9611 
9612  >>> s = FPSort(8, 24)
9613  >>> rm = RNE()
9614  >>> x = FP('x', s)
9615  >>> y = FP('y', s)
9616  >>> fpMax(x, y)
9617  fpMax(x, y)
9618  >>> fpMax(x, y).sort()
9619  FPSort(8, 24)
9620  """
9621  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9622 

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

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

◆ fpMinusInfinity()

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

Definition at line 9330 of file z3py.py.

9330 def fpMinusInfinity(s):
9331  """Create a Z3 floating-point -oo term."""
9332  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9333  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9334 

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 9346 of file z3py.py.

9346 def fpMinusZero(s):
9347  """Create a Z3 floating-point -0.0 term."""
9348  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9349  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9350 

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

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

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

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

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

9464 def fpNeg(a, ctx=None):
9465  """Create a Z3 floating-point addition expression.
9466 
9467  >>> s = FPSort(8, 24)
9468  >>> rm = RNE()
9469  >>> x = FP('x', s)
9470  >>> fpNeg(x)
9471  -x
9472  >>> fpNeg(x).sort()
9473  FPSort(8, 24)
9474  """
9475  ctx = _get_ctx(ctx)
9476  [a] = _coerce_fp_expr_list([a], ctx)
9477  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9478 

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

9743 def fpNEQ(a, b, ctx=None):
9744  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9745 
9746  >>> x, y = FPs('x y', FPSort(8, 24))
9747  >>> fpNEQ(x, y)
9748  Not(fpEQ(x, y))
9749  >>> (x != y).sexpr()
9750  '(distinct x y)'
9751  """
9752  return Not(fpEQ(a, b, ctx))
9753 

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

9314 def fpPlusInfinity(s):
9315  """Create a Z3 floating-point +oo term.
9316 
9317  >>> s = FPSort(8, 24)
9318  >>> pb = get_fpa_pretty()
9319  >>> set_fpa_pretty(True)
9320  >>> fpPlusInfinity(s)
9321  +oo
9322  >>> set_fpa_pretty(False)
9323  >>> fpPlusInfinity(s)
9324  fpPlusInfinity(FPSort(8, 24))
9325  >>> set_fpa_pretty(pb)
9326  """
9327  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9328  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9329 

Referenced by FPVal().

◆ fpPlusZero()

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

Definition at line 9341 of file z3py.py.

9341 def fpPlusZero(s):
9342  """Create a Z3 floating-point +0.0 term."""
9343  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9344  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9345 

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

9855 def fpRealToFP(rm, v, sort, ctx=None):
9856  """Create a Z3 floating-point conversion expression that represents the
9857  conversion from a real term to a floating-point term.
9858 
9859  >>> x_r = RealVal(1.5)
9860  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9861  >>> x_fp
9862  fpToFP(RNE(), 3/2)
9863  >>> simplify(x_fp)
9864  1.5
9865  """
9866  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9867  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9868  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9869  ctx = _get_ctx(ctx)
9870  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9871 

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

9582 def fpRem(a, b, ctx=None):
9583  """Create a Z3 floating-point remainder expression.
9584 
9585  >>> s = FPSort(8, 24)
9586  >>> x = FP('x', s)
9587  >>> y = FP('y', s)
9588  >>> fpRem(x, y)
9589  fpRem(x, y)
9590  >>> fpRem(x, y).sort()
9591  FPSort(8, 24)
9592  """
9593  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9594 

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

9633 def fpRoundToIntegral(rm, a, ctx=None):
9634  """Create a Z3 floating-point roundToIntegral expression.
9635  """
9636  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9637 

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

9424 def FPs(names, fpsort, ctx=None):
9425  """Return an array of floating-point constants.
9426 
9427  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9428  >>> x.sort()
9429  FPSort(8, 24)
9430  >>> x.sbits()
9431  24
9432  >>> x.ebits()
9433  8
9434  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9435  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9436  """
9437  ctx = _get_ctx(ctx)
9438  if isinstance(names, str):
9439  names = names.split(" ")
9440  return [FP(name, fpsort, ctx) for name in names]
9441 

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

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

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

9240 def FPSort(ebits, sbits, ctx=None):
9241  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9242 
9243  >>> Single = FPSort(8, 24)
9244  >>> Double = FPSort(11, 53)
9245  >>> Single
9246  FPSort(8, 24)
9247  >>> x = Const('x', Single)
9248  >>> eq(x, FP('x', FPSort(8, 24)))
9249  True
9250  """
9251  ctx = _get_ctx(ctx)
9252  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9253 

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

9628 def fpSqrt(rm, a, ctx=None):
9629  """Create a Z3 floating-point square root expression.
9630  """
9631  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9632 

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

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

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

9782 def fpToFP(a1, a2=None, a3=None, ctx=None):
9783  """Create a Z3 floating-point conversion expression from other term sorts
9784  to floating-point.
9785 
9786  From a bit-vector term in IEEE 754-2008 format:
9787  >>> x = FPVal(1.0, Float32())
9788  >>> x_bv = fpToIEEEBV(x)
9789  >>> simplify(fpToFP(x_bv, Float32()))
9790  1
9791 
9792  From a floating-point term with different precision:
9793  >>> x = FPVal(1.0, Float32())
9794  >>> x_db = fpToFP(RNE(), x, Float64())
9795  >>> x_db.sort()
9796  FPSort(11, 53)
9797 
9798  From a real term:
9799  >>> x_r = RealVal(1.5)
9800  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9801  1.5
9802 
9803  From a signed bit-vector term:
9804  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9805  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9806  -1.25*(2**2)
9807  """
9808  ctx = _get_ctx(ctx)
9809  if is_bv(a1) and is_fp_sort(a2):
9810  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9811  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9812  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9813  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9814  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9815  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9816  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9817  else:
9818  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9819 

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

9906 def fpToFPUnsigned(rm, x, s, ctx=None):
9907  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9908  if z3_debug():
9909  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9910  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9911  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9912  ctx = _get_ctx(ctx)
9913  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9914 

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

9976 def fpToIEEEBV(x, ctx=None):
9977  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9978 
9979  The size of the resulting bit-vector is automatically determined.
9980 
9981  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9982  knows only one NaN and it will always produce the same bit-vector representation of
9983  that NaN.
9984 
9985  >>> x = FP('x', FPSort(8, 24))
9986  >>> y = fpToIEEEBV(x)
9987  >>> print(is_fp(x))
9988  True
9989  >>> print(is_bv(y))
9990  True
9991  >>> print(is_fp(y))
9992  False
9993  >>> print(is_bv(x))
9994  False
9995  """
9996  if z3_debug():
9997  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9998  ctx = _get_ctx(ctx)
9999  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10000 
10001 
10002 

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

9957 def fpToReal(x, ctx=None):
9958  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9959 
9960  >>> x = FP('x', FPSort(8, 24))
9961  >>> y = fpToReal(x)
9962  >>> print(is_fp(x))
9963  True
9964  >>> print(is_real(y))
9965  True
9966  >>> print(is_fp(y))
9967  False
9968  >>> print(is_real(x))
9969  False
9970  """
9971  if z3_debug():
9972  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9973  ctx = _get_ctx(ctx)
9974  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9975 

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

9915 def fpToSBV(rm, x, s, ctx=None):
9916  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9917 
9918  >>> x = FP('x', FPSort(8, 24))
9919  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9920  >>> print(is_fp(x))
9921  True
9922  >>> print(is_bv(y))
9923  True
9924  >>> print(is_fp(y))
9925  False
9926  >>> print(is_bv(x))
9927  False
9928  """
9929  if z3_debug():
9930  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9931  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9932  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9933  ctx = _get_ctx(ctx)
9934  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9935 

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

9936 def fpToUBV(rm, x, s, ctx=None):
9937  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9938 
9939  >>> x = FP('x', FPSort(8, 24))
9940  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9941  >>> print(is_fp(x))
9942  True
9943  >>> print(is_bv(y))
9944  True
9945  >>> print(is_fp(y))
9946  False
9947  >>> print(is_bv(x))
9948  False
9949  """
9950  if z3_debug():
9951  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9952  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9953  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9954  ctx = _get_ctx(ctx)
9955  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9956 

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

9889 def fpUnsignedToFP(rm, v, sort, ctx=None):
9890  """Create a Z3 floating-point conversion expression that represents the
9891  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9892 
9893  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9894  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9895  >>> x_fp
9896  fpToFPUnsigned(RNE(), 4294967291)
9897  >>> simplify(x_fp)
9898  1*(2**32)
9899  """
9900  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9901  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9902  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9903  ctx = _get_ctx(ctx)
9904  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9905 

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

9357 def FPVal(sig, exp=None, fps=None, ctx=None):
9358  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9359 
9360  >>> v = FPVal(20.0, FPSort(8, 24))
9361  >>> v
9362  1.25*(2**4)
9363  >>> print("0x%.8x" % v.exponent_as_long(False))
9364  0x00000004
9365  >>> v = FPVal(2.25, FPSort(8, 24))
9366  >>> v
9367  1.125*(2**1)
9368  >>> v = FPVal(-2.25, FPSort(8, 24))
9369  >>> v
9370  -1.125*(2**1)
9371  >>> FPVal(-0.0, FPSort(8, 24))
9372  -0.0
9373  >>> FPVal(0.0, FPSort(8, 24))
9374  +0.0
9375  >>> FPVal(+0.0, FPSort(8, 24))
9376  +0.0
9377  """
9378  ctx = _get_ctx(ctx)
9379  if is_fp_sort(exp):
9380  fps = exp
9381  exp = None
9382  elif fps is None:
9383  fps = _dflt_fps(ctx)
9384  _z3_assert(is_fp_sort(fps), "sort mismatch")
9385  if exp is None:
9386  exp = 0
9387  val = _to_float_str(sig)
9388  if val == "NaN" or val == "nan":
9389  return fpNaN(fps)
9390  elif val == "-0.0":
9391  return fpMinusZero(fps)
9392  elif val == "0.0" or val == "+0.0":
9393  return fpPlusZero(fps)
9394  elif val == "+oo" or val == "+inf" or val == "+Inf":
9395  return fpPlusInfinity(fps)
9396  elif val == "-oo" or val == "-inf" or val == "-Inf":
9397  return fpMinusInfinity(fps)
9398  else:
9399  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9400 

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

9351 def fpZero(s, negative):
9352  """Create a Z3 floating-point +0.0 or -0.0 term."""
9353  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9354  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9355  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9356 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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

10194 def Full(s):
10195  """Create the regular expression that accepts the universal language
10196  >>> e = Full(ReSort(SeqSort(IntSort())))
10197  >>> print(e)
10198  Full(ReSort(Seq(Int)))
10199  >>> e1 = Full(ReSort(StringSort()))
10200  >>> print(e1)
10201  Full(ReSort(String))
10202  """
10203  if isinstance(s, ReSortRef):
10204  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10205  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10206 
10207 

◆ 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 

◆ 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 

◆ 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 

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 

◆ get_default_fp_sort()

def z3py.get_default_fp_sort (   ctx = None)

Definition at line 8710 of file z3py.py.

8710 def get_default_fp_sort(ctx=None):
8711  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8712 

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

8683 def get_default_rounding_mode(ctx=None):
8684  """Retrieves the global default rounding mode."""
8685  global _dflt_rounding_mode
8686  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8687  return RTZ(ctx)
8688  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8689  return RTN(ctx)
8690  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8691  return RTP(ctx)
8692  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8693  return RNE(ctx)
8694  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8695  return RNA(ctx)
8696 

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

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ help_simplify()

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

Definition at line 8263 of file z3py.py.

8263 def help_simplify():
8264  """Return a string describing all options available for Z3 `simplify` procedure."""
8265  print(Z3_simplify_get_help(main_ctx().ref()))
8266 

◆ 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 

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 

Referenced by Fixedpoint.add_rule(), and Fixedpoint.update_rule().

◆ IndexOf() [1/2]

def z3py.IndexOf (   s,
  substr 
)

Definition at line 10273 of file z3py.py.

10273 def IndexOf(s, substr):
10274  return IndexOf(s, substr, IntVal(0))
10275 

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

10276 def IndexOf(s, substr, offset):
10277  """Retrieve the index of substring within a string starting at a specified offset.
10278  >>> simplify(IndexOf("abcabc", "bc", 0))
10279  1
10280  >>> simplify(IndexOf("abcabc", "bc", 2))
10281  4
10282  """
10283  ctx = None
10284  if is_expr(offset):
10285  ctx = offset.ctx
10286  ctx = _get_ctx2(s, substr, ctx)
10287  s = _coerce_seq(s, ctx)
10288  substr = _coerce_seq(substr, ctx)
10289  if _is_int(offset):
10290  offset = IntVal(offset, ctx)
10291  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10292 

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

10373 def InRe(s, re):
10374  """Create regular expression membership test
10375  >>> re = Union(Re("a"),Re("b"))
10376  >>> print (simplify(InRe("a", re)))
10377  True
10378  >>> print (simplify(InRe("b", re)))
10379  True
10380  >>> print (simplify(InRe("c", re)))
10381  False
10382  """
10383  s = _coerce_seq(s, re.ctx)
10384  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10385 

◆ 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 

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 

◆ Intersect()

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

Definition at line 10405 of file z3py.py.

10405 def Intersect(*args):
10406  """Create intersection of regular expressions.
10407  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10408  """
10409  args = _get_args(args)
10410  sz = len(args)
10411  if z3_debug():
10412  _z3_assert(sz > 0, "At least one argument expected.")
10413  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10414  if sz == 1:
10415  return args[0]
10416  ctx = args[0].ctx
10417  v = (Ast * sz)()
10418  for i in range(sz):
10419  v[i] = args[i].as_ast()
10420  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10421 

◆ 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 

◆ 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 

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

◆ IntToStr()

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

Definition at line 10327 of file z3py.py.

10327 def IntToStr(s):
10328  """Convert integer expression to string"""
10329  if not is_expr(s):
10330  s = _py2expr(s)
10331  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10332 
10333 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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 

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 

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 

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 

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 

◆ 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 

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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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 

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

7307 def is_finite_domain(a):
7308  """Return `True` if `a` is a Z3 finite-domain expression.
7309 
7310  >>> s = FiniteDomainSort('S', 100)
7311  >>> b = Const('b', s)
7312  >>> is_finite_domain(b)
7313  True
7314  >>> is_finite_domain(Int('x'))
7315  False
7316  """
7317  return isinstance(a, FiniteDomainRef)
7318 
7319 

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

7285 def is_finite_domain_sort(s):
7286  """Return True if `s` is a Z3 finite-domain sort.
7287 
7288  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7289  True
7290  >>> is_finite_domain_sort(IntSort())
7291  False
7292  """
7293  return isinstance(s, FiniteDomainSortRef)
7294 
7295 

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

7360 def is_finite_domain_value(a):
7361  """Return `True` if `a` is a Z3 finite-domain value.
7362 
7363  >>> s = FiniteDomainSort('S', 100)
7364  >>> b = Const('b', s)
7365  >>> is_finite_domain_value(b)
7366  False
7367  >>> b = FiniteDomainVal(10, s)
7368  >>> b
7369  10
7370  >>> is_finite_domain_value(b)
7371  True
7372  """
7373  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7374 
7375 

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

9213 def is_fp(a):
9214  """Return `True` if `a` is a Z3 floating-point expression.
9215 
9216  >>> b = FP('b', FPSort(8, 24))
9217  >>> is_fp(b)
9218  True
9219  >>> is_fp(b + 1.0)
9220  True
9221  >>> is_fp(Int('x'))
9222  False
9223  """
9224  return isinstance(a, FPRef)
9225 

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

8830 def is_fp_sort(s):
8831  """Return True if `s` is a Z3 floating-point sort.
8832 
8833  >>> is_fp_sort(FPSort(8, 24))
8834  True
8835  >>> is_fp_sort(IntSort())
8836  False
8837  """
8838  return isinstance(s, FPSortRef)
8839 

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

9226 def is_fp_value(a):
9227  """Return `True` if `a` is a Z3 floating-point numeral value.
9228 
9229  >>> b = FP('b', FPSort(8, 24))
9230  >>> is_fp_value(b)
9231  False
9232  >>> b = FPVal(1.0, FPSort(8, 24))
9233  >>> b
9234  1
9235  >>> is_fp_value(b)
9236  True
9237  """
9238  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9239 

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

9077 def is_fprm(a):
9078  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9079 
9080  >>> rm = RNE()
9081  >>> is_fprm(rm)
9082  True
9083  >>> rm = 1.0
9084  >>> is_fprm(rm)
9085  False
9086  """
9087  return isinstance(a, FPRMRef)
9088 

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

8840 def is_fprm_sort(s):
8841  """Return True if `s` is a Z3 floating-point rounding mode sort.
8842 
8843  >>> is_fprm_sort(FPSort(8, 24))
8844  False
8845  >>> is_fprm_sort(RNE().sort())
8846  True
8847  """
8848  return isinstance(s, FPRMSortRef)
8849 

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

9089 def is_fprm_value(a):
9090  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9091  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9092 

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 

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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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 

◆ 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 

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

8119 def is_probe(p):
8120  """Return `True` if `p` is a Z3 probe.
8121 
8122  >>> is_probe(Int('x'))
8123  False
8124  >>> is_probe(Probe('memory'))
8125  True
8126  """
8127  return isinstance(p, Probe)
8128 

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 

◆ 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 

◆ is_re()

def z3py.is_re (   s)

Definition at line 10369 of file z3py.py.

10369 def is_re(s):
10370  return isinstance(s, ReRef)
10371 
10372 

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 

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

10114 def is_seq(a):
10115  """Return `True` if `a` is a Z3 sequence expression.
10116  >>> print (is_seq(Unit(IntVal(0))))
10117  True
10118  >>> print (is_seq(StringVal("abc")))
10119  True
10120  """
10121  return isinstance(a, SeqRef)
10122 

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 

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

10123 def is_string(a):
10124  """Return `True` if `a` is a Z3 string expression.
10125  >>> print (is_string(StringVal("ab")))
10126  True
10127  """
10128  return isinstance(a, SeqRef) and a.is_string()
10129 

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

10130 def is_string_value(a):
10131  """return 'True' if 'a' is a Z3 string constant expression.
10132  >>> print (is_string_value(StringVal("a")))
10133  True
10134  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10135  False
10136  """
10137  return isinstance(a, SeqRef) and a.is_string_value()
10138 
10139 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ LastIndexOf()

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

Definition at line 10293 of file z3py.py.

10293 def LastIndexOf(s, substr):
10294  """Retrieve the last index of substring within a string"""
10295  ctx = None
10296  ctx = _get_ctx2(s, substr, ctx)
10297  s = _coerce_seq(s, ctx)
10298  substr = _coerce_seq(substr, ctx)
10299  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10300 
10301 

◆ Length()

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

Definition at line 10302 of file z3py.py.

10302 def Length(s):
10303  """Obtain the length of a sequence 's'
10304  >>> l = Length(StringVal("abc"))
10305  >>> simplify(l)
10306  3
10307  """
10308  s = _coerce_seq(s)
10309  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10310 

◆ LinearOrder()

def z3py.LinearOrder (   a,
  index 
)

Definition at line 10491 of file z3py.py.

10491 def LinearOrder(a, index):
10492  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10493 

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

10462 def Loop(re, lo, hi=0):
10463  """Create the regular expression accepting between a lower and upper bound repetitions
10464  >>> re = Loop(Re("a"), 1, 3)
10465  >>> print(simplify(InRe("aa", re)))
10466  True
10467  >>> print(simplify(InRe("aaaa", re)))
10468  False
10469  >>> print(simplify(InRe("", re)))
10470  False
10471  """
10472  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10473 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

Referenced by ModelRef.translate().

◆ MultiPattern()

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

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

Definition at line 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 

◆ 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 

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 

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

10434 def Option(re):
10435  """Create the regular expression that optionally accepts the argument.
10436  >>> re = Option(Re("a"))
10437  >>> print(simplify(InRe("a", re)))
10438  True
10439  >>> print(simplify(InRe("", re)))
10440  True
10441  >>> print(simplify(InRe("aa", re)))
10442  False
10443  """
10444  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10445 

◆ 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 

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

7835 def OrElse(*ts, **ks):
7836  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7837 
7838  >>> x = Int('x')
7839  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7840  >>> # Tactic split-clause fails if there is no clause in the given goal.
7841  >>> t(x == 0)
7842  [[x == 0]]
7843  >>> t(Or(x == 0, x == 1))
7844  [[x == 0], [x == 1]]
7845  """
7846  if z3_debug():
7847  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7848  ctx = ks.get('ctx', None)
7849  num = len(ts)
7850  r = ts[0]
7851  for i in range(num - 1):
7852  r = _or_else(r, ts[i+1], ctx)
7853  return r
7854 

◆ ParAndThen()

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

Definition at line 7887 of file z3py.py.

7887 def ParAndThen(t1, t2, ctx=None):
7888  """Alias for ParThen(t1, t2, ctx)."""
7889  return ParThen(t1, t2, ctx)
7890 

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

7855 def ParOr(*ts, **ks):
7856  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7857 
7858  >>> x = Int('x')
7859  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7860  >>> t(x + 1 == 2)
7861  [[x == 1]]
7862  """
7863  if z3_debug():
7864  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7865  ctx = _get_ctx(ks.get('ctx', None))
7866  ts = [ _to_tactic(t, ctx) for t in ts ]
7867  sz = len(ts)
7868  _args = (TacticObj * sz)()
7869  for i in range(sz):
7870  _args[i] = ts[i].tactic
7871  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7872 

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

8660 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8661  """Parse a file in SMT 2.0 format using the given sorts and decls.
8662 
8663  This function is similar to parse_smt2_string().
8664  """
8665  ctx = _get_ctx(ctx)
8666  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8667  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8668  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8669 
8670 

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

8640 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8641  """Parse a string in SMT 2.0 format using the given sorts and decls.
8642 
8643  The arguments sorts and decls are Python dictionaries used to initialize
8644  the symbol table used for the SMT 2.0 parser.
8645 
8646  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8647  [x > 0, x < 10]
8648  >>> x, y = Ints('x y')
8649  >>> f = Function('f', IntSort(), IntSort())
8650  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8651  [x + f(y) > 0]
8652  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8653  [a > 0]
8654  """
8655  ctx = _get_ctx(ctx)
8656  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8657  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8658  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8659 

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

7873 def ParThen(t1, t2, ctx=None):
7874  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7875 
7876  >>> x, y = Ints('x y')
7877  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7878  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7879  [[x == 1, y == 2], [x == 2, y == 3]]
7880  """
7881  t1 = _to_tactic(t1, ctx)
7882  t2 = _to_tactic(t2, ctx)
7883  if z3_debug():
7884  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7885  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7886 

Referenced by ParAndThen().

◆ PartialOrder()

def z3py.PartialOrder (   a,
  index 
)

Definition at line 10488 of file z3py.py.

10488 def PartialOrder(a, index):
10489  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10490 

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

8447 def PbEq(args, k, ctx = None):
8448  """Create a Pseudo-Boolean inequality k constraint.
8449 
8450  >>> a, b, c = Bools('a b c')
8451  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8452  """
8453  _z3_check_cint_overflow(k, "k")
8454  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8455  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8456 
8457 

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

8437 def PbGe(args, k):
8438  """Create a Pseudo-Boolean inequality k constraint.
8439 
8440  >>> a, b, c = Bools('a b c')
8441  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8442  """
8443  _z3_check_cint_overflow(k, "k")
8444  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8445  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8446 

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

8427 def PbLe(args, k):
8428  """Create a Pseudo-Boolean inequality k constraint.
8429 
8430  >>> a, b, c = Bools('a b c')
8431  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8432  """
8433  _z3_check_cint_overflow(k, "k")
8434  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8435  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8436 

◆ PiecewiseLinearOrder()

def z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 10497 of file z3py.py.

10497 def PiecewiseLinearOrder(a, index):
10498  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10499 

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

10422 def Plus(re):
10423  """Create the regular expression accepting one or more repetitions of argument.
10424  >>> re = Plus(Re("a"))
10425  >>> print(simplify(InRe("aa", re)))
10426  True
10427  >>> print(simplify(InRe("ab", re)))
10428  False
10429  >>> print(simplify(InRe("", re)))
10430  False
10431  """
10432  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10433 

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

10212 def PrefixOf(a, b):
10213  """Check if 'a' is a prefix of 'b'
10214  >>> s1 = PrefixOf("ab", "abc")
10215  >>> simplify(s1)
10216  True
10217  >>> s2 = PrefixOf("bc", "abc")
10218  >>> simplify(s2)
10219  False
10220  """
10221  ctx = _get_ctx2(a, b)
10222  a = _coerce_seq(a, ctx)
10223  b = _coerce_seq(b, ctx)
10224  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10225 

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

8145 def probe_description(name, ctx=None):
8146  """Return a short description for the probe named `name`.
8147 
8148  >>> d = probe_description('memory')
8149  """
8150  ctx = _get_ctx(ctx)
8151  return Z3_probe_get_descr(ctx.ref(), name)
8152 

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

8135 def probes(ctx=None):
8136  """Return a list of all available probes in Z3.
8137 
8138  >>> l = probes()
8139  >>> l.count('memory') == 1
8140  True
8141  """
8142  ctx = _get_ctx(ctx)
8143  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8144 

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

8343 def Product(*args):
8344  """Create the product of the Z3 expressions.
8345 
8346  >>> a, b, c = Ints('a b c')
8347  >>> Product(a, b, c)
8348  a*b*c
8349  >>> Product([a, b, c])
8350  a*b*c
8351  >>> A = IntVector('a', 5)
8352  >>> Product(A)
8353  a__0*a__1*a__2*a__3*a__4
8354  """
8355  args = _get_args(args)
8356  if len(args) == 0:
8357  return 1
8358  ctx = _ctx_from_ast_arg_list(args)
8359  if ctx is None:
8360  return _reduce(lambda a, b: a * b, args, 1)
8361  args = _coerce_expr_list(args, ctx)
8362  if is_bv(args[0]):
8363  return _reduce(lambda a, b: a * b, args, 1)
8364  else:
8365  _args, sz = _to_ast_array(args)
8366  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8367 

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

8515 def prove(claim, **keywords):
8516  """Try to prove the given claim.
8517 
8518  This is a simple function for creating demonstrations. It tries to prove
8519  `claim` by showing the negation is unsatisfiable.
8520 
8521  >>> p, q = Bools('p q')
8522  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8523  proved
8524  """
8525  if z3_debug():
8526  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8527  s = Solver()
8528  s.set(**keywords)
8529  s.add(Not(claim))
8530  if keywords.get('show', False):
8531  print(s)
8532  r = s.check()
8533  if r == unsat:
8534  print("proved")
8535  elif r == unknown:
8536  print("failed to prove")
8537  print(s.model())
8538  else:
8539  print("counterexample")
8540  print(s.model())
8541 

◆ 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 

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

10474 def Range(lo, hi, ctx = None):
10475  """Create the range regular expression over two sequences of length 1
10476  >>> range = Range("a","z")
10477  >>> print(simplify(InRe("b", range)))
10478  True
10479  >>> print(simplify(InRe("bb", range)))
10480  False
10481  """
10482  lo = _coerce_seq(lo, ctx)
10483  hi = _coerce_seq(hi, ctx)
10484  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10485 
10486 # Special Relations
10487 

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

10334 def Re(s, ctx=None):
10335  """The regular expression that accepts sequence 's'
10336  >>> s1 = Re("ab")
10337  >>> s2 = Re(StringVal("ab"))
10338  >>> s3 = Re(Unit(BoolVal(True)))
10339  """
10340  s = _coerce_seq(s, ctx)
10341  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10342 
10343 
10344 
10345 

◆ 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 

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 

◆ 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 

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 

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 

◆ 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 

◆ 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 

◆ 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 

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

7917 def Repeat(t, max=4294967295, ctx=None):
7918  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7919 
7920  >>> x, y = Ints('x y')
7921  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7922  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7923  >>> r = t(c)
7924  >>> for subgoal in r: print(subgoal)
7925  [x == 0, y == 0, x > y]
7926  [x == 0, y == 1, x > y]
7927  [x == 1, y == 0, x > y]
7928  [x == 1, y == 1, x > y]
7929  >>> t = Then(t, Tactic('propagate-values'))
7930  >>> t(c)
7931  [[x == 1, y == 0]]
7932  """
7933  t = _to_tactic(t, ctx)
7934  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7935 

◆ 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 

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

10259 def Replace(s, src, dst):
10260  """Replace the first occurrence of 'src' by 'dst' in 's'
10261  >>> r = Replace("aaa", "a", "b")
10262  >>> simplify(r)
10263  "baa"
10264  """
10265  ctx = _get_ctx2(dst, s)
10266  if ctx is None and is_expr(src):
10267  ctx = src.ctx
10268  src = _coerce_seq(src, ctx)
10269  dst = _coerce_seq(dst, ctx)
10270  s = _coerce_seq(s, ctx)
10271  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10272 

◆ 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 

◆ ReSort()

def z3py.ReSort (   s)

Definition at line 10354 of file z3py.py.

10354 def ReSort(s):
10355  if is_ast(s):
10356  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10357  if s is None or isinstance(s, Context):
10358  ctx = _get_ctx(s)
10359  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10360  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10361 
10362 

◆ RNA()

def z3py.RNA (   ctx = None)

Definition at line 9049 of file z3py.py.

9049 def RNA (ctx=None):
9050  ctx = _get_ctx(ctx)
9051  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9052 

Referenced by get_default_rounding_mode().

◆ RNE()

def z3py.RNE (   ctx = None)

Definition at line 9041 of file z3py.py.

9041 def RNE (ctx=None):
9042  ctx = _get_ctx(ctx)
9043  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9044 

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 

◆ 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 

◆ RoundNearestTiesToAway()

def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 9045 of file z3py.py.

9045 def RoundNearestTiesToAway(ctx=None):
9046  ctx = _get_ctx(ctx)
9047  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9048 

◆ RoundNearestTiesToEven()

def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 9037 of file z3py.py.

9037 def RoundNearestTiesToEven(ctx=None):
9038  ctx = _get_ctx(ctx)
9039  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9040 

◆ RoundTowardNegative()

def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9061 of file z3py.py.

9061 def RoundTowardNegative(ctx=None):
9062  ctx = _get_ctx(ctx)
9063  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9064 

◆ RoundTowardPositive()

def z3py.RoundTowardPositive (   ctx = None)

Definition at line 9053 of file z3py.py.

9053 def RoundTowardPositive(ctx=None):
9054  ctx = _get_ctx(ctx)
9055  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9056 

◆ RoundTowardZero()

def z3py.RoundTowardZero (   ctx = None)

Definition at line 9069 of file z3py.py.

9069 def RoundTowardZero(ctx=None):
9070  ctx = _get_ctx(ctx)
9071  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9072 

◆ RTN()

def z3py.RTN (   ctx = None)

Definition at line 9065 of file z3py.py.

9065 def RTN(ctx=None):
9066  ctx = _get_ctx(ctx)
9067  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9068 

Referenced by get_default_rounding_mode().

◆ RTP()

def z3py.RTP (   ctx = None)

Definition at line 9057 of file z3py.py.

9057 def RTP(ctx=None):
9058  ctx = _get_ctx(ctx)
9059  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9060 

Referenced by get_default_rounding_mode().

◆ RTZ()

def z3py.RTZ (   ctx = None)

Definition at line 9073 of file z3py.py.

9073 def RTZ(ctx=None):
9074  ctx = _get_ctx(ctx)
9075  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9076 

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 

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

10037 def SeqSort(s):
10038  """Create a sequence sort over elements provided in the argument
10039  >>> s = SeqSort(IntSort())
10040  >>> s == Unit(IntVal(1)).sort()
10041  True
10042  """
10043  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10044 

◆ set_default_fp_sort()

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

Definition at line 8713 of file z3py.py.

8713 def set_default_fp_sort(ebits, sbits, ctx=None):
8714  global _dflt_fpsort_ebits
8715  global _dflt_fpsort_sbits
8716  _dflt_fpsort_ebits = ebits
8717  _dflt_fpsort_sbits = sbits
8718 

◆ set_default_rounding_mode()

def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 8697 of file z3py.py.

8697 def set_default_rounding_mode(rm, ctx=None):
8698  global _dflt_rounding_mode
8699  if is_fprm_value(rm):
8700  _dflt_rounding_mode = rm.decl().kind()
8701  else:
8702  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8703  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8704  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8705  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8706  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8707  "illegal rounding mode")
8708  _dflt_rounding_mode = rm
8709 

◆ 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 

◆ 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 

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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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

6988 def SimpleSolver(ctx=None, logFile=None):
6989  """Return a simple general purpose solver with limited amount of preprocessing.
6990 
6991  >>> s = SimpleSolver()
6992  >>> x = Int('x')
6993  >>> s.add(x > 0)
6994  >>> s.check()
6995  sat
6996  """
6997  ctx = _get_ctx(ctx)
6998  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6999 

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

8239 def simplify(a, *arguments, **keywords):
8240  """Simplify the expression `a` using the given options.
8241 
8242  This function has many options. Use `help_simplify` to obtain the complete list.
8243 
8244  >>> x = Int('x')
8245  >>> y = Int('y')
8246  >>> simplify(x + 1 + y + x + 1)
8247  2 + 2*x + y
8248  >>> simplify((x + 1)*(y + 1), som=True)
8249  1 + x + y + x*y
8250  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8251  And(Not(x == y), Not(x == 1), Not(y == 1))
8252  >>> simplify(And(x == 0, y == 1), elim_and=True)
8253  Not(Or(Not(x == 0), Not(y == 1)))
8254  """
8255  if z3_debug():
8256  _z3_assert(is_expr(a), "Z3 expression expected")
8257  if len(arguments) > 0 or len(keywords) > 0:
8258  p = args2params(arguments, keywords, a.ctx)
8259  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8260  else:
8261  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8262 

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

8267 def simplify_param_descrs():
8268  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8269  return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8270 

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

8458 def solve(*args, **keywords):
8459  """Solve the constraints `*args`.
8460 
8461  This is a simple function for creating demonstrations. It creates a solver,
8462  configure it using the options in `keywords`, adds the constraints
8463  in `args`, and invokes check.
8464 
8465  >>> a = Int('a')
8466  >>> solve(a > 0, a < 2)
8467  [a = 1]
8468  """
8469  s = Solver()
8470  s.set(**keywords)
8471  s.add(*args)
8472  if keywords.get('show', False):
8473  print(s)
8474  r = s.check()
8475  if r == unsat:
8476  print("no solution")
8477  elif r == unknown:
8478  print("failed to solve")
8479  try:
8480  print(s.model())
8481  except Z3Exception:
8482  return
8483  else:
8484  print(s.model())
8485 

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

8486 def solve_using(s, *args, **keywords):
8487  """Solve the constraints `*args` using solver `s`.
8488 
8489  This is a simple function for creating demonstrations. It is similar to `solve`,
8490  but it uses the given solver `s`.
8491  It configures solver `s` using the options in `keywords`, adds the constraints
8492  in `args`, and invokes check.
8493  """
8494  if z3_debug():
8495  _z3_assert(isinstance(s, Solver), "Solver object expected")
8496  s.set(**keywords)
8497  s.add(*args)
8498  if keywords.get('show', False):
8499  print("Problem:")
8500  print(s)
8501  r = s.check()
8502  if r == unsat:
8503  print("no solution")
8504  elif r == unknown:
8505  print("failed to solve")
8506  try:
8507  print(s.model())
8508  except Z3Exception:
8509  return
8510  else:
8511  if keywords.get('show', False):
8512  print("Solution:")
8513  print(s.model())
8514 

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

6968 def SolverFor(logic, ctx=None, logFile=None):
6969  """Create a solver customized for the given logic.
6970 
6971  The parameter `logic` is a string. It should be contains
6972  the name of a SMT-LIB logic.
6973  See http://www.smtlib.org/ for the name of all available logics.
6974 
6975  >>> s = SolverFor("QF_LIA")
6976  >>> x = Int('x')
6977  >>> s.add(x > 0)
6978  >>> s.add(x < 2)
6979  >>> s.check()
6980  sat
6981  >>> s.model()
6982  [x = 1]
6983  """
6984  ctx = _get_ctx(ctx)
6985  logic = to_symbol(logic)
6986  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6987 

◆ 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 

◆ 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 

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

10450 def Star(re):
10451  """Create the regular expression accepting zero or more repetitions of argument.
10452  >>> re = Star(Re("a"))
10453  >>> print(simplify(InRe("aa", re)))
10454  True
10455  >>> print(simplify(InRe("ab", re)))
10456  False
10457  >>> print(simplify(InRe("", re)))
10458  True
10459  """
10460  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10461 

◆ 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 

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

10145 def String(name, ctx=None):
10146  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10147 
10148  >>> x = String('x')
10149  """
10150  ctx = _get_ctx(ctx)
10151  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10152 

Referenced by Strings(), and SubSeq().

◆ Strings()

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

Definition at line 10153 of file z3py.py.

10153 def Strings(names, ctx=None):
10154  """Return string constants"""
10155  ctx = _get_ctx(ctx)
10156  if isinstance(names, str):
10157  names = names.split(" ")
10158  return [String(name, ctx) for name in names]
10159 

Referenced by SubSeq().

◆ StringSort()

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

Definition at line 10027 of file z3py.py.

10027 def StringSort(ctx=None):
10028  """Create a string sort
10029  >>> s = StringSort()
10030  >>> print(s)
10031  String
10032  """
10033  ctx = _get_ctx(ctx)
10034  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10035 
10036 

Referenced by String().

◆ StringVal()

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

Definition at line 10140 of file z3py.py.

10140 def StringVal(s, ctx=None):
10141  """create a string expression"""
10142  ctx = _get_ctx(ctx)
10143  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10144 

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

10311 def StrToInt(s):
10312  """Convert string expression to integer
10313  >>> a = StrToInt("1")
10314  >>> simplify(1 == a)
10315  True
10316  >>> b = StrToInt("2")
10317  >>> simplify(1 == b)
10318  False
10319  >>> c = StrToInt(IntToStr(2))
10320  >>> simplify(1 == c)
10321  False
10322  """
10323  s = _coerce_seq(s)
10324  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10325 
10326 

◆ SubSeq()

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

Definition at line 10164 of file z3py.py.

10164 def SubSeq(s, offset, length):
10165  """Extract substring or subsequence starting at offset"""
10166  return Extract(s, offset, length)
10167 

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

8271 def substitute(t, *m):
8272  """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.
8273 
8274  >>> x = Int('x')
8275  >>> y = Int('y')
8276  >>> substitute(x + 1, (x, y + 1))
8277  y + 1 + 1
8278  >>> f = Function('f', IntSort(), IntSort())
8279  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8280  1 + 1
8281  """
8282  if isinstance(m, tuple):
8283  m1 = _get_args(m)
8284  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8285  m = m1
8286  if z3_debug():
8287  _z3_assert(is_expr(t), "Z3 expression expected")
8288  _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.")
8289  num = len(m)
8290  _from = (Ast * num)()
8291  _to = (Ast * num)()
8292  for i in range(num):
8293  _from[i] = m[i][0].as_ast()
8294  _to[i] = m[i][1].as_ast()
8295  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8296 

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

8297 def substitute_vars(t, *m):
8298  """Substitute the free variables in t with the expression in m.
8299 
8300  >>> v0 = Var(0, IntSort())
8301  >>> v1 = Var(1, IntSort())
8302  >>> x = Int('x')
8303  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8304  >>> # replace v0 with x+1 and v1 with x
8305  >>> substitute_vars(f(v0, v1), x + 1, x)
8306  f(x + 1, x)
8307  """
8308  if z3_debug():
8309  _z3_assert(is_expr(t), "Z3 expression expected")
8310  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8311  num = len(m)
8312  _to = (Ast * num)()
8313  for i in range(num):
8314  _to[i] = m[i].as_ast()
8315  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8316 

◆ SubString()

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

Definition at line 10160 of file z3py.py.

10160 def SubString(s, offset, length):
10161  """Extract substring or subsequence starting at offset"""
10162  return Extract(s, offset, length)
10163 

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

10226 def SuffixOf(a, b):
10227  """Check if 'a' is a suffix of 'b'
10228  >>> s1 = SuffixOf("ab", "abc")
10229  >>> simplify(s1)
10230  False
10231  >>> s2 = SuffixOf("bc", "abc")
10232  >>> simplify(s2)
10233  True
10234  """
10235  ctx = _get_ctx2(a, b)
10236  a = _coerce_seq(a, ctx)
10237  b = _coerce_seq(b, ctx)
10238  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10239 

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

8317 def Sum(*args):
8318  """Create the sum of the Z3 expressions.
8319 
8320  >>> a, b, c = Ints('a b c')
8321  >>> Sum(a, b, c)
8322  a + b + c
8323  >>> Sum([a, b, c])
8324  a + b + c
8325  >>> A = IntVector('a', 5)
8326  >>> Sum(A)
8327  a__0 + a__1 + a__2 + a__3 + a__4
8328  """
8329  args = _get_args(args)
8330  if len(args) == 0:
8331  return 0
8332  ctx = _ctx_from_ast_arg_list(args)
8333  if ctx is None:
8334  return _reduce(lambda a, b: a + b, args, 0)
8335  args = _coerce_expr_list(args, ctx)
8336  if is_bv(args[0]):
8337  return _reduce(lambda a, b: a + b, args, 0)
8338  else:
8339  _args, sz = _to_ast_array(args)
8340  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8341 
8342 

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

7954 def tactic_description(name, ctx=None):
7955  """Return a short description for the tactic named `name`.
7956 
7957  >>> d = tactic_description('simplify')
7958  """
7959  ctx = _get_ctx(ctx)
7960  return Z3_tactic_get_descr(ctx.ref(), name)
7961 

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

7944 def tactics(ctx=None):
7945  """Return a list of all available tactics in Z3.
7946 
7947  >>> l = tactics()
7948  >>> l.count('simplify') == 1
7949  True
7950  """
7951  ctx = _get_ctx(ctx)
7952  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7953 

Referenced by describe_tactics(), and z3.par_or().

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

7823 def Then(*ts, **ks):
7824  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7825 
7826  >>> x, y = Ints('x y')
7827  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7828  >>> t(And(x == 0, y > x + 1))
7829  [[Not(y <= 1)]]
7830  >>> t(And(x == 0, y > x + 1)).as_expr()
7831  Not(y <= 1)
7832  """
7833  return AndThen(*ts, **ks)
7834 

◆ 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 

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 

◆ 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 

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

10500 def TransitiveClosure(f):
10501  """Given a binary relation R, such that the two arguments have the same sort
10502  create the transitive closure relation R+.
10503  The transitive closure R+ is a new relation.
10504  """
10505  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
10506 
10507 

◆ TreeOrder()

def z3py.TreeOrder (   a,
  index 
)

Definition at line 10494 of file z3py.py.

10494 def TreeOrder(a, index):
10495  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10496 

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

7936 def TryFor(t, ms, ctx=None):
7937  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7938 
7939  If `t` does not terminate in `ms` milliseconds, then it fails.
7940  """
7941  t = _to_tactic(t, ctx)
7942  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7943 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

◆ 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 

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

10386 def Union(*args):
10387  """Create union of regular expressions.
10388  >>> re = Union(Re("a"), Re("b"), Re("c"))
10389  >>> print (simplify(InRe("d", re)))
10390  False
10391  """
10392  args = _get_args(args)
10393  sz = len(args)
10394  if z3_debug():
10395  _z3_assert(sz > 0, "At least one argument expected.")
10396  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10397  if sz == 1:
10398  return args[0]
10399  ctx = args[0].ctx
10400  v = (Ast * sz)()
10401  for i in range(sz):
10402  v[i] = args[i].as_ast()
10403  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10404 

Referenced by ReRef.__add__().

◆ Unit()

def z3py.Unit (   a)
Create a singleton sequence

Definition at line 10208 of file z3py.py.

10208 def Unit(a):
10209  """Create a singleton sequence"""
10210  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10211 

◆ 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 

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 

◆ user_prop_diseq()

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

Definition at line 10574 of file z3py.py.

10574 def user_prop_diseq(ctx, cb, x, y):
10575  prop = _prop_closures.get(ctx)
10576  prop.cb = cb
10577  prop.diseq(x, y)
10578  prop.cb = None
10579 

◆ user_prop_eq()

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

Definition at line 10568 of file z3py.py.

10568 def user_prop_eq(ctx, cb, x, y):
10569  prop = _prop_closures.get(ctx)
10570  prop.cb = cb
10571  prop.eq(x, y)
10572  prop.cb = None
10573 

◆ user_prop_final()

def z3py.user_prop_final (   ctx,
  cb 
)

Definition at line 10562 of file z3py.py.

10562 def user_prop_final(ctx, cb):
10563  prop = _prop_closures.get(ctx)
10564  prop.cb = cb
10565  prop.final()
10566  prop.cb = None
10567 

◆ user_prop_fixed()

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

Definition at line 10556 of file z3py.py.

10556 def user_prop_fixed(ctx, cb, id, value):
10557  prop = _prop_closures.get(ctx)
10558  prop.cb = cb
10559  prop.fixed(id, _to_expr_ref(ctypes.c_void_p(value), prop.ctx()))
10560  prop.cb = None
10561 

◆ user_prop_fresh()

def z3py.user_prop_fresh (   id,
  ctx 
)

Definition at line 10549 of file z3py.py.

10549 def user_prop_fresh(id, ctx):
10550  prop = _prop_closures.get(id)
10551  _prop_closures.set_threaded()
10552  new_prop = UsePropagateBase(None, ctx)
10553  _prop_closures.set(new_prop.id, new_prop.fresh())
10554  return ctypes.c_void_p(new_prop.id)
10555 

◆ user_prop_pop()

def z3py.user_prop_pop (   ctx,
  num_scopes 
)

Definition at line 10546 of file z3py.py.

10546 def user_prop_pop(ctx, num_scopes):
10547  _prop_closures.get(ctx).pop(num_scopes)
10548 

◆ user_prop_push()

def z3py.user_prop_push (   ctx)

Definition at line 10543 of file z3py.py.

10543 def user_prop_push(ctx):
10544  _prop_closures.get(ctx).push();
10545 

◆ 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 

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

8205 def When(p, t, ctx=None):
8206  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8207 
8208  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8209  >>> x, y = Ints('x y')
8210  >>> g = Goal()
8211  >>> g.add(x > 0)
8212  >>> g.add(y > 0)
8213  >>> t(g)
8214  [[x > 0, y > 0]]
8215  >>> g.add(x == y + 1)
8216  >>> t(g)
8217  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8218  """
8219  p = _to_probe(p, ctx)
8220  t = _to_tactic(t, ctx)
8221  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8222 

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

7891 def With(t, *args, **keys):
7892  """Return a tactic that applies tactic `t` using the given configuration options.
7893 
7894  >>> x, y = Ints('x y')
7895  >>> t = With(Tactic('simplify'), som=True)
7896  >>> t((x + 1)*(y + 2) == 0)
7897  [[2*x + y + x*y == -2]]
7898  """
7899  ctx = keys.pop('ctx', None)
7900  t = _to_tactic(t, ctx)
7901  p = args2params(args, keys, t.ctx)
7902  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7903 

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

7904 def WithParams(t, p):
7905  """Return a tactic that applies tactic `t` using the given configuration options.
7906 
7907  >>> x, y = Ints('x y')
7908  >>> p = ParamsRef()
7909  >>> p.set("som", True)
7910  >>> t = WithParams(Tactic('simplify'), p)
7911  >>> t((x + 1)*(y + 2) == 0)
7912  [[2*x + y + x*y == -2]]
7913  """
7914  t = _to_tactic(t, None)
7915  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7916 

◆ 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 

◆ 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 

◆ 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 

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.

Z3_mk_re_plus
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
z3py.Reals
def Reals(names, ctx=None)
Definition: z3py.py:3106
Z3_global_param_reset_all
void Z3_API Z3_global_param_reset_all(void)
Restore the value of all global (and module) parameters. This command will not affect already created...
z3py.fpInfinity
def fpInfinity(s, negative)
Definition: z3py.py:9335
z3py.RNA
def RNA(ctx=None)
Definition: z3py.py:9049
z3py.fpLT
def fpLT(a, b, ctx=None)
Definition: z3py.py:9688
z3py.fpRoundToIntegral
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9633
z3py.RepeatBitVec
def RepeatBitVec(n, a)
Definition: z3py.py:4171
Z3_mk_string_symbol
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_mk_re_option
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
z3py.is_fprm_sort
def is_fprm_sort(s)
Definition: z3py.py:8840
z3py.get_version_string
def get_version_string()
Definition: z3py.py:73
Z3_to_func_decl
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
Z3_tactic_par_and_then
Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and then t2 to every subgoal produced by t1....
z3py.RoundTowardPositive
def RoundTowardPositive(ctx=None)
Definition: z3py.py:9053
Z3_mk_fpa_to_fp_bv
Z3_ast Z3_API Z3_mk_fpa_to_fp_bv(Z3_context c, Z3_ast bv, Z3_sort s)
Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.
z3py.FreshReal
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3134
z3py.is_distinct
def is_distinct(a)
Definition: z3py.py:1542
z3py.enable_trace
def enable_trace(msg)
Definition: z3py.py:67
Z3_mk_int_to_str
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
Z3_mk_re_complement
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
z3py.is_fprm
def is_fprm(a)
Definition: z3py.py:9077
Z3_get_probe_name
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.
Z3_get_version
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
z3py.fpIsInf
def fpIsInf(a, ctx=None)
Definition: z3py.py:9649
Z3_mk_ext_rotate_left
Z3_ast Z3_API Z3_mk_ext_rotate_left(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the left t2 times.
z3py.TupleSort
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:5012
Z3_mk_true
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
z3py.is_to_real
def is_to_real(a)
Definition: z3py.py:2743
z3py.fpBVToFP
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9820
z3py.fpMinusInfinity
def fpMinusInfinity(s)
Definition: z3py.py:9330
Z3_parse_smtlib2_file
Z3_ast_vector Z3_API Z3_parse_smtlib2_file(Z3_context c, Z3_string file_name, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Similar to Z3_parse_smtlib2_string, but reads the benchmark from a file.
Z3_mk_bvmul_no_underflow
Z3_ast Z3_API Z3_mk_bvmul_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed multiplication of t1 and t2 does not underflo...
z3py.FPs
def FPs(names, fpsort, ctx=None)
Definition: z3py.py:9424
Z3_mk_bvmul_no_overflow
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise multiplication of t1 and t2 does not overflow.
z3py.ZeroExt
def ZeroExt(n, a)
Definition: z3py.py:4144
z3py.ParOr
def ParOr(*ts, **ks)
Definition: z3py.py:7855
z3py.IsMember
def IsMember(e, s)
Definition: z3py.py:4692
z3py.SetIntersect
def SetIntersect(*args)
Definition: z3py.py:4641
Z3_mk_fresh_const
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
z3py.ToInt
def ToInt(a)
Definition: z3py.py:3164
Z3_mk_zero_ext
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i,...
Z3_get_as_array_func_decl
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a)
Return the function declaration f associated with a (_ as_array f) node.
z3py.DisjointSum
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:5023
z3py.Strings
def Strings(names, ctx=None)
Definition: z3py.py:10153
z3py.is_fp
def is_fp(a)
Definition: z3py.py:9213
z3py.user_prop_fixed
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:10556
Z3_mk_seq_concat
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_tactic_fail_if
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.
z3py.SetHasSize
def SetHasSize(a, k)
Definition: z3py.py:4574
z3py.RealSort
def RealSort(ctx=None)
Definition: z3py.py:2958
Z3_mk_fpa_to_ubv
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
z3py.is_array_sort
def is_array_sort(a)
Definition: z3py.py:4331
z3py.FPVal
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9357
Z3_mk_fpa_sort_64
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
z3py.RealVarVector
def RealVarVector(n, ctx=None)
Definition: z3py.py:1373
z3py.fpToUBV
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9936
Z3_tactic_try_for
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms)
Return a tactic that applies t to a given goal for ms milliseconds. If t does not terminate in ms mil...
z3py.Consts
def Consts(names, sort)
Definition: z3py.py:1332
z3py.RTP
def RTP(ctx=None)
Definition: z3py.py:9057
Z3_get_decl_ast_parameter
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.
z3py.user_prop_fresh
def user_prop_fresh(id, ctx)
Definition: z3py.py:10549
Z3_append_log
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.
z3py.TransitiveClosure
def TransitiveClosure(f)
Definition: z3py.py:10500
z3py.Var
def Var(idx, s)
Definition: z3py.py:1351
z3py.AtLeast
def AtLeast(*args)
Definition: z3py.py:8385
Z3_mk_fpa_zero
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
z3py.probes
def probes(ctx=None)
Definition: z3py.py:8135
z3py.SignExt
def SignExt(n, a)
Definition: z3py.py:4115
Z3_mk_fpa_round_toward_positive
Z3_ast Z3_API Z3_mk_fpa_round_toward_positive(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode.
z3::range
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3518
z3py.BVSubNoOverflow
def BVSubNoOverflow(a, b)
Definition: z3py.py:4218
Z3_mk_re_full
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
z3py.parse_smt2_string
def parse_smt2_string(s, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8640
z3py.reset_params
def reset_params()
Definition: z3py.py:263
z3py.ULT
def ULT(a, b)
Definition: z3py.py:3943
Z3_mk_bv2int
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast t1, bool is_signed)
Create an integer from the bit-vector argument t1. If is_signed is false, then the bit-vector t1 is t...
z3py.RoundTowardNegative
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9061
Z3_mk_and
Z3_ast Z3_API Z3_mk_and(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] and ... and args[num_args-1].
z3py.set_param
def set_param(*args, **kws)
Definition: z3py.py:240
z3py.RatVal
def RatVal(a, b, ctx=None)
Definition: z3py.py:3018
z3py.IntVal
def IntVal(val, ctx=None)
Definition: z3py.py:2989
z3py.SetDifference
def SetDifference(a, b)
Definition: z3py.py:4682
Z3_add_rec_def
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body)
Define the body of a recursive function.
z3py.fpToFP
def fpToFP(a1, a2=None, a3=None, ctx=None)
Definition: z3py.py:9782
z3py.fpGT
def fpGT(a, b, ctx=None)
Definition: z3py.py:9710
z3py.tactics
def tactics(ctx=None)
Definition: z3py.py:7944
Z3_mk_set_has_size
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.
z3py.fpUnsignedToFP
def fpUnsignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9889
z3py.IsInt
def IsInt(a)
Definition: z3py.py:3181
z3py.RTN
def RTN(ctx=None)
Definition: z3py.py:9065
Z3_mk_set_del
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
z3py.is_arith_sort
def is_arith_sort(s)
Definition: z3py.py:2199
z3py.RotateLeft
def RotateLeft(a, b)
Definition: z3py.py:4085
Z3_mk_fpa_round_nearest_ties_to_even
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_even(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
z3py.Or
def Or(*args)
Definition: z3py.py:1732
Z3_mk_seq_suffix
Z3_ast Z3_API Z3_mk_seq_suffix(Z3_context c, Z3_ast suffix, Z3_ast s)
Check if suffix is a suffix of s.
z3py.TreeOrder
def TreeOrder(a, index)
Definition: z3py.py:10494
z3py.BoolVector
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1614
Z3_mk_xor
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
Z3_mk_bvneg_no_overflow
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.
z3py.Loop
def Loop(re, lo, hi=0)
Definition: z3py.py:10462
z3py.SubSeq
def SubSeq(s, offset, length)
Definition: z3py.py:10164
Z3_mk_fpa_fp
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.
z3py.ensure_prop_closures
def ensure_prop_closures()
Definition: z3py.py:10538
z3py.SimpleSolver
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6988
z3py.With
def With(t, *args, **keys)
Definition: z3py.py:7891
Z3_mk_full_set
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
z3py.is_select
def is_select(a)
Definition: z3py.py:4579
z3py.simplify
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8239
Z3_mk_solver_for_logic
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic)
Create a new solver customized for the given logic. It behaves like Z3_mk_solver if the logic is unkn...
Z3_simplify_get_help
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.
Z3_mk_or
Z3_ast Z3_API Z3_mk_or(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] or ... or args[num_args-1].
z3py.StringSort
def StringSort(ctx=None)
Definition: z3py.py:10027
z3py.is_gt
def is_gt(a)
Definition: z3py.py:2721
Z3_mk_finite_domain_sort
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.
Z3_mk_set_union
Z3_ast Z3_API Z3_mk_set_union(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the union of a list of sets.
z3py.UserPropagateBase.pop
def pop(self, num_scopes)
Definition: z3py.py:10662
Z3_mk_set_intersect
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.
z3py.Exists
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2082
z3py.is_implies
def is_implies(a)
Definition: z3py.py:1511
z3py.to_symbol
def to_symbol(s, ctx=None)
Definition: z3py.py:109
z3py.is_map
def is_map(a)
Definition: z3py.py:4372
z3py.is_or
def is_or(a)
Definition: z3py.py:1500
z3py.fpMul
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9554
Z3_mk_distinct
Z3_ast Z3_API Z3_mk_distinct(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing distinct(args[0], ..., args[num_args-1]).
Z3_simplify_ex
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
z3py.fpGEQ
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9721
z3py.is_string_value
def is_string_value(a)
Definition: z3py.py:10130
z3py.is_app
def is_app(a)
Definition: z3py.py:1157
z3py.IndexOf
def IndexOf(s, substr)
Definition: z3py.py:10273
z3py.fpEQ
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9732
Z3_mk_rec_func_decl
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a recursive function.
Z3_mk_empty_set
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
z3py.LShR
def LShR(a, b)
Definition: z3py.py:4054
z3py.is_default
def is_default(a)
Definition: z3py.py:4387
z3py.fpRem
def fpRem(a, b, ctx=None)
Definition: z3py.py:9582
z3py.substitute
def substitute(t, *m)
Definition: z3py.py:8271
z3py.Union
def Union(*args)
Definition: z3py.py:10386
z3py.fpMinusZero
def fpMinusZero(s)
Definition: z3py.py:9346
z3py.RotateRight
def RotateRight(a, b)
Definition: z3py.py:4100
z3py.FiniteDomainSort
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7278
z3py.is_ge
def is_ge(a)
Definition: z3py.py:2710
z3py.is_and
def is_and(a)
Definition: z3py.py:1489
Z3_mk_model
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_mk_re_loop
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...
z3py.MultiPattern
def MultiPattern(*args)
Definition: z3py.py:1797
Z3_mk_linear_order
Z3_func_decl Z3_API Z3_mk_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a linear ordering relation over signature a. The relation is identified by the index id.
Z3_is_as_array
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a)
The (_ as-array f) AST node is a construct for assigning interpretations for arrays in Z3....
z3py.PrefixOf
def PrefixOf(a, b)
Definition: z3py.py:10212
z3py.InRe
def InRe(s, re)
Definition: z3py.py:10373
Z3_mk_fpa_to_sbv
Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
Z3_mk_add
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].
z3py.z3_error_handler
def z3_error_handler(c, e)
Definition: z3py.py:156
z3py.And
def And(*args)
Definition: z3py.py:1700
z3py.UGE
def UGE(a, b)
Definition: z3py.py:3960
z3py.Cbrt
def Cbrt(a, ctx=None)
Definition: z3py.py:3209
z3py.disable_trace
def disable_trace(msg)
Definition: z3py.py:70
z3py.Float64
def Float64(ctx=None)
Definition: z3py.py:8806
z3py.UserPropagateBase.push
def push(self)
Definition: z3py.py:10659
z3py.BitVecVal
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3795
Z3_mk_bvugt
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
Z3_mk_seq_prefix
Z3_ast Z3_API Z3_mk_seq_prefix(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if prefix is a prefix of s.
z3py.is_K
def is_K(a)
Definition: z3py.py:4360
z3py.Float32
def Float32(ctx=None)
Definition: z3py.py:8796
z3py.Range
def Range(lo, hi, ctx=None)
Definition: z3py.py:10474
Z3_mk_pattern
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.
Z3_mk_fpa_to_fp_signed
Z3_ast Z3_API Z3_mk_fpa_to_fp_signed(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort.
z3py.Cond
def Cond(p, t1, t2, ctx=None)
Definition: z3py.py:8223
z3py.is_fp_value
def is_fp_value(a)
Definition: z3py.py:9226
z3py.is_finite_domain_sort
def is_finite_domain_sort(s)
Definition: z3py.py:7285
Z3_mk_concat
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
Z3_mk_implies
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
z3py.fpMax
def fpMax(a, b, ctx=None)
Definition: z3py.py:9609
z3py.RealVal
def RealVal(val, ctx=None)
Definition: z3py.py:3000
z3py.PbLe
def PbLe(args, k)
Definition: z3py.py:8427
z3py.solve
def solve(*args, **keywords)
Definition: z3py.py:8458
z3py.RoundNearestTiesToEven
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9037
Z3_mk_seq_unit
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
z3py.Const
def Const(name, sort)
Definition: z3py.py:1321
Z3_get_sort_kind
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_mk_pbeq
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_mk_numeral
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
z3py.ForAll
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2065
Z3_mk_bvadd_no_overflow
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.
z3py.fpToFPUnsigned
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9906
Z3_mk_real2int
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.
z3py.FloatQuadruple
def FloatQuadruple(ctx=None)
Definition: z3py.py:8821
z3py.fpAbs
def fpAbs(a, ctx=None)
Definition: z3py.py:9442
Z3_mk_bvredor
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
z3py.If
def If(a, b, c, ctx=None)
Definition: z3py.py:1268
Z3_mk_fpa_sort
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
Z3_mk_fpa_to_fp_unsigned
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.
z3py.set_default_rounding_mode
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8697
Z3_mk_fpa_to_fp_real
Z3_ast Z3_API Z3_mk_fpa_to_fp_real(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a term of real sort into a term of FloatingPoint sort.
z3py.is_array
def is_array(a)
Definition: z3py.py:4335
Z3_mk_seq_length
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_mk_re_star
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
z3py.mk_not
def mk_not(a)
Definition: z3py.py:1687
Z3_mk_fpa_sort_quadruple
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_array_ext
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...
Z3_mk_map
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const *args)
Map f on the argument arrays.
z3py.get_as_array_func
def get_as_array_func(n)
Definition: z3py.py:6285
z3py.fpFMA
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9623
z3py.is_not
def is_not(a)
Definition: z3py.py:1522
z3py.Int
def Int(name, ctx=None)
Definition: z3py.py:3045
Z3_simplify_get_param_descrs
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
Z3_mk_fpa_to_real
Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a real-numbered term.
z3py.open_log
def open_log(fname)
Definition: z3py.py:101
z3py.simplify_param_descrs
def simplify_param_descrs()
Definition: z3py.py:8267
z3py.EmptySet
def EmptySet(s)
Definition: z3py.py:4613
z3py.SuffixOf
def SuffixOf(a, b)
Definition: z3py.py:10226
z3py.user_prop_eq
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:10568
z3py.fpSignedToFP
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9872
z3py.get_default_rounding_mode
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8683
Z3_mk_set_complement
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
z3py.PbEq
def PbEq(args, k, ctx=None)
Definition: z3py.py:8447
Z3_mk_fpa_neg
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
z3py.is_fprm_value
def is_fprm_value(a)
Definition: z3py.py:9089
z3py.user_prop_diseq
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:10574
Z3_tactic_using_params
Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p)
Return a tactic that applies t using the given set of parameters.
z3py.BVRedOr
def BVRedOr(a)
Definition: z3py.py:4200
z3py.is_quantifier
def is_quantifier(a)
Definition: z3py.py:2018
Z3_mk_seq_last_index
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,...
z3py.Length
def Length(s)
Definition: z3py.py:10302
z3py.get_ctx
def get_ctx(ctx)
Definition: z3py.py:237
z3py.BVAddNoOverflow
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4206
z3py.is_eq
def is_eq(a)
Definition: z3py.py:1533
Z3_mk_constructor
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort_opt const sorts[], unsigned sort_refs[])
Create a constructor.
z3py.fpIsNaN
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9638
z3py.URem
def URem(a, b)
Definition: z3py.py:4014
z3py.is_const
def is_const(a)
Definition: z3py.py:1182
z3py.Star
def Star(re)
Definition: z3py.py:10450
Z3_mk_fpa_sort_128
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_fpa_to_ieee_bv
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
z3py.is_real
def is_real(a)
Definition: z3py.py:2536
z3py.is_mod
def is_mod(a)
Definition: z3py.py:2677
z3py.Ints
def Ints(names, ctx=None)
Definition: z3py.py:3057
z3py.Model
def Model(ctx=None)
Definition: z3py.py:6277
z3py.Extract
def Extract(high, low, a)
Definition: z3py.py:3899
z3py.Int2BV
def Int2BV(a, num_bits)
Definition: z3py.py:3773
Z3_mk_str_to_int
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
z3py.Replace
def Replace(s, src, dst)
Definition: z3py.py:10259
z3py.FreshBool
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1628
z3py.Array
def Array(name, dom, rng)
Definition: z3py.py:4444
z3py.CreateDatatypes
def CreateDatatypes(*ds)
Definition: z3py.py:4823
z3py.main_ctx
def main_ctx()
Definition: z3py.py:211
Z3_get_tactic_name
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.
Z3_mk_repeat
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
z3py.RNE
def RNE(ctx=None)
Definition: z3py.py:9041
z3py.ParAndThen
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7887
z3py.BVAddNoUnderflow
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4212
z3py.FloatDouble
def FloatDouble(ctx=None)
Definition: z3py.py:8811
Z3_mk_func_decl
Z3_func_decl Z3_API Z3_mk_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a constant or function.
z3py.Float16
def Float16(ctx=None)
Definition: z3py.py:8786
z3py.Bools
def Bools(names, ctx=None)
Definition: z3py.py:1599
z3py.Intersect
def Intersect(*args)
Definition: z3py.py:10405
z3py.Sum
def Sum(*args)
Definition: z3py.py:8317
z3py.RoundNearestTiesToAway
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9045
z3py.is_pattern
def is_pattern(a)
Definition: z3py.py:1780
Z3_mk_re_range
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.
z3py.parse_smt2_file
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8660
z3py.substitute_vars
def substitute_vars(t, *m)
Definition: z3py.py:8297
Z3_mk_fresh_func_decl
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.
z3py.is_le
def is_le(a)
Definition: z3py.py:2688
z3py.help_simplify
def help_simplify()
Definition: z3py.py:8263
z3py.IsSubset
def IsSubset(a, b)
Definition: z3py.py:4702
Z3_mk_ite
Z3_ast Z3_API Z3_mk_ite(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_ast t3)
Create an AST node representing an if-then-else: ite(t1, t2, t3).
Z3_mk_extract
Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast t1)
Extract the bits high down to low from a bit-vector of size m to yield a new bit-vector of size n,...
z3py.user_prop_push
def user_prop_push(ctx)
Definition: z3py.py:10543
z3py.Implies
def Implies(a, b, ctx=None)
Definition: z3py.py:1641
Z3_mk_seq_in_re
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.
Z3_mk_set_difference
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
Z3_mk_bvule
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
z3py.BVSDivNoOverflow
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4231
z3py.is_arith
def is_arith(a)
Definition: z3py.py:2498
z3py.BitVec
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3811
z3py.is_sort
def is_sort(s)
Definition: z3py.py:596
z3py.is_int_value
def is_int_value(a)
Definition: z3py.py:2560
Z3_mk_bool_sort
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
z3py.ToReal
def ToReal(a)
Definition: z3py.py:3147
Z3_get_num_tactics
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
z3py.BitVecs
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3834
z3py.is_re
def is_re(s)
Definition: z3py.py:10369
z3py.is_int
def is_int(a)
Definition: z3py.py:2518
Z3_tactic_cond
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...
z3py.LastIndexOf
def LastIndexOf(s, substr)
Definition: z3py.py:10293
Z3_mk_lstring
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...
z3py.is_string
def is_string(a)
Definition: z3py.py:10123
z3py.Default
def Default(a)
Definition: z3py.py:4478
Z3_global_param_get
Z3_bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.
z3py.get_map_func
def get_map_func(a)
Definition: z3py.py:4395
z3py.Distinct
def Distinct(*args)
Definition: z3py.py:1290
z3py.fpIsNormal
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9664
z3py.FreshConst
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346
z3py.PbGe
def PbGe(args, k)
Definition: z3py.py:8437
Z3_tactic_repeat
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...
Z3_mk_ext_rotate_right
Z3_ast Z3_API Z3_mk_ext_rotate_right(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the right t2 times.
Z3_mk_fpa_sort_32
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
z3py.z3_debug
def z3_debug()
Definition: z3py.py:56
z3py.is_true
def is_true(a)
Definition: z3py.py:1459
Z3_mk_const
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
z3py.SetSort
def SetSort(s)
Sets.
Definition: z3py.py:4609
z3py.Real
def Real(name, ctx=None)
Definition: z3py.py:3094
Z3_disable_trace
void Z3_API Z3_disable_trace(Z3_string tag)
Disable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
z3py.probe_description
def probe_description(name, ctx=None)
Definition: z3py.py:8145
z3py.Lambda
def Lambda(vs, body)
Definition: z3py.py:2102
z3py.tactic_description
def tactic_description(name, ctx=None)
Definition: z3py.py:7954
Z3_mk_bv_sort
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
z3py.StringVal
def StringVal(s, ctx=None)
Definition: z3py.py:10140
z3py.StrToInt
def StrToInt(s)
Definition: z3py.py:10311
Z3_get_index_value
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.
Z3_mk_seq_to_re
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
z3py.fpFP
def fpFP(sgn, exp, sig, ctx=None)
Definition: z3py.py:9754
Z3_mk_int_sort
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Z3_probe_get_descr
Z3_string Z3_API Z3_probe_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the probe with the given name.
Z3_mk_enumeration_sort
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.
z3py.fpPlusZero
def fpPlusZero(s)
Definition: z3py.py:9341
z3py.fpNaN
def fpNaN(s)
Definition: z3py.py:9298
z3py.FPSort
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9240
Z3_get_full_version
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.
Z3_mk_bvurem
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
z3py.get_version
def get_version()
Definition: z3py.py:81
z3py.DeclareSort
def DeclareSort(name, ctx=None)
Definition: z3py.py:637
Z3_mk_bvsub_no_overflow
Z3_ast Z3_API Z3_mk_bvsub_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed subtraction of t1 and t2 does not overflow.
z3py.Unit
def Unit(a)
Definition: z3py.py:10208
Z3_mk_constructor_list
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
z3py.is_finite_domain
def is_finite_domain(a)
Definition: z3py.py:7307
z3py.fpZero
def fpZero(s, negative)
Definition: z3py.py:9351
z3py.fpSqrt
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9628
Z3_mk_seq_replace
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.
z3py.RealVar
def RealVar(idx, ctx=None)
Definition: z3py.py:1363
z3py.FP
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9401
Z3_mk_seq_contains
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
z3py.fpDiv
def fpDiv(rm, a, b, ctx=None)
Definition: z3py.py:9568
z3py.is_as_array
def is_as_array(n)
Definition: z3py.py:6281
z3py.set_default_fp_sort
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8713
Z3_mk_bound
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a bound variable.
z3py.PiecewiseLinearOrder
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10497
z3py.is_store
def is_store(a)
Definition: z3py.py:4591
Z3_mk_datatypes
void Z3_API Z3_mk_datatypes(Z3_context c, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort sorts[], Z3_constructor_list constructor_lists[])
Create mutually recursive datatypes.
Z3_mk_bvadd_no_underflow
Z3_ast Z3_API Z3_mk_bvadd_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed addition of t1 and t2 does not underflow.
Z3_mk_seq_empty
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
z3py.Select
def Select(a, i)
Definition: z3py.py:4505
z3py.FreshFunction
def FreshFunction(*sig)
Definition: z3py.py:821
z3py.AtMost
def AtMost(*args)
Definition: z3py.py:8368
z3py.RecAddDefinition
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
z3py.fpToSBV
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9915
z3py.is_div
def is_div(a)
Definition: z3py.py:2650
Z3_mk_string_sort
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for 8 bit strings.
Z3_probe_not
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
z3py.Re
def Re(s, ctx=None)
Definition: z3py.py:10334
z3py.FullSet
def FullSet(s)
Definition: z3py.py:4621
z3py.OrElse
def OrElse(*ts, **ks)
Definition: z3py.py:7835
z3py.is_probe
def is_probe(p)
Definition: z3py.py:8119
Z3_mk_array_sort
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
z3py.is_mul
def is_mul(a)
Definition: z3py.py:2628
Z3_mk_int2bv
Z3_ast Z3_API Z3_mk_int2bv(Z3_context c, unsigned n, Z3_ast t1)
Create an n bit bit-vector from the integer argument t1.
z3py.FreshInt
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3081
z3py.fpPlusInfinity
def fpPlusInfinity(s)
Definition: z3py.py:9314
Z3_mk_false
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
z3py.solve_using
def solve_using(s, *args, **keywords)
Definition: z3py.py:8486
Z3_mk_fpa_round_toward_negative
Z3_ast Z3_API Z3_mk_fpa_round_toward_negative(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode.
z3py.Function
def Function(name, *sig)
Definition: z3py.py:799
z3py.Plus
def Plus(re)
Definition: z3py.py:10422
z3py.append_log
def append_log(s)
Definition: z3py.py:105
z3py.FiniteDomainVal
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7346
z3py.Float128
def Float128(ctx=None)
Definition: z3py.py:8816
z3py.is_add
def is_add(a)
Definition: z3py.py:2617
z3py.Then
def Then(*ts, **ks)
Definition: z3py.py:7823
Z3_get_num_probes
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
Z3_parse_smtlib2_string
Z3_ast_vector Z3_API Z3_parse_smtlib2_string(Z3_context c, Z3_string str, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Parse the given string using the SMT-LIB2 parser.
Z3_mk_atleast
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
z3py.LinearOrder
def LinearOrder(a, index)
Definition: z3py.py:10491
z3py.ArraySort
def ArraySort(*sig)
Definition: z3py.py:4412
z3py.BitVecSort
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3781
z3py.fpAdd
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9524
z3py.Contains
def Contains(a, b)
Definition: z3py.py:10240
z3py.is_finite_domain_value
def is_finite_domain_value(a)
Definition: z3py.py:7360
z3py.Bool
def Bool(name, ctx=None)
Definition: z3py.py:1588
z3py.SetUnion
def SetUnion(*args)
Definition: z3py.py:4629
Z3_mk_fpa_sort_double
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
Z3_tactic_get_descr
Z3_string Z3_API Z3_tactic_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the tactic with the given name.
z3py.fpSub
def fpSub(rm, a, b, ctx=None)
Definition: z3py.py:9540
Z3_mk_set_member
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
z3py.is_const_array
def is_const_array(a)
Definition: z3py.py:4348
z3py.Product
def Product(*args)
Definition: z3py.py:8343
Z3_tactic_par_or
Z3_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[])
Return a tactic that applies the given tactics in parallel.
z3py.IntToStr
def IntToStr(s)
Definition: z3py.py:10327
z3py.TryFor
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7936
z3py.SetDel
def SetDel(s, e)
Definition: z3py.py:4663
Z3_mk_bvult
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
Z3_simplify
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
z3py.user_prop_final
def user_prop_final(ctx, cb)
Definition: z3py.py:10562
z3py.SRem
def SRem(a, b)
Definition: z3py.py:4034
z3py.get_var_index
def get_var_index(a)
Definition: z3py.py:1224
z3py.fpNeg
def fpNeg(a, ctx=None)
Definition: z3py.py:9464
z3py.fpLEQ
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9699
z3py.EnumSort
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5035
z3py.BoolVal
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
z3py.is_ast
def is_ast(a)
Definition: z3py.py:412
z3py.get_default_fp_sort
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8710
Z3_mk_re_union
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
Z3_mk_bvudiv
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
Z3_mk_re_sort
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
z3py.is_bv_value
def is_bv_value(a)
Definition: z3py.py:3737
z3py.is_idiv
def is_idiv(a)
Definition: z3py.py:2666
Z3_mk_sign_ext
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...
z3py.Concat
def Concat(*args)
Definition: z3py.py:3854
Z3_mk_tree_order
Z3_func_decl Z3_API Z3_mk_tree_order(Z3_context c, Z3_sort a, unsigned id)
create a tree ordering relation over signature a identified using index id.
Z3_mk_seq_sort
Z3_sort Z3_API Z3_mk_seq_sort(Z3_context c, Z3_sort s)
Create a sequence sort out of the sort for the elements.
z3py.SolverFor
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6968
z3py.describe_probes
def describe_probes()
Definition: z3py.py:8153
Z3_mk_pble
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
z3py.Not
def Not(a, ctx=None)
Definition: z3py.py:1669
Z3_substitute
Z3_ast Z3_API Z3_substitute(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const from[], Z3_ast const to[])
Substitute every occurrence of from[i] in a with to[i], for i smaller than num_exprs....
Z3_mk_simple_solver
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
z3py.K
def K(dom, v)
Definition: z3py.py:4542
Z3_mk_bvsub_no_underflow
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.
z3py.BVRedAnd
def BVRedAnd(a)
Definition: z3py.py:4194
z3py.is_fp_sort
def is_fp_sort(s)
Definition: z3py.py:8830
z3py.is_var
def is_var(a)
Definition: z3py.py:1200
Z3_open_log
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.
z3py.BVSNegNoOverflow
def BVSNegNoOverflow(a)
Definition: z3py.py:4237
Z3_mk_store
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
Z3_mk_bvredand
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
z3py.IntVector
def IntVector(prefix, sz, ctx=None)
Definition: z3py.py:3069
z3py.is_bv_sort
def is_bv_sort(s)
Definition: z3py.py:3259
z3py.Full
def Full(s)
Definition: z3py.py:10194
Z3_mk_fpa_sort_half
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
Z3_mk_not
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
z3py.is_is_int
def is_is_int(a)
Definition: z3py.py:2732
z3py.AndThen
def AndThen(*ts, **ks)
Definition: z3py.py:7804
z3py.user_prop_pop
def user_prop_pop(ctx, num_scopes)
Definition: z3py.py:10546
z3py.IntSort
def IntSort(ctx=None)
Definition: z3py.py:2942
z3py.fpIsZero
def fpIsZero(a, ctx=None)
Definition: z3py.py:9659
z3py.is_rational_value
def is_rational_value(a)
Definition: z3py.py:2583
z3py.PartialOrder
def PartialOrder(a, index)
Definition: z3py.py:10488
Z3_enable_trace
void Z3_API Z3_enable_trace(Z3_string tag)
Enable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
Z3_mk_set_add
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
Z3_mk_seq_index
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of first occurrence of substr in s starting from offset offset. If s does not contain su...
z3py.UGT
def UGT(a, b)
Definition: z3py.py:3977
Z3_mk_const_array
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
Z3_substitute_vars
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the free variables in a with the expressions in to. For every i smaller than num_exprs,...
Z3_mk_int2real
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
Z3_mk_fpa_inf
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
Z3_mk_re_intersect
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
Z3_mk_fpa_to_fp_float
Z3_ast Z3_API Z3_mk_fpa_to_fp_float(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a FloatingPoint term into another term of different FloatingPoint sort.
Z3_mk_fpa_round_toward_zero
Z3_ast Z3_API Z3_mk_fpa_round_toward_zero(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.
z3py.UDiv
def UDiv(a, b)
Definition: z3py.py:3994
z3py.BV2Int
def BV2Int(a, is_signed=False)
Definition: z3py.py:3751
z3py.is_func_decl
def is_func_decl(a)
Definition: z3py.py:787
z3py.RoundTowardZero
def RoundTowardZero(ctx=None)
Definition: z3py.py:9069
z3py.WithParams
def WithParams(t, p)
Definition: z3py.py:7904
z3py.RecFunction
def RecFunction(name, *sig)
Definition: z3py.py:843
z3py.Xor
def Xor(a, b, ctx=None)
Definition: z3py.py:1654
Z3_mk_fpa_sort_16
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
z3py.is_algebraic_value
def is_algebraic_value(a)
Definition: z3py.py:2604
z3py.BVMulNoUnderflow
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4250
z3py.is_to_int
def is_to_int(a)
Definition: z3py.py:2757
Z3_mk_fpa_abs
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
Z3_mk_is_int
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
Z3_mk_fpa_nan
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
Z3_global_param_set
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.
z3py.prove
def prove(claim, **keywords)
Definition: z3py.py:8515
z3py.is_bv
def is_bv(a)
Definition: z3py.py:3724
z3py.fpMin
def fpMin(a, b, ctx=None)
Definition: z3py.py:9595
Z3_mk_bvsdiv_no_overflow
Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed division of t1 and t2 does not overflow.
Z3_mk_bvuge
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_mk_array_sort_n
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const *domain, Z3_sort range)
Create an array type with N arguments.
z3py.is_expr
def is_expr(a)
Definition: z3py.py:1135
z3py.Sqrt
def Sqrt(a, ctx=None)
Definition: z3py.py:3197
z3py.SetComplement
def SetComplement(s)
Definition: z3py.py:4673
z3py.is_app_of
def is_app_of(a, k)
Definition: z3py.py:1256
z3py.BVMulNoOverflow
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4243
Z3_get_sort
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
z3py.Repeat
def Repeat(t, max=4294967295, ctx=None)
Definition: z3py.py:7917
z3py.fpToReal
def fpToReal(x, ctx=None)
Definition: z3py.py:9957
z3py.Update
def Update(a, i, v)
Definition: z3py.py:4457
z3py.describe_tactics
def describe_tactics()
Definition: z3py.py:7962
z3py.is_bool
def is_bool(a)
Definition: z3py.py:1442
z3py.get_full_version
def get_full_version()
Definition: z3py.py:89
Z3_mk_atmost
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
z3py.is_lt
def is_lt(a)
Definition: z3py.py:2699
Z3_mk_bvsrem
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
Z3_mk_uninterpreted_sort
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
z3py.FloatHalf
def FloatHalf(ctx=None)
Definition: z3py.py:8791
z3py.fpIsSubnormal
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9669
z3py.SetAdd
def SetAdd(s, e)
Definition: z3py.py:4653
z3py.Ext
def Ext(a, b)
Definition: z3py.py:4563
Z3_mk_lambda_const
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, unsigned num_bound, Z3_app const bound[], Z3_ast body)
Create a lambda expression using a list of constants that form the set of bound variables.
z3py.fpIsNegative
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9674
z3py.fpFPToFP
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9836
z3py.fpNEQ
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9743
z3py.SeqSort
def SeqSort(s)
Definition: z3py.py:10037
z3py.Map
def Map(f, *args)
Definition: z3py.py:4520
z3py.BVSubNoUnderflow
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4225
Z3_mk_set_subset
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
z3py.ParThen
def ParThen(t1, t2, ctx=None)
Definition: z3py.py:7873
Z3_mk_bvlshr
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
z3py.args2params
def args2params(arguments, keywords, ctx=None)
Definition: z3py.py:5111
Z3_mk_pbge
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
z3py.is_false
def is_false(a)
Definition: z3py.py:1476
z3py.Store
def Store(a, i, v)
Definition: z3py.py:4489
z3py.FloatSingle
def FloatSingle(ctx=None)
Definition: z3py.py:8801
z3py.ULE
def ULE(a, b)
Definition: z3py.py:3926
Z3_mk_real_sort
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
z3py.FailIf
def FailIf(p, ctx=None)
Definition: z3py.py:8186
Z3_mk_fpa_sort_single
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
Z3_mk_re_empty
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
z3py.BoolSort
def BoolSort(ctx=None)
Definition: z3py.py:1553
z3py.get_param
def get_param(name)
Definition: z3py.py:273
z3py.fpRealToFP
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9855
z3py.Complement
def Complement(re)
Definition: z3py.py:10446
z3py.RealVector
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3120
z3py.UserPropagateBase.eq
eq
Definition: z3py.py:10606
z3py.Empty
def Empty(s)
Definition: z3py.py:10175
z3py.Option
def Option(re)
Definition: z3py.py:10434
Z3_tactic_when
Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t)
Return a tactic that applies t to a given goal is the probe p evaluates to true. If p evaluates to fa...
z3py.fpIsPositive
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9679
Z3_mk_re_concat
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
z3py.ReSort
def ReSort(s)
Definition: z3py.py:10354
Z3_mk_mul
Z3_ast Z3_API Z3_mk_mul(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] * ... * args[num_args-1].
z3py.RTZ
def RTZ(ctx=None)
Definition: z3py.py:9073
z3py.is_sub
def is_sub(a)
Definition: z3py.py:2639
Z3_mk_seq_extract
Z3_ast Z3_API Z3_mk_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.
z3py.set_option
def set_option(*args, **kws)
Definition: z3py.py:268
z3py.SubString
def SubString(s, offset, length)
Definition: z3py.py:10160
z3py.When
def When(p, t, ctx=None)
Definition: z3py.py:8205
z3py.is_seq
def is_seq(a)
Definition: z3py.py:10114
Z3_mk_transitive_closure
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
Z3_mk_int_symbol
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
z3py.fpToIEEEBV
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9976
z3py.Q
def Q(a, b, ctx=None)
Definition: z3py.py:3033
z3py.String
def String(name, ctx=None)
Definition: z3py.py:10145
Z3_mk_partial_order
Z3_func_decl Z3_API Z3_mk_partial_order(Z3_context c, Z3_sort a, unsigned id)
create a partial ordering relation over signature a and index id.
Z3_mk_fpa_round_nearest_ties_to_away
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_away(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
Z3_mk_piecewise_linear_order
Z3_func_decl Z3_API Z3_mk_piecewise_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a piecewise linear ordering relation over signature a and index id.