Z3
Data Structures | Functions | Variables
z3py Namespace Reference

Data Structures

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

Functions

def z3_debug ()
 
def enable_trace (msg)
 
def disable_trace (msg)
 
def get_version_string ()
 
def get_version ()
 
def get_full_version ()
 
def open_log (fname)
 
def append_log (s)
 
def to_symbol (s, ctx=None)
 
def z3_error_handler (c, e)
 
def main_ctx ()
 
def get_ctx (ctx)
 
def set_param (*args, **kws)
 
def reset_params ()
 
def set_option (*args, **kws)
 
def get_param (name)
 
def is_ast (a)
 
def eq (a, b)
 
def is_sort (s)
 
def DeclareSort (name, ctx=None)
 
def is_func_decl (a)
 
def Function (name, *sig)
 
def RecFunction (name, *sig)
 
def RecAddDefinition (f, args, body)
 
def is_expr (a)
 
def is_app (a)
 
def is_const (a)
 
def is_var (a)
 
def get_var_index (a)
 
def is_app_of (a, k)
 
def If (a, b, c, ctx=None)
 
def Distinct (*args)
 
def Const (name, sort)
 
def Consts (names, sort)
 
def FreshConst (sort, prefix='c')
 
def Var (idx, s)
 
def RealVar (idx, ctx=None)
 
def RealVarVector (n, ctx=None)
 
def is_bool (a)
 
def is_true (a)
 
def is_false (a)
 
def is_and (a)
 
def is_or (a)
 
def is_implies (a)
 
def is_not (a)
 
def is_eq (a)
 
def is_distinct (a)
 
def BoolSort (ctx=None)
 
def BoolVal (val, ctx=None)
 
def Bool (name, ctx=None)
 
def Bools (names, ctx=None)
 
def BoolVector (prefix, sz, ctx=None)
 
def FreshBool (prefix='b', ctx=None)
 
def Implies (a, b, ctx=None)
 
def Xor (a, b, ctx=None)
 
def Not (a, ctx=None)
 
def mk_not (a)
 
def And (*args)
 
def Or (*args)
 
def is_pattern (a)
 
def MultiPattern (*args)
 
def is_quantifier (a)
 
def ForAll (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
 
def Exists (vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
 
def Lambda (vs, body)
 
def is_arith_sort (s)
 
def is_arith (a)
 
def is_int (a)
 
def is_real (a)
 
def is_int_value (a)
 
def is_rational_value (a)
 
def is_algebraic_value (a)
 
def is_add (a)
 
def is_mul (a)
 
def is_sub (a)
 
def is_div (a)
 
def is_idiv (a)
 
def is_mod (a)
 
def is_le (a)
 
def is_lt (a)
 
def is_ge (a)
 
def is_gt (a)
 
def is_is_int (a)
 
def is_to_real (a)
 
def is_to_int (a)
 
def IntSort (ctx=None)
 
def RealSort (ctx=None)
 
def IntVal (val, ctx=None)
 
def RealVal (val, ctx=None)
 
def RatVal (a, b, ctx=None)
 
def Q (a, b, ctx=None)
 
def Int (name, ctx=None)
 
def Ints (names, ctx=None)
 
def IntVector (prefix, sz, ctx=None)
 
def FreshInt (prefix='x', ctx=None)
 
def Real (name, ctx=None)
 
def Reals (names, ctx=None)
 
def RealVector (prefix, sz, ctx=None)
 
def FreshReal (prefix='b', ctx=None)
 
def ToReal (a)
 
def ToInt (a)
 
def IsInt (a)
 
def Sqrt (a, ctx=None)
 
def Cbrt (a, ctx=None)
 
def is_bv_sort (s)
 
def is_bv (a)
 
def is_bv_value (a)
 
def BV2Int (a, is_signed=False)
 
def Int2BV (a, num_bits)
 
def BitVecSort (sz, ctx=None)
 
def BitVecVal (val, bv, ctx=None)
 
def BitVec (name, bv, ctx=None)
 
def BitVecs (names, bv, ctx=None)
 
def Concat (*args)
 
def Extract (high, low, a)
 
def ULE (a, b)
 
def ULT (a, b)
 
def UGE (a, b)
 
def UGT (a, b)
 
def UDiv (a, b)
 
def URem (a, b)
 
def SRem (a, b)
 
def LShR (a, b)
 
def RotateLeft (a, b)
 
def RotateRight (a, b)
 
def SignExt (n, a)
 
def ZeroExt (n, a)
 
def RepeatBitVec (n, a)
 
def BVRedAnd (a)
 
def BVRedOr (a)
 
def BVAddNoOverflow (a, b, signed)
 
def BVAddNoUnderflow (a, b)
 
def BVSubNoOverflow (a, b)
 
def BVSubNoUnderflow (a, b, signed)
 
def BVSDivNoOverflow (a, b)
 
def BVSNegNoOverflow (a)
 
def BVMulNoOverflow (a, b, signed)
 
def BVMulNoUnderflow (a, b)
 
def is_array_sort (a)
 
def is_array (a)
 
def is_const_array (a)
 
def is_K (a)
 
def is_map (a)
 
def is_default (a)
 
def get_map_func (a)
 
def ArraySort (*sig)
 
def Array (name, dom, rng)
 
def Update (a, i, v)
 
def Default (a)
 
def Store (a, i, v)
 
def Select (a, i)
 
def Map (f, *args)
 
def K (dom, v)
 
def Ext (a, b)
 
def SetHasSize (a, k)
 
def is_select (a)
 
def is_store (a)
 
def SetSort (s)
 Sets. More...
 
def EmptySet (s)
 
def FullSet (s)
 
def SetUnion (*args)
 
def SetIntersect (*args)
 
def SetAdd (s, e)
 
def SetDel (s, e)
 
def SetComplement (s)
 
def SetDifference (a, b)
 
def IsMember (e, s)
 
def IsSubset (a, b)
 
def CreateDatatypes (*ds)
 
def TupleSort (name, sorts, ctx=None)
 
def DisjointSum (name, sorts, ctx=None)
 
def EnumSort (name, values, ctx=None)
 
def args2params (arguments, keywords, ctx=None)
 
def Model (ctx=None)
 
def is_as_array (n)
 
def get_as_array_func (n)
 
def SolverFor (logic, ctx=None, logFile=None)
 
def SimpleSolver (ctx=None, logFile=None)
 
def FiniteDomainSort (name, sz, ctx=None)
 
def is_finite_domain_sort (s)
 
def is_finite_domain (a)
 
def FiniteDomainVal (val, sort, ctx=None)
 
def is_finite_domain_value (a)
 
def AndThen (*ts, **ks)
 
def Then (*ts, **ks)
 
def OrElse (*ts, **ks)
 
def ParOr (*ts, **ks)
 
def ParThen (t1, t2, ctx=None)
 
def ParAndThen (t1, t2, ctx=None)
 
def With (t, *args, **keys)
 
def WithParams (t, p)
 
def Repeat (t, max=4294967295, ctx=None)
 
def TryFor (t, ms, ctx=None)
 
def tactics (ctx=None)
 
def tactic_description (name, ctx=None)
 
def describe_tactics ()
 
def is_probe (p)
 
def probes (ctx=None)
 
def probe_description (name, ctx=None)
 
def describe_probes ()
 
def FailIf (p, ctx=None)
 
def When (p, t, ctx=None)
 
def Cond (p, t1, t2, ctx=None)
 
def simplify (a, *arguments, **keywords)
 Utils. More...
 
def help_simplify ()
 
def simplify_param_descrs ()
 
def substitute (t, *m)
 
def substitute_vars (t, *m)
 
def Sum (*args)
 
def Product (*args)
 
def AtMost (*args)
 
def AtLeast (*args)
 
def PbLe (args, k)
 
def PbGe (args, k)
 
def PbEq (args, k, ctx=None)
 
def solve (*args, **keywords)
 
def solve_using (s, *args, **keywords)
 
def prove (claim, **keywords)
 
def parse_smt2_string (s, sorts={}, decls={}, ctx=None)
 
def parse_smt2_file (f, sorts={}, decls={}, ctx=None)
 
def get_default_rounding_mode (ctx=None)
 
def set_default_rounding_mode (rm, ctx=None)
 
def get_default_fp_sort (ctx=None)
 
def set_default_fp_sort (ebits, sbits, ctx=None)
 
def Float16 (ctx=None)
 
def FloatHalf (ctx=None)
 
def Float32 (ctx=None)
 
def FloatSingle (ctx=None)
 
def Float64 (ctx=None)
 
def FloatDouble (ctx=None)
 
def Float128 (ctx=None)
 
def FloatQuadruple (ctx=None)
 
def is_fp_sort (s)
 
def is_fprm_sort (s)
 
def RoundNearestTiesToEven (ctx=None)
 
def RNE (ctx=None)
 
def RoundNearestTiesToAway (ctx=None)
 
def RNA (ctx=None)
 
def RoundTowardPositive (ctx=None)
 
def RTP (ctx=None)
 
def RoundTowardNegative (ctx=None)
 
def RTN (ctx=None)
 
def RoundTowardZero (ctx=None)
 
def RTZ (ctx=None)
 
def is_fprm (a)
 
def is_fprm_value (a)
 
def is_fp (a)
 
def is_fp_value (a)
 
def FPSort (ebits, sbits, ctx=None)
 
def fpNaN (s)
 
def fpPlusInfinity (s)
 
def fpMinusInfinity (s)
 
def fpInfinity (s, negative)
 
def fpPlusZero (s)
 
def fpMinusZero (s)
 
def fpZero (s, negative)
 
def FPVal (sig, exp=None, fps=None, ctx=None)
 
def FP (name, fpsort, ctx=None)
 
def FPs (names, fpsort, ctx=None)
 
def fpAbs (a, ctx=None)
 
def fpNeg (a, ctx=None)
 
def fpAdd (rm, a, b, ctx=None)
 
def fpSub (rm, a, b, ctx=None)
 
def fpMul (rm, a, b, ctx=None)
 
def fpDiv (rm, a, b, ctx=None)
 
def fpRem (a, b, ctx=None)
 
def fpMin (a, b, ctx=None)
 
def fpMax (a, b, ctx=None)
 
def fpFMA (rm, a, b, c, ctx=None)
 
def fpSqrt (rm, a, ctx=None)
 
def fpRoundToIntegral (rm, a, ctx=None)
 
def fpIsNaN (a, ctx=None)
 
def fpIsInf (a, ctx=None)
 
def fpIsZero (a, ctx=None)
 
def fpIsNormal (a, ctx=None)
 
def fpIsSubnormal (a, ctx=None)
 
def fpIsNegative (a, ctx=None)
 
def fpIsPositive (a, ctx=None)
 
def fpLT (a, b, ctx=None)
 
def fpLEQ (a, b, ctx=None)
 
def fpGT (a, b, ctx=None)
 
def fpGEQ (a, b, ctx=None)
 
def fpEQ (a, b, ctx=None)
 
def fpNEQ (a, b, ctx=None)
 
def fpFP (sgn, exp, sig, ctx=None)
 
def fpToFP (a1, a2=None, a3=None, ctx=None)
 
def fpBVToFP (v, sort, ctx=None)
 
def fpFPToFP (rm, v, sort, ctx=None)
 
def fpRealToFP (rm, v, sort, ctx=None)
 
def fpSignedToFP (rm, v, sort, ctx=None)
 
def fpUnsignedToFP (rm, v, sort, ctx=None)
 
def fpToFPUnsigned (rm, x, s, ctx=None)
 
def fpToSBV (rm, x, s, ctx=None)
 
def fpToUBV (rm, x, s, ctx=None)
 
def fpToReal (x, ctx=None)
 
def fpToIEEEBV (x, ctx=None)
 
def StringSort (ctx=None)
 
def SeqSort (s)
 
def is_seq (a)
 
def is_string (a)
 
def is_string_value (a)
 
def StringVal (s, ctx=None)
 
def String (name, ctx=None)
 
def Strings (names, ctx=None)
 
def SubString (s, offset, length)
 
def SubSeq (s, offset, length)
 
def Empty (s)
 
def Full (s)
 
def Unit (a)
 
def PrefixOf (a, b)
 
def SuffixOf (a, b)
 
def Contains (a, b)
 
def Replace (s, src, dst)
 
def IndexOf (s, substr)
 
def IndexOf (s, substr, offset)
 
def LastIndexOf (s, substr)
 
def Length (s)
 
def StrToInt (s)
 
def IntToStr (s)
 
def Re (s, ctx=None)
 
def ReSort (s)
 
def is_re (s)
 
def InRe (s, re)
 
def Union (*args)
 
def Intersect (*args)
 
def Plus (re)
 
def Option (re)
 
def Complement (re)
 
def Star (re)
 
def Loop (re, lo, hi=0)
 
def Range (lo, hi, ctx=None)
 
def PartialOrder (a, index)
 
def LinearOrder (a, index)
 
def TreeOrder (a, index)
 
def PiecewiseLinearOrder (a, index)
 
def TransitiveClosure (f)
 

Variables

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

Function Documentation

◆ And()

def z3py.And ( args)
Create a Z3 and-expression or and-probe.

>>> p, q, r = Bools('p q r')
>>> And(p, q, r)
And(p, q, r)
>>> P = BoolVector('p', 5)
>>> And(P)
And(p__0, p__1, p__2, p__3, p__4)

Definition at line 1680 of file z3py.py.

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

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

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

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

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

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

4403 def Array(name, dom, rng):
4404  """Return an array constant named `name` with the given domain and range sorts.
4405 
4406  >>> a = Array('a', IntSort(), IntSort())
4407  >>> a.sort()
4408  Array(Int, Int)
4409  >>> a[0]
4410  a[0]
4411  """
4412  s = ArraySort(dom, rng)
4413  ctx = s.ctx
4414  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4415 

◆ ArraySort()

def z3py.ArraySort ( sig)
Return the Z3 array sort with the given domain and range sorts.

>>> A = ArraySort(IntSort(), BoolSort())
>>> A
Array(Int, Bool)
>>> A.domain()
Int
>>> A.range()
Bool
>>> AA = ArraySort(IntSort(), A)
>>> AA
Array(Int, Array(Int, Bool))

Definition at line 4371 of file z3py.py.

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

Referenced by Array(), Context.mkArraySort(), and SetSort().

◆ AtLeast()

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

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

Definition at line 8328 of file z3py.py.

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

◆ AtMost()

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

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

Definition at line 8311 of file z3py.py.

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

◆ BitVec()

def z3py.BitVec (   name,
  bv,
  ctx = None 
)
Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
If `ctx=None`, then the global context is used.

>>> x  = BitVec('x', 16)
>>> is_bv(x)
True
>>> x.size()
16
>>> x.sort()
BitVec(16)
>>> word = BitVecSort(16)
>>> x2 = BitVec('x', word)
>>> eq(x, x2)
True

Definition at line 3770 of file z3py.py.

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

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

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

◆ BitVecSort()

def z3py.BitVecSort (   sz,
  ctx = None 
)
Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.

>>> Byte = BitVecSort(8)
>>> Word = BitVecSort(16)
>>> Byte
BitVec(8)
>>> x = Const('x', Byte)
>>> eq(x, BitVec('x', 8))
True

Definition at line 3740 of file z3py.py.

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

Referenced by BitVec(), BitVecVal(), and Context.mkBitVecSort().

◆ BitVecVal()

def z3py.BitVecVal (   val,
  bv,
  ctx = None 
)
Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.

>>> v = BitVecVal(10, 32)
>>> v
10
>>> print("0x%.8x" % v.as_long())
0x0000000a

Definition at line 3754 of file z3py.py.

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

◆ Bool()

def z3py.Bool (   name,
  ctx = None 
)
Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.

>>> p = Bool('p')
>>> q = Bool('q')
>>> And(p, q)
And(p, q)

Definition at line 1568 of file z3py.py.

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

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

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

◆ BoolSort()

def z3py.BoolSort (   ctx = None)
Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.

>>> BoolSort()
Bool
>>> p = Const('p', BoolSort())
>>> is_bool(p)
True
>>> r = Function('r', IntSort(), IntSort(), BoolSort())
>>> r(0, 1)
r(0, 1)
>>> is_bool(r(0, 1))
True

Definition at line 1533 of file z3py.py.

1533 def BoolSort(ctx=None):
1534  """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1535 
1536  >>> BoolSort()
1537  Bool
1538  >>> p = Const('p', BoolSort())
1539  >>> is_bool(p)
1540  True
1541  >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1542  >>> r(0, 1)
1543  r(0, 1)
1544  >>> is_bool(r(0, 1))
1545  True
1546  """
1547  ctx = _get_ctx(ctx)
1548  return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1549 

Referenced by Goal.assert_exprs(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), Bool(), FreshBool(), Context.getBoolSort(), If(), Implies(), Context.mkBoolSort(), 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 1550 of file z3py.py.

1550 def BoolVal(val, ctx=None):
1551  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1552 
1553  >>> BoolVal(True)
1554  True
1555  >>> is_true(BoolVal(True))
1556  True
1557  >>> is_true(True)
1558  False
1559  >>> is_false(BoolVal(False))
1560  True
1561  """
1562  ctx = _get_ctx(ctx)
1563  if val == False:
1564  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1565  else:
1566  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1567 

Referenced by AlgebraicNumRef.as_decimal(), Goal.as_expr(), ApplyResult.as_expr(), BoolSortRef.cast(), 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 1594 of file z3py.py.

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

◆ BV2Int()

def z3py.BV2Int (   a,
  is_signed = False 
)
Return the Z3 expression BV2Int(a).

>>> b = BitVec('b', 3)
>>> BV2Int(b).sort()
Int
>>> x = Int('x')
>>> x > BV2Int(b)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=False)
x > BV2Int(b)
>>> x > BV2Int(b, is_signed=True)
x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
>>> solve(x > BV2Int(b), b == 1, x < 3)
[x = 2, b = 1]

Definition at line 3710 of file z3py.py.

3710 def BV2Int(a, is_signed=False):
3711  """Return the Z3 expression BV2Int(a).
3712 
3713  >>> b = BitVec('b', 3)
3714  >>> BV2Int(b).sort()
3715  Int
3716  >>> x = Int('x')
3717  >>> x > BV2Int(b)
3718  x > BV2Int(b)
3719  >>> x > BV2Int(b, is_signed=False)
3720  x > BV2Int(b)
3721  >>> x > BV2Int(b, is_signed=True)
3722  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3723  >>> solve(x > BV2Int(b), b == 1, x < 3)
3724  [x = 2, b = 1]
3725  """
3726  if z3_debug():
3727  _z3_assert(is_bv(a), "Z3 bit-vector expression expected")
3728  ctx = a.ctx
3729 
3730  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3731 

◆ BVAddNoOverflow()

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

Definition at line 4165 of file z3py.py.

4165 def BVAddNoOverflow(a, b, signed):
4166  """A predicate the determines that bit-vector addition does not overflow"""
4167  _check_bv_args(a, b)
4168  a, b = _coerce_exprs(a, b)
4169  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4170 

◆ BVAddNoUnderflow()

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

Definition at line 4171 of file z3py.py.

4171 def BVAddNoUnderflow(a, b):
4172  """A predicate the determines that signed bit-vector addition does not underflow"""
4173  _check_bv_args(a, b)
4174  a, b = _coerce_exprs(a, b)
4175  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4176 

◆ BVMulNoOverflow()

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

Definition at line 4202 of file z3py.py.

4202 def BVMulNoOverflow(a, b, signed):
4203  """A predicate the determines that bit-vector multiplication does not overflow"""
4204  _check_bv_args(a, b)
4205  a, b = _coerce_exprs(a, b)
4206  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4207 
4208 

◆ BVMulNoUnderflow()

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

Definition at line 4209 of file z3py.py.

4209 def BVMulNoUnderflow(a, b):
4210  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4211  _check_bv_args(a, b)
4212  a, b = _coerce_exprs(a, b)
4213  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4214 
4215 
4216 

◆ BVRedAnd()

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

Definition at line 4153 of file z3py.py.

4153 def BVRedAnd(a):
4154  """Return the reduction-and expression of `a`."""
4155  if z3_debug():
4156  _z3_assert(is_bv(a), "First argument must be a Z3 Bitvector expression")
4157  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4158 

◆ BVRedOr()

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

Definition at line 4159 of file z3py.py.

4159 def BVRedOr(a):
4160  """Return the reduction-or expression of `a`."""
4161  if z3_debug():
4162  _z3_assert(is_bv(a), "First argument must be a Z3 Bitvector expression")
4163  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4164 

◆ BVSDivNoOverflow()

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

Definition at line 4190 of file z3py.py.

4190 def BVSDivNoOverflow(a, b):
4191  """A predicate the determines that bit-vector signed division does not overflow"""
4192  _check_bv_args(a, b)
4193  a, b = _coerce_exprs(a, b)
4194  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4195 

◆ BVSNegNoOverflow()

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

Definition at line 4196 of file z3py.py.

4196 def BVSNegNoOverflow(a):
4197  """A predicate the determines that bit-vector unary negation does not overflow"""
4198  if z3_debug():
4199  _z3_assert(is_bv(a), "Argument should be a bit-vector")
4200  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4201 

◆ BVSubNoOverflow()

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

Definition at line 4177 of file z3py.py.

4177 def BVSubNoOverflow(a, b):
4178  """A predicate the determines that bit-vector subtraction does not overflow"""
4179  _check_bv_args(a, b)
4180  a, b = _coerce_exprs(a, b)
4181  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4182 
4183 

◆ BVSubNoUnderflow()

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

Definition at line 4184 of file z3py.py.

4184 def BVSubNoUnderflow(a, b, signed):
4185  """A predicate the determines that bit-vector subtraction does not underflow"""
4186  _check_bv_args(a, b)
4187  a, b = _coerce_exprs(a, b)
4188  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4189 

◆ Cbrt()

def z3py.Cbrt (   a,
  ctx = None 
)
Return a Z3 expression which represents the cubic root of a.

>>> x = Real('x')
>>> Cbrt(x)
x**(1/3)

Definition at line 3172 of file z3py.py.

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

◆ Complement()

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

Definition at line 10386 of file z3py.py.

10386 def Complement(re):
10387  """Create the complement regular expression."""
10388  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10389 

◆ Concat()

def z3py.Concat ( args)
Create a Z3 bit-vector concatenation expression.

>>> v = BitVecVal(1, 4)
>>> Concat(v, v+1, v)
Concat(Concat(1, 1 + 1), 1)
>>> simplify(Concat(v, v+1, v))
289
>>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
121

Definition at line 3813 of file z3py.py.

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

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

8166 def Cond(p, t1, t2, ctx=None):
8167  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8168 
8169  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8170  """
8171  p = _to_probe(p, ctx)
8172  t1 = _to_tactic(t1, ctx)
8173  t2 = _to_tactic(t2, ctx)
8174  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8175 

Referenced by If().

◆ Const()

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

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

Definition at line 1301 of file z3py.py.

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

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

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

◆ Contains()

def z3py.Contains (   a,
  b 
)
Check if 'a' contains 'b'
>>> s1 = Contains("abc", "ab")
>>> simplify(s1)
True
>>> s2 = Contains("abc", "bc")
>>> simplify(s2)
True
>>> x, y, z = Strings('x y z')
>>> s3 = Contains(Concat(x,y,z), y)
>>> simplify(s3)
True

Definition at line 10180 of file z3py.py.

10180 def Contains(a, b):
10181  """Check if 'a' contains 'b'
10182  >>> s1 = Contains("abc", "ab")
10183  >>> simplify(s1)
10184  True
10185  >>> s2 = Contains("abc", "bc")
10186  >>> simplify(s2)
10187  True
10188  >>> x, y, z = Strings('x y z')
10189  >>> s3 = Contains(Concat(x,y,z), y)
10190  >>> simplify(s3)
10191  True
10192  """
10193  ctx = _get_ctx2(a, b)
10194  a = _coerce_seq(a, ctx)
10195  b = _coerce_seq(b, ctx)
10196  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10197 
10198 

◆ CreateDatatypes()

def z3py.CreateDatatypes ( ds)
Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.

In the following example we define a Tree-List using two mutually recursive datatypes.

>>> TreeList = Datatype('TreeList')
>>> Tree     = Datatype('Tree')
>>> # Tree has two constructors: leaf and node
>>> Tree.declare('leaf', ('val', IntSort()))
>>> # a node contains a list of trees
>>> Tree.declare('node', ('children', TreeList))
>>> TreeList.declare('nil')
>>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
>>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
>>> Tree.val(Tree.leaf(10))
val(leaf(10))
>>> simplify(Tree.val(Tree.leaf(10)))
10
>>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
>>> n1
node(cons(leaf(10), cons(leaf(20), nil)))
>>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
>>> simplify(n2 == n1)
False
>>> simplify(TreeList.car(Tree.children(n2)) == n1)
True

Definition at line 4782 of file z3py.py.

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

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

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

◆ describe_probes()

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

Definition at line 8096 of file z3py.py.

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

◆ describe_tactics()

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

Definition at line 7905 of file z3py.py.

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

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

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

◆ Distinct()

def z3py.Distinct ( args)
Create a Z3 distinct expression.

>>> x = Int('x')
>>> y = Int('y')
>>> Distinct(x, y)
x != y
>>> z = Int('z')
>>> Distinct(x, y, z)
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z))
Distinct(x, y, z)
>>> simplify(Distinct(x, y, z), blast_distinct=True)
And(Not(x == y), Not(x == z), Not(y == z))

Definition at line 1270 of file z3py.py.

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

◆ Empty()

def z3py.Empty (   s)
Create the empty sequence of the given sort
>>> e = Empty(StringSort())
>>> e2 = StringVal("")
>>> print(e.eq(e2))
True
>>> e3 = Empty(SeqSort(IntSort()))
>>> print(e3)
Empty(Seq(Int))
>>> e4 = Empty(ReSort(SeqSort(IntSort())))
>>> print(e4)
Empty(ReSort(Seq(Int)))

Definition at line 10115 of file z3py.py.

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

◆ EmptySet()

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

Definition at line 4572 of file z3py.py.

4572 def EmptySet(s):
4573  """Create the empty set
4574  >>> EmptySet(IntSort())
4575  K(Int, False)
4576  """
4577  ctx = s.ctx
4578  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4579 

◆ 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 

◆ EnumSort()

def z3py.EnumSort (   name,
  values,
  ctx = None 
)
Return a new enumeration sort named `name` containing the given values.

The result is a pair (sort, list of constants).
Example:
    >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])

Definition at line 4994 of file z3py.py.

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

Referenced by Context.mkEnumSort().

◆ eq()

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

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

Definition at line 432 of file z3py.py.

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

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

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

4522 def Ext(a, b):
4523  """Return extensionality index for one-dimensional arrays.
4524  >> a, b = Consts('a b', SetSort(IntSort()))
4525  >> Ext(a, b)
4526  Ext(a, b)
4527  """
4528  ctx = a.ctx
4529  if z3_debug():
4530  _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4531  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4532 

◆ Extract()

def z3py.Extract (   high,
  low,
  a 
)
Create a Z3 bit-vector extraction expression, or create a string extraction expression.

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

Definition at line 3858 of file z3py.py.

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

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

8129 def FailIf(p, ctx=None):
8130  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8131 
8132  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8133 
8134  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8135  >>> x, y = Ints('x y')
8136  >>> g = Goal()
8137  >>> g.add(x > 0)
8138  >>> g.add(y > 0)
8139  >>> t(g)
8140  [[x > 0, y > 0]]
8141  >>> g.add(x == y + 1)
8142  >>> t(g)
8143  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8144  """
8145  p = _to_probe(p, ctx)
8146  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8147 

◆ FiniteDomainSort()

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

Definition at line 7221 of file z3py.py.

7221 def FiniteDomainSort(name, sz, ctx=None):
7222  """Create a named finite domain sort of a given size sz"""
7223  if not isinstance(name, Symbol):
7224  name = to_symbol(name)
7225  ctx = _get_ctx(ctx)
7226  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7227 

Referenced by Context.mkFiniteDomainSort().

◆ FiniteDomainVal()

def z3py.FiniteDomainVal (   val,
  sort,
  ctx = None 
)
Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.

>>> s = FiniteDomainSort('S', 256)
>>> FiniteDomainVal(255, s)
255
>>> FiniteDomainVal('100', s)
100

Definition at line 7289 of file z3py.py.

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

◆ Float128()

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

Definition at line 8759 of file z3py.py.

8759 def Float128(ctx=None):
8760  """Floating-point 128-bit (quadruple) sort."""
8761  ctx = _get_ctx(ctx)
8762  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8763 

◆ Float16()

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

Definition at line 8729 of file z3py.py.

8729 def Float16(ctx=None):
8730  """Floating-point 16-bit (half) sort."""
8731  ctx = _get_ctx(ctx)
8732  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8733 

◆ Float32()

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

Definition at line 8739 of file z3py.py.

8739 def Float32(ctx=None):
8740  """Floating-point 32-bit (single) sort."""
8741  ctx = _get_ctx(ctx)
8742  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8743 

◆ Float64()

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

Definition at line 8749 of file z3py.py.

8749 def Float64(ctx=None):
8750  """Floating-point 64-bit (double) sort."""
8751  ctx = _get_ctx(ctx)
8752  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8753 

◆ FloatDouble()

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

Definition at line 8754 of file z3py.py.

8754 def FloatDouble(ctx=None):
8755  """Floating-point 64-bit (double) sort."""
8756  ctx = _get_ctx(ctx)
8757  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8758 

◆ FloatHalf()

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

Definition at line 8734 of file z3py.py.

8734 def FloatHalf(ctx=None):
8735  """Floating-point 16-bit (half) sort."""
8736  ctx = _get_ctx(ctx)
8737  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8738 

◆ FloatQuadruple()

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

Definition at line 8764 of file z3py.py.

8764 def FloatQuadruple(ctx=None):
8765  """Floating-point 128-bit (quadruple) sort."""
8766  ctx = _get_ctx(ctx)
8767  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8768 

◆ FloatSingle()

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

Definition at line 8744 of file z3py.py.

8744 def FloatSingle(ctx=None):
8745  """Floating-point 32-bit (single) sort."""
8746  ctx = _get_ctx(ctx)
8747  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8748 

◆ ForAll()

def z3py.ForAll (   vs,
  body,
  weight = 1,
  qid = "",
  skid = "",
  patterns = [],
  no_patterns = [] 
)
Create a Z3 forall formula.

The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> x = Int('x')
>>> y = Int('y')
>>> ForAll([x, y], f(x, y) >= x)
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
ForAll([x, y], f(x, y) >= x)
>>> ForAll([x, y], f(x, y) >= x, weight=10)
ForAll([x, y], f(x, y) >= x)

Definition at line 2044 of file z3py.py.

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

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

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

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

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

◆ fpAdd()

def z3py.fpAdd (   rm,
  a,
  b,
  ctx = None 
)
Create a Z3 floating-point addition expression.

>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpAdd(rm, x, y)
fpAdd(RNE(), x, y)
>>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
x + y
>>> fpAdd(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9467 of file z3py.py.

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

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

9763 def fpBVToFP(v, sort, ctx=None):
9764  """Create a Z3 floating-point conversion expression that represents the
9765  conversion from a bit-vector term to a floating-point term.
9766 
9767  >>> x_bv = BitVecVal(0x3F800000, 32)
9768  >>> x_fp = fpBVToFP(x_bv, Float32())
9769  >>> x_fp
9770  fpToFP(1065353216)
9771  >>> simplify(x_fp)
9772  1
9773  """
9774  _z3_assert(is_bv(v), "First argument must be a Z3 floating-point rounding mode expression.")
9775  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9776  ctx = _get_ctx(ctx)
9777  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9778 

◆ fpDiv()

def z3py.fpDiv (   rm,
  a,
  b,
  ctx = None 
)
Create a Z3 floating-point division expression.

>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpDiv(rm, x, y)
fpDiv(RNE(), x, y)
>>> fpDiv(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9511 of file z3py.py.

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

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

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

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

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

◆ fpFP()

def z3py.fpFP (   sgn,
  exp,
  sig,
  ctx = None 
)
Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.

>>> s = FPSort(8, 24)
>>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
>>> print(x)
fpFP(1, 127, 4194304)
>>> xv = FPVal(-1.5, s)
>>> print(xv)
-1.5
>>> slvr = Solver()
>>> slvr.add(fpEQ(x, xv))
>>> slvr.check()
sat
>>> xv = FPVal(+1.5, s)
>>> print(xv)
1.5
>>> slvr = Solver()
>>> slvr.add(fpEQ(x, xv))
>>> slvr.check()
unsat

Definition at line 9697 of file z3py.py.

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

◆ fpFPToFP()

def z3py.fpFPToFP (   rm,
  v,
  sort,
  ctx = None 
)
Create a Z3 floating-point conversion expression that represents the
conversion from a floating-point term to a floating-point term of different precision.

>>> x_sgl = FPVal(1.0, Float32())
>>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
>>> x_dbl
fpToFP(RNE(), 1)
>>> simplify(x_dbl)
1
>>> x_dbl.sort()
FPSort(11, 53)

Definition at line 9779 of file z3py.py.

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

◆ fpGEQ()

def z3py.fpGEQ (   a,
  b,
  ctx = None 
)
Create the Z3 floating-point expression `other >= self`.

>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpGEQ(x, y)
x >= y
>>> (x >= y).sexpr()
'(fp.geq x y)'

Definition at line 9664 of file z3py.py.

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

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

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

Referenced by FPRef.__gt__().

◆ fpInfinity()

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

Definition at line 9278 of file z3py.py.

9278 def fpInfinity(s, negative):
9279  """Create a Z3 floating-point +oo or -oo term."""
9280  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9281  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9282  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9283 

◆ fpIsInf()

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

>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> fpIsInf(x)
fpIsInf(x)

Definition at line 9592 of file z3py.py.

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

◆ fpIsNaN()

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

>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpIsNaN(x)
fpIsNaN(x)

Definition at line 9581 of file z3py.py.

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

◆ fpIsNegative()

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

Definition at line 9617 of file z3py.py.

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

◆ fpIsNormal()

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

Definition at line 9607 of file z3py.py.

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

◆ fpIsPositive()

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

Definition at line 9622 of file z3py.py.

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

◆ fpIsSubnormal()

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

Definition at line 9612 of file z3py.py.

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

◆ fpIsZero()

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

Definition at line 9602 of file z3py.py.

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

◆ fpLEQ()

def z3py.fpLEQ (   a,
  b,
  ctx = None 
)
Create the Z3 floating-point expression `other <= self`.

>>> x, y = FPs('x y', FPSort(8, 24))
>>> fpLEQ(x, y)
x <= y
>>> (x <= y).sexpr()
'(fp.leq x y)'

Definition at line 9642 of file z3py.py.

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

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

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

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

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

◆ fpMin()

def z3py.fpMin (   a,
  b,
  ctx = None 
)
Create a Z3 floating-point minimum expression.

>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpMin(x, y)
fpMin(x, y)
>>> fpMin(x, y).sort()
FPSort(8, 24)

Definition at line 9538 of file z3py.py.

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

◆ fpMinusInfinity()

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

Definition at line 9273 of file z3py.py.

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

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 9289 of file z3py.py.

9289 def fpMinusZero(s):
9290  """Create a Z3 floating-point -0.0 term."""
9291  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9292  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9293 

Referenced by FPVal().

◆ fpMul()

def z3py.fpMul (   rm,
  a,
  b,
  ctx = None 
)
Create a Z3 floating-point multiplication expression.

>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpMul(rm, x, y)
fpMul(RNE(), x, y)
>>> fpMul(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9497 of file z3py.py.

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

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

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

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

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

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

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

◆ fpPlusInfinity()

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

>>> s = FPSort(8, 24)
>>> pb = get_fpa_pretty()
>>> set_fpa_pretty(True)
>>> fpPlusInfinity(s)
+oo
>>> set_fpa_pretty(False)
>>> fpPlusInfinity(s)
fpPlusInfinity(FPSort(8, 24))
>>> set_fpa_pretty(pb)

Definition at line 9257 of file z3py.py.

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

Referenced by FPVal().

◆ fpPlusZero()

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

Definition at line 9284 of file z3py.py.

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

Referenced by FPVal().

◆ fpRealToFP()

def z3py.fpRealToFP (   rm,
  v,
  sort,
  ctx = None 
)
Create a Z3 floating-point conversion expression that represents the
conversion from a real term to a floating-point term.

>>> x_r = RealVal(1.5)
>>> x_fp = fpRealToFP(RNE(), x_r, Float32())
>>> x_fp
fpToFP(RNE(), 3/2)
>>> simplify(x_fp)
1.5

Definition at line 9798 of file z3py.py.

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

◆ fpRem()

def z3py.fpRem (   a,
  b,
  ctx = None 
)
Create a Z3 floating-point remainder expression.

>>> s = FPSort(8, 24)
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpRem(x, y)
fpRem(x, y)
>>> fpRem(x, y).sort()
FPSort(8, 24)

Definition at line 9525 of file z3py.py.

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

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

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

◆ FPs()

def z3py.FPs (   names,
  fpsort,
  ctx = None 
)
Return an array of floating-point constants.

>>> x, y, z = FPs('x y z', FPSort(8, 24))
>>> x.sort()
FPSort(8, 24)
>>> x.sbits()
24
>>> x.ebits()
8
>>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
fpMul(RNE(), fpAdd(RNE(), x, y), z)

Definition at line 9367 of file z3py.py.

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

◆ fpSignedToFP()

def z3py.fpSignedToFP (   rm,
  v,
  sort,
  ctx = None 
)
Create a Z3 floating-point conversion expression that represents the
conversion from a signed bit-vector term (encoding an integer) to a floating-point term.

>>> x_signed = BitVecVal(-5, BitVecSort(32))
>>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
>>> x_fp
fpToFP(RNE(), 4294967291)
>>> simplify(x_fp)
-1.25*(2**2)

Definition at line 9815 of file z3py.py.

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

◆ FPSort()

def z3py.FPSort (   ebits,
  sbits,
  ctx = None 
)
Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.

>>> Single = FPSort(8, 24)
>>> Double = FPSort(11, 53)
>>> Single
FPSort(8, 24)
>>> x = Const('x', Single)
>>> eq(x, FP('x', FPSort(8, 24)))
True

Definition at line 9183 of file z3py.py.

9183 def FPSort(ebits, sbits, ctx=None):
9184  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9185 
9186  >>> Single = FPSort(8, 24)
9187  >>> Double = FPSort(11, 53)
9188  >>> Single
9189  FPSort(8, 24)
9190  >>> x = Const('x', Single)
9191  >>> eq(x, FP('x', FPSort(8, 24)))
9192  True
9193  """
9194  ctx = _get_ctx(ctx)
9195  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9196 

Referenced by get_default_fp_sort(), Context.mkFPSort(), Context.mkFPSort128(), Context.mkFPSort16(), Context.mkFPSort32(), Context.mkFPSort64(), Context.mkFPSortDouble(), Context.mkFPSortHalf(), Context.mkFPSortQuadruple(), and Context.mkFPSortSingle().

◆ fpSqrt()

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

Definition at line 9571 of file z3py.py.

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

◆ fpSub()

def z3py.fpSub (   rm,
  a,
  b,
  ctx = None 
)
Create a Z3 floating-point subtraction expression.

>>> s = FPSort(8, 24)
>>> rm = RNE()
>>> x = FP('x', s)
>>> y = FP('y', s)
>>> fpSub(rm, x, y)
fpSub(RNE(), x, y)
>>> fpSub(rm, x, y).sort()
FPSort(8, 24)

Definition at line 9483 of file z3py.py.

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

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

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

◆ fpToFPUnsigned()

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

Definition at line 9849 of file z3py.py.

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

◆ fpToIEEEBV()

def z3py.fpToIEEEBV (   x,
  ctx = None 
)
\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.

The size of the resulting bit-vector is automatically determined.

Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
knows only one NaN and it will always produce the same bit-vector representation of
that NaN.

>>> x = FP('x', FPSort(8, 24))
>>> y = fpToIEEEBV(x)
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False

Definition at line 9919 of file z3py.py.

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

◆ fpToReal()

def z3py.fpToReal (   x,
  ctx = None 
)
Create a Z3 floating-point conversion expression, from floating-point expression to real.

>>> x = FP('x', FPSort(8, 24))
>>> y = fpToReal(x)
>>> print(is_fp(x))
True
>>> print(is_real(y))
True
>>> print(is_fp(y))
False
>>> print(is_real(x))
False

Definition at line 9900 of file z3py.py.

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

◆ fpToSBV()

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

>>> x = FP('x', FPSort(8, 24))
>>> y = fpToSBV(RTZ(), x, BitVecSort(32))
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False

Definition at line 9858 of file z3py.py.

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

◆ fpToUBV()

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

>>> x = FP('x', FPSort(8, 24))
>>> y = fpToUBV(RTZ(), x, BitVecSort(32))
>>> print(is_fp(x))
True
>>> print(is_bv(y))
True
>>> print(is_fp(y))
False
>>> print(is_bv(x))
False

Definition at line 9879 of file z3py.py.

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

◆ fpUnsignedToFP()

def z3py.fpUnsignedToFP (   rm,
  v,
  sort,
  ctx = None 
)
Create a Z3 floating-point conversion expression that represents the
conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.

>>> x_signed = BitVecVal(-5, BitVecSort(32))
>>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
>>> x_fp
fpToFPUnsigned(RNE(), 4294967291)
>>> simplify(x_fp)
1*(2**32)

Definition at line 9832 of file z3py.py.

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

◆ FPVal()

def z3py.FPVal (   sig,
  exp = None,
  fps = None,
  ctx = None 
)
Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.

>>> v = FPVal(20.0, FPSort(8, 24))
>>> v
1.25*(2**4)
>>> print("0x%.8x" % v.exponent_as_long(False))
0x00000004
>>> v = FPVal(2.25, FPSort(8, 24))
>>> v
1.125*(2**1)
>>> v = FPVal(-2.25, FPSort(8, 24))
>>> v
-1.125*(2**1)
>>> FPVal(-0.0, FPSort(8, 24))
-0.0
>>> FPVal(0.0, FPSort(8, 24))
+0.0
>>> FPVal(+0.0, FPSort(8, 24))
+0.0

Definition at line 9300 of file z3py.py.

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

Referenced by set_default_fp_sort().

◆ fpZero()

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

Definition at line 9294 of file z3py.py.

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

◆ FreshBool()

def z3py.FreshBool (   prefix = 'b',
  ctx = None 
)
Return a fresh Boolean constant in the given context using the given prefix.

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

>>> b1 = FreshBool()
>>> b2 = FreshBool()
>>> eq(b1, b2)
False

Definition at line 1608 of file z3py.py.

1608 def FreshBool(prefix='b', ctx=None):
1609  """Return a fresh Boolean constant in the given context using the given prefix.
1610 
1611  If `ctx=None`, then the global context is used.
1612 
1613  >>> b1 = FreshBool()
1614  >>> b2 = FreshBool()
1615  >>> eq(b1, b2)
1616  False
1617  """
1618  ctx = _get_ctx(ctx)
1619  return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1620 

◆ FreshConst()

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

Definition at line 1326 of file z3py.py.

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

◆ FreshInt()

def z3py.FreshInt (   prefix = 'x',
  ctx = None 
)
Return a fresh integer constant in the given context using the given prefix.

>>> x = FreshInt()
>>> y = FreshInt()
>>> eq(x, y)
False
>>> x.sort()
Int

Definition at line 3045 of file z3py.py.

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

◆ FreshReal()

def z3py.FreshReal (   prefix = 'b',
  ctx = None 
)
Return a fresh real constant in the given context using the given prefix.

>>> x = FreshReal()
>>> y = FreshReal()
>>> eq(x, y)
False
>>> x.sort()
Real

Definition at line 3097 of file z3py.py.

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

◆ Full()

def z3py.Full (   s)
Create the regular expression that accepts the universal language
>>> e = Full(ReSort(SeqSort(IntSort())))
>>> print(e)
Full(ReSort(Seq(Int)))
>>> e1 = Full(ReSort(StringSort()))
>>> print(e1)
Full(ReSort(String))

Definition at line 10134 of file z3py.py.

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

◆ FullSet()

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

Definition at line 4580 of file z3py.py.

4580 def FullSet(s):
4581  """Create the full set
4582  >>> FullSet(IntSort())
4583  K(Int, True)
4584  """
4585  ctx = s.ctx
4586  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4587 

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

6244 def get_as_array_func(n):
6245  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6246  if z3_debug():
6247  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6248  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6249 

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

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

Referenced by set_default_fp_sort().

◆ get_default_rounding_mode()

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

Definition at line 8626 of file z3py.py.

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

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

4354 def get_map_func(a):
4355  """Return the function declaration associated with a Z3 map array expression.
4356 
4357  >>> f = Function('f', IntSort(), IntSort())
4358  >>> b = Array('b', IntSort(), IntSort())
4359  >>> a = Map(f, b)
4360  >>> eq(f, get_map_func(a))
4361  True
4362  >>> get_map_func(a)
4363  f
4364  >>> get_map_func(a)(0)
4365  f(0)
4366  """
4367  if z3_debug():
4368  _z3_assert(is_map(a), "Z3 array map expression expected.")
4369  return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4370 

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

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

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

8206 def help_simplify():
8207  """Return a string describing all options available for Z3 `simplify` procedure."""
8208  print(Z3_simplify_get_help(main_ctx().ref()))
8209 

◆ If()

def z3py.If (   a,
  b,
  c,
  ctx = None 
)
Create a Z3 if-then-else expression.

>>> x = Int('x')
>>> y = Int('y')
>>> max = If(x > y, x, y)
>>> max
If(x > y, x, y)
>>> simplify(max)
If(x <= y, y, x)

Definition at line 1248 of file z3py.py.

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

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

1621 def Implies(a, b, ctx=None):
1622  """Create a Z3 implies expression.
1623 
1624  >>> p, q = Bools('p q')
1625  >>> Implies(p, q)
1626  Implies(p, q)
1627  """
1628  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1629  s = BoolSort(ctx)
1630  a = s.cast(a)
1631  b = s.cast(b)
1632  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1633 

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

◆ IndexOf() [1/2]

def z3py.IndexOf (   s,
  substr 
)

Definition at line 10213 of file z3py.py.

10213 def IndexOf(s, substr):
10214  return IndexOf(s, substr, IntVal(0))
10215 

Referenced by IndexOf().

◆ IndexOf() [2/2]

def z3py.IndexOf (   s,
  substr,
  offset 
)
Retrieve the index of substring within a string starting at a specified offset.
>>> simplify(IndexOf("abcabc", "bc", 0))
1
>>> simplify(IndexOf("abcabc", "bc", 2))
4

Definition at line 10216 of file z3py.py.

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

◆ InRe()

def z3py.InRe (   s,
  re 
)
Create regular expression membership test
>>> re = Union(Re("a"),Re("b"))
>>> print (simplify(InRe("a", re)))
True
>>> print (simplify(InRe("b", re)))
True
>>> print (simplify(InRe("c", re)))
False

Definition at line 10313 of file z3py.py.

10313 def InRe(s, re):
10314  """Create regular expression membership test
10315  >>> re = Union(Re("a"),Re("b"))
10316  >>> print (simplify(InRe("a", re)))
10317  True
10318  >>> print (simplify(InRe("b", re)))
10319  True
10320  >>> print (simplify(InRe("c", re)))
10321  False
10322  """
10323  s = _coerce_seq(s, re.ctx)
10324  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10325 

◆ Int()

def z3py.Int (   name,
  ctx = None 
)
Return an integer constant named `name`. If `ctx=None`, then the global context is used.

>>> x = Int('x')
>>> is_int(x)
True
>>> is_int(x + 1)
True

Definition at line 3010 of file z3py.py.

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

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

3732 def Int2BV(a, num_bits):
3733  """Return the z3 expression Int2BV(a, num_bits).
3734  It is a bit-vector of width num_bits and represents the
3735  modulo of a by 2^num_bits
3736  """
3737  ctx = a.ctx
3738  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3739 

◆ Intersect()

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

Definition at line 10345 of file z3py.py.

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

◆ Ints()

def z3py.Ints (   names,
  ctx = None 
)
Return a tuple of Integer constants.

>>> x, y, z = Ints('x y z')
>>> Sum(x, y, z)
x + y + z

Definition at line 3022 of file z3py.py.

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

◆ IntSort()

def z3py.IntSort (   ctx = None)
Return the integer sort in the given context. If `ctx=None`, then the global context is used.

>>> IntSort()
Int
>>> x = Const('x', IntSort())
>>> is_int(x)
True
>>> x.sort() == IntSort()
True
>>> x.sort() == BoolSort()
False

Definition at line 2907 of file z3py.py.

2907 def IntSort(ctx=None):
2908  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2909 
2910  >>> IntSort()
2911  Int
2912  >>> x = Const('x', IntSort())
2913  >>> is_int(x)
2914  True
2915  >>> x.sort() == IntSort()
2916  True
2917  >>> x.sort() == BoolSort()
2918  False
2919  """
2920  ctx = _get_ctx(ctx)
2921  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2922 

Referenced by FreshInt(), Context.getIntSort(), Int(), IntVal(), and Context.mkIntSort().

◆ IntToStr()

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

Definition at line 10267 of file z3py.py.

10267 def IntToStr(s):
10268  """Convert integer expression to string"""
10269  if not is_expr(s):
10270  s = _py2expr(s)
10271  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10272 
10273 

◆ IntVal()

def z3py.IntVal (   val,
  ctx = None 
)
Return a Z3 integer value. If `ctx=None`, then the global context is used.

>>> IntVal(1)
1
>>> IntVal("100")
100

Definition at line 2954 of file z3py.py.

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

Referenced by SeqRef.__getitem__(), AlgebraicNumRef.as_decimal(), SeqRef.at(), 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 3034 of file z3py.py.

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

◆ is_add()

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

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

Definition at line 2596 of file z3py.py.

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

◆ is_algebraic_value()

def z3py.is_algebraic_value (   a)
Return `True` if `a` is an algebraic value of sort Real.

>>> is_algebraic_value(RealVal("3/5"))
False
>>> n = simplify(Sqrt(2))
>>> n
1.4142135623?
>>> is_algebraic_value(n)
True

Definition at line 2583 of file z3py.py.

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

◆ is_and()

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

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

Definition at line 1469 of file z3py.py.

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

◆ is_app()

def z3py.is_app (   a)
Return `True` if `a` is a Z3 function application.

Note that, constants are function applications with 0 arguments.

>>> a = Int('a')
>>> is_app(a)
True
>>> is_app(a + 1)
True
>>> is_app(IntSort())
False
>>> is_app(1)
False
>>> is_app(IntVal(1))
True
>>> x = Int('x')
>>> is_app(ForAll(x, x >= 0))
False

Definition at line 1137 of file z3py.py.

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

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

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

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

◆ is_arith()

def z3py.is_arith (   a)
Return `True` if `a` is an arithmetical expression.

>>> x = Int('x')
>>> is_arith(x)
True
>>> is_arith(x + 1)
True
>>> is_arith(1)
False
>>> is_arith(IntVal(1))
True
>>> y = Real('y')
>>> is_arith(y)
True
>>> is_arith(y + 1)
True

Definition at line 2477 of file z3py.py.

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

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

◆ is_arith_sort()

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

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

Definition at line 2178 of file z3py.py.

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

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

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

Referenced by Ext(), and Map().

◆ is_array_sort()

def z3py.is_array_sort (   a)

Definition at line 4290 of file z3py.py.

4290 def is_array_sort(a):
4291  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4292 
4293 

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

◆ is_as_array()

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

Definition at line 6240 of file z3py.py.

6240 def is_as_array(n):
6241  """Return true if n is a Z3 expression of the form (_ as-array f)."""
6242  return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6243 

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 AstRef.eq(), 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 1422 of file z3py.py.

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

Referenced by is_quantifier(), and prove().

◆ is_bv()

def z3py.is_bv (   a)
Return `True` if `a` is a Z3 bit-vector expression.

>>> b = BitVec('b', 32)
>>> is_bv(b)
True
>>> is_bv(b + 10)
True
>>> is_bv(Int('x'))
False

Definition at line 3683 of file z3py.py.

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

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

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

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

◆ is_bv_value()

def z3py.is_bv_value (   a)
Return `True` if `a` is a Z3 bit-vector numeral value.

>>> b = BitVec('b', 32)
>>> is_bv_value(b)
False
>>> b = BitVecVal(10, 32)
>>> b
10
>>> is_bv_value(b)
True

Definition at line 3696 of file z3py.py.

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

◆ is_const()

def z3py.is_const (   a)
Return `True` if `a` is Z3 constant/variable expression.

>>> a = Int('a')
>>> is_const(a)
True
>>> is_const(a + 1)
False
>>> is_const(1)
False
>>> is_const(IntVal(1))
True
>>> x = Int('x')
>>> is_const(ForAll(x, x >= 0))
False

Definition at line 1162 of file z3py.py.

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

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

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

◆ is_default()

def z3py.is_default (   a)
Return `True` if `a` is a Z3 default array expression.
>>> d = Default(K(IntSort(), 10))
>>> is_default(d)
True

Definition at line 4346 of file z3py.py.

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

◆ is_distinct()

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

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

Definition at line 1522 of file z3py.py.

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

◆ is_div()

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

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

Definition at line 2629 of file z3py.py.

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

◆ is_eq()

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

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

Definition at line 1513 of file z3py.py.

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

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

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

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

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

Referenced by AstRef.__bool__().

◆ is_finite_domain()

def z3py.is_finite_domain (   a)
Return `True` if `a` is a Z3 finite-domain expression.

>>> s = FiniteDomainSort('S', 100)
>>> b = Const('b', s)
>>> is_finite_domain(b)
True
>>> is_finite_domain(Int('x'))
False

Definition at line 7250 of file z3py.py.

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

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

7228 def is_finite_domain_sort(s):
7229  """Return True if `s` is a Z3 finite-domain sort.
7230 
7231  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7232  True
7233  >>> is_finite_domain_sort(IntSort())
7234  False
7235  """
7236  return isinstance(s, FiniteDomainSortRef)
7237 
7238 

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

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

◆ is_fp()

def z3py.is_fp (   a)
Return `True` if `a` is a Z3 floating-point expression.

>>> b = FP('b', FPSort(8, 24))
>>> is_fp(b)
True
>>> is_fp(b + 1.0)
True
>>> is_fp(Int('x'))
False

Definition at line 9156 of file z3py.py.

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

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

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

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

◆ is_fp_value()

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

>>> b = FP('b', FPSort(8, 24))
>>> is_fp_value(b)
False
>>> b = FPVal(1.0, FPSort(8, 24))
>>> b
1
>>> is_fp_value(b)
True

Definition at line 9169 of file z3py.py.

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

◆ is_fprm()

def z3py.is_fprm (   a)
Return `True` if `a` is a Z3 floating-point rounding mode expression.

>>> rm = RNE()
>>> is_fprm(rm)
True
>>> rm = 1.0
>>> is_fprm(rm)
False

Definition at line 9020 of file z3py.py.

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

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

◆ is_fprm_sort()

def z3py.is_fprm_sort (   s)
Return True if `s` is a Z3 floating-point rounding mode sort.

>>> is_fprm_sort(FPSort(8, 24))
False
>>> is_fprm_sort(RNE().sort())
True

Definition at line 8783 of file z3py.py.

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

◆ is_fprm_value()

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

Definition at line 9032 of file z3py.py.

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

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

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

◆ is_gt()

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

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

Definition at line 2700 of file z3py.py.

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

◆ is_idiv()

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

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

Definition at line 2645 of file z3py.py.

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

◆ is_implies()

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

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

Definition at line 1491 of file z3py.py.

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

◆ is_int()

def z3py.is_int (   a)
Return `True` if `a` is an integer expression.

>>> x = Int('x')
>>> is_int(x + 1)
True
>>> is_int(1)
False
>>> is_int(IntVal(1))
True
>>> y = Real('y')
>>> is_int(y)
False
>>> is_int(y + 1)
False

Definition at line 2497 of file z3py.py.

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

◆ is_int_value()

def z3py.is_int_value (   a)
Return `True` if `a` is an integer value of sort Int.

>>> is_int_value(IntVal(1))
True
>>> is_int_value(1)
False
>>> is_int_value(Int('x'))
False
>>> n = Int('x') + 1
>>> n
x + 1
>>> n.arg(1)
1
>>> is_int_value(n.arg(1))
True
>>> is_int_value(RealVal("1/3"))
False
>>> is_int_value(RealVal(1))
False

Definition at line 2539 of file z3py.py.

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

◆ is_is_int()

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

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

Definition at line 2711 of file z3py.py.

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

◆ is_K()

def z3py.is_K (   a)
Return `True` if `a` is a Z3 constant array.

>>> a = K(IntSort(), 10)
>>> is_K(a)
True
>>> a = Array('a', IntSort(), IntSort())
>>> is_K(a)
False

Definition at line 4319 of file z3py.py.

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

◆ is_le()

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

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

Definition at line 2667 of file z3py.py.

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

◆ is_lt()

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

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

Definition at line 2678 of file z3py.py.

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

◆ is_map()

def z3py.is_map (   a)
Return `True` if `a` is a Z3 map array expression.

>>> f = Function('f', IntSort(), IntSort())
>>> b = Array('b', IntSort(), IntSort())
>>> a  = Map(f, b)
>>> a
Map(f, b)
>>> is_map(a)
True
>>> is_map(b)
False

Definition at line 4331 of file z3py.py.

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

Referenced by get_map_func().

◆ is_mod()

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

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

Definition at line 2656 of file z3py.py.

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

◆ is_mul()

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

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

Definition at line 2607 of file z3py.py.

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

◆ is_not()

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

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

Definition at line 1502 of file z3py.py.

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

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

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

◆ is_pattern()

def z3py.is_pattern (   a)
Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.

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

Definition at line 1759 of file z3py.py.

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

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

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

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

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

◆ is_rational_value()

def z3py.is_rational_value (   a)
Return `True` if `a` is rational value of sort Real.

>>> is_rational_value(RealVal(1))
True
>>> is_rational_value(RealVal("3/5"))
True
>>> is_rational_value(IntVal(1))
False
>>> is_rational_value(1)
False
>>> n = Real('x') + 1
>>> n.arg(1)
1
>>> is_rational_value(n.arg(1))
True
>>> is_rational_value(Real('x'))
False

Definition at line 2562 of file z3py.py.

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

◆ is_re()

def z3py.is_re (   s)

Definition at line 10309 of file z3py.py.

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

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

◆ is_real()

def z3py.is_real (   a)
Return `True` if `a` is a real expression.

>>> x = Int('x')
>>> is_real(x + 1)
False
>>> y = Real('y')
>>> is_real(y)
True
>>> is_real(y + 1)
True
>>> is_real(1)
False
>>> is_real(RealVal(1))
True

Definition at line 2515 of file z3py.py.

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

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

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

◆ is_seq()

def z3py.is_seq (   a)
Return `True` if `a` is a Z3 sequence expression.
>>> print (is_seq(Unit(IntVal(0))))
True
>>> print (is_seq(StringVal("abc")))
True

Definition at line 10054 of file z3py.py.

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

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

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

◆ is_string()

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

Definition at line 10063 of file z3py.py.

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

◆ is_string_value()

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

Definition at line 10070 of file z3py.py.

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

◆ is_sub()

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

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

Definition at line 2618 of file z3py.py.

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

◆ is_to_int()

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

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

Definition at line 2736 of file z3py.py.

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

◆ is_to_real()

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

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

Definition at line 2722 of file z3py.py.

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

◆ is_true()

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

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

Definition at line 1439 of file z3py.py.

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

Referenced by AstRef.__bool__().

◆ is_var()

def z3py.is_var (   a)
Return `True` if `a` is variable.

Z3 uses de-Bruijn indices for representing bound variables in
quantifiers.

>>> x = Int('x')
>>> is_var(x)
False
>>> is_const(x)
True
>>> f = Function('f', IntSort(), IntSort())
>>> # Z3 replaces x with bound variables when ForAll is executed.
>>> q = ForAll(x, f(x) == x)
>>> b = q.body()
>>> b
f(Var(0)) == Var(0)
>>> b.arg(1)
Var(0)
>>> is_var(b.arg(1))
True

Definition at line 1180 of file z3py.py.

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

Referenced by get_var_index().

◆ IsInt()

def z3py.IsInt (   a)
Return the Z3 predicate IsInt(a).

>>> x = Real('x')
>>> IsInt(x + "1/2")
IsInt(x + 1/2)
>>> solve(IsInt(x + "1/2"), x > 0, x < 1)
[x = 1/2]
>>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
no solution

Definition at line 3144 of file z3py.py.

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

◆ IsMember()

def z3py.IsMember (   e,
  s 
)
Check if e is a member of set s
>>> a = Const('a', SetSort(IntSort()))
>>> IsMember(1, a)
a[1]

Definition at line 4651 of file z3py.py.

4651 def IsMember(e, s):
4652  """ Check if e is a member of set s
4653  >>> a = Const('a', SetSort(IntSort()))
4654  >>> IsMember(1, a)
4655  a[1]
4656  """
4657  ctx = _ctx_from_ast_arg_list([s,e])
4658  e = _py2expr(e, ctx)
4659  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4660 

◆ IsSubset()

def z3py.IsSubset (   a,
  b 
)
Check if a is a subset of b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> IsSubset(a, b)
subset(a, b)

Definition at line 4661 of file z3py.py.

4661 def IsSubset(a, b):
4662  """ Check if a is a subset of b
4663  >>> a = Const('a', SetSort(IntSort()))
4664  >>> b = Const('b', SetSort(IntSort()))
4665  >>> IsSubset(a, b)
4666  subset(a, b)
4667  """
4668  ctx = _ctx_from_ast_arg_list([a, b])
4669  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4670 
4671 

◆ K()

def z3py.K (   dom,
  v 
)
Return a Z3 constant array expression.

>>> a = K(IntSort(), 10)
>>> a
K(Int, 10)
>>> a.sort()
Array(Int, Int)
>>> i = Int('i')
>>> a[i]
K(Int, 10)[i]
>>> simplify(a[i])
10

Definition at line 4501 of file z3py.py.

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

◆ Lambda()

def z3py.Lambda (   vs,
  body 
)
Create a Z3 lambda expression.

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> mem0 = Array('mem0', IntSort(), IntSort())
>>> lo, hi, e, i = Ints('lo hi e i')
>>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
>>> mem1
Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))

Definition at line 2081 of file z3py.py.

2081 def Lambda(vs, body):
2082  """Create a Z3 lambda expression.
2083 
2084  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2085  >>> mem0 = Array('mem0', IntSort(), IntSort())
2086  >>> lo, hi, e, i = Ints('lo hi e i')
2087  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2088  >>> mem1
2089  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2090  """
2091  ctx = body.ctx
2092  if is_app(vs):
2093  vs = [vs]
2094  num_vars = len(vs)
2095  _vs = (Ast * num_vars)()
2096  for i in range(num_vars):
2097 
2098  _vs[i] = vs[i].as_ast()
2099  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2100 

◆ LastIndexOf()

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

Definition at line 10233 of file z3py.py.

10233 def LastIndexOf(s, substr):
10234  """Retrieve the last index of substring within a string"""
10235  ctx = None
10236  ctx = _get_ctx2(s, substr, ctx)
10237  s = _coerce_seq(s, ctx)
10238  substr = _coerce_seq(substr, ctx)
10239  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10240 
10241 

◆ Length()

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

Definition at line 10242 of file z3py.py.

10242 def Length(s):
10243  """Obtain the length of a sequence 's'
10244  >>> l = Length(StringVal("abc"))
10245  >>> simplify(l)
10246  3
10247  """
10248  s = _coerce_seq(s)
10249  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10250 

◆ LinearOrder()

def z3py.LinearOrder (   a,
  index 
)

Definition at line 10431 of file z3py.py.

10431 def LinearOrder(a, index):
10432  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10433 

◆ Loop()

def z3py.Loop (   re,
  lo,
  hi = 0 
)
Create the regular expression accepting between a lower and upper bound repetitions
>>> re = Loop(Re("a"), 1, 3)
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("aaaa", re)))
False
>>> print(simplify(InRe("", re)))
False

Definition at line 10402 of file z3py.py.

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

◆ LShR()

def z3py.LShR (   a,
  b 
)
Create the Z3 expression logical right shift.

Use the operator >> for the arithmetical right shift.

>>> x, y = BitVecs('x y', 32)
>>> LShR(x, y)
LShR(x, y)
>>> (x >> y).sexpr()
'(bvashr x y)'
>>> LShR(x, y).sexpr()
'(bvlshr x y)'
>>> BitVecVal(4, 3)
4
>>> BitVecVal(4, 3).as_signed_long()
-4
>>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
-2
>>> simplify(BitVecVal(4, 3) >> 1)
6
>>> simplify(LShR(BitVecVal(4, 3), 1))
2
>>> simplify(BitVecVal(2, 3) >> 1)
1
>>> simplify(LShR(BitVecVal(2, 3), 1))
1

Definition at line 4013 of file z3py.py.

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

◆ 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__(), And(), help_simplify(), Or(), 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 4479 of file z3py.py.

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

Referenced by Context.Context().

◆ mk_not()

def z3py.mk_not (   a)

Definition at line 1667 of file z3py.py.

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

◆ Model()

def z3py.Model (   ctx = None)

Definition at line 6236 of file z3py.py.

6236 def Model(ctx = None):
6237  ctx = _get_ctx(ctx)
6238  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6239 

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

◆ MultiPattern()

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

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

Definition at line 1776 of file z3py.py.

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

◆ Not()

def z3py.Not (   a,
  ctx = None 
)
Create a Z3 not expression or probe.

>>> p = Bool('p')
>>> Not(Not(p))
Not(Not(p))
>>> simplify(Not(Not(p)))
p

Definition at line 1649 of file z3py.py.

1649 def Not(a, ctx=None):
1650  """Create a Z3 not expression or probe.
1651 
1652  >>> p = Bool('p')
1653  >>> Not(Not(p))
1654  Not(Not(p))
1655  >>> simplify(Not(Not(p)))
1656  p
1657  """
1658  ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1659  if is_probe(a):
1660  # Not is also used to build probes
1661  return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1662  else:
1663  s = BoolSort(ctx)
1664  a = s.cast(a)
1665  return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1666 

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

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

◆ Or()

def z3py.Or ( args)
Create a Z3 or-expression or or-probe.

>>> p, q, r = Bools('p q r')
>>> Or(p, q, r)
Or(p, q, r)
>>> P = BoolVector('p', 5)
>>> Or(P)
Or(p__0, p__1, p__2, p__3, p__4)

Definition at line 1713 of file z3py.py.

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

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

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

◆ ParAndThen()

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

Definition at line 7830 of file z3py.py.

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

◆ ParOr()

def z3py.ParOr ( ts,
**  ks 
)
Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).

>>> x = Int('x')
>>> t = ParOr(Tactic('simplify'), Tactic('fail'))
>>> t(x + 1 == 2)
[[x == 1]]

Definition at line 7798 of file z3py.py.

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

◆ parse_smt2_file()

def z3py.parse_smt2_file (   f,
  sorts = {},
  decls = {},
  ctx = None 
)
Parse a file in SMT 2.0 format using the given sorts and decls.

This function is similar to parse_smt2_string().

Definition at line 8603 of file z3py.py.

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

◆ parse_smt2_string()

def z3py.parse_smt2_string (   s,
  sorts = {},
  decls = {},
  ctx = None 
)
Parse a string in SMT 2.0 format using the given sorts and decls.

The arguments sorts and decls are Python dictionaries used to initialize
the symbol table used for the SMT 2.0 parser.

>>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
[x > 0, x < 10]
>>> x, y = Ints('x y')
>>> f = Function('f', IntSort(), IntSort())
>>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
[x + f(y) > 0]
>>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
[a > 0]

Definition at line 8583 of file z3py.py.

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

◆ ParThen()

def z3py.ParThen (   t1,
  t2,
  ctx = None 
)
Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.

>>> x, y = Ints('x y')
>>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
>>> t(And(Or(x == 1, x == 2), y == x + 1))
[[x == 1, y == 2], [x == 2, y == 3]]

Definition at line 7816 of file z3py.py.

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

Referenced by ParAndThen().

◆ PartialOrder()

def z3py.PartialOrder (   a,
  index 
)

Definition at line 10428 of file z3py.py.

10428 def PartialOrder(a, index):
10429  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10430 

◆ PbEq()

def z3py.PbEq (   args,
  k,
  ctx = None 
)
Create a Pseudo-Boolean inequality k constraint.

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

Definition at line 8390 of file z3py.py.

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

◆ PbGe()

def z3py.PbGe (   args,
  k 
)
Create a Pseudo-Boolean inequality k constraint.

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

Definition at line 8380 of file z3py.py.

8380 def PbGe(args, k):
8381  """Create a Pseudo-Boolean inequality k constraint.
8382 
8383  >>> a, b, c = Bools('a b c')
8384  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8385  """
8386  _z3_check_cint_overflow(k, "k")
8387  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8388  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8389 

◆ PbLe()

def z3py.PbLe (   args,
  k 
)
Create a Pseudo-Boolean inequality k constraint.

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

Definition at line 8370 of file z3py.py.

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

◆ PiecewiseLinearOrder()

def z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 10437 of file z3py.py.

10437 def PiecewiseLinearOrder(a, index):
10438  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10439 

◆ Plus()

def z3py.Plus (   re)
Create the regular expression accepting one or more repetitions of argument.
>>> re = Plus(Re("a"))
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("ab", re)))
False
>>> print(simplify(InRe("", re)))
False

Definition at line 10362 of file z3py.py.

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

◆ PrefixOf()

def z3py.PrefixOf (   a,
  b 
)
Check if 'a' is a prefix of 'b'
>>> s1 = PrefixOf("ab", "abc")
>>> simplify(s1)
True
>>> s2 = PrefixOf("bc", "abc")
>>> simplify(s2)
False

Definition at line 10152 of file z3py.py.

10152 def PrefixOf(a, b):
10153  """Check if 'a' is a prefix of 'b'
10154  >>> s1 = PrefixOf("ab", "abc")
10155  >>> simplify(s1)
10156  True
10157  >>> s2 = PrefixOf("bc", "abc")
10158  >>> simplify(s2)
10159  False
10160  """
10161  ctx = _get_ctx2(a, b)
10162  a = _coerce_seq(a, ctx)
10163  b = _coerce_seq(b, ctx)
10164  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10165 

◆ probe_description()

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

>>> d = probe_description('memory')

Definition at line 8088 of file z3py.py.

8088 def probe_description(name, ctx=None):
8089  """Return a short description for the probe named `name`.
8090 
8091  >>> d = probe_description('memory')
8092  """
8093  ctx = _get_ctx(ctx)
8094  return Z3_probe_get_descr(ctx.ref(), name)
8095 

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

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

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

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

◆ prove()

def z3py.prove (   claim,
**  keywords 
)
Try to prove the given claim.

This is a simple function for creating demonstrations.  It tries to prove
`claim` by showing the negation is unsatisfiable.

>>> p, q = Bools('p q')
>>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
proved

Definition at line 8458 of file z3py.py.

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

◆ Q()

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

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

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

Definition at line 2998 of file z3py.py.

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

◆ Range()

def z3py.Range (   lo,
  hi,
  ctx = None 
)
Create the range regular expression over two sequences of length 1
>>> range = Range("a","z")
>>> print(simplify(InRe("b", range)))
True
>>> print(simplify(InRe("bb", range)))
False

Definition at line 10414 of file z3py.py.

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

◆ RatVal()

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

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

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

Definition at line 2983 of file z3py.py.

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

Referenced by Q().

◆ Re()

def z3py.Re (   s,
  ctx = None 
)
The regular expression that accepts sequence 's'
>>> s1 = Re("ab")
>>> s2 = Re(StringVal("ab"))
>>> s3 = Re(Unit(BoolVal(True)))

Definition at line 10274 of file z3py.py.

10274 def Re(s, ctx=None):
10275  """The regular expression that accepts sequence 's'
10276  >>> s1 = Re("ab")
10277  >>> s2 = Re(StringVal("ab"))
10278  >>> s3 = Re(Unit(BoolVal(True)))
10279  """
10280  s = _coerce_seq(s, ctx)
10281  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10282 
10283 
10284 
10285 

◆ Real()

def z3py.Real (   name,
  ctx = None 
)
Return a real constant named `name`. If `ctx=None`, then the global context is used.

>>> x = Real('x')
>>> is_real(x)
True
>>> is_real(x + 1)
True

Definition at line 3058 of file z3py.py.

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

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

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

◆ RealSort()

def z3py.RealSort (   ctx = None)
Return the real sort in the given context. If `ctx=None`, then the global context is used.

>>> RealSort()
Real
>>> x = Const('x', RealSort())
>>> is_real(x)
True
>>> is_int(x)
False
>>> x.sort() == RealSort()
True

Definition at line 2923 of file z3py.py.

2923 def RealSort(ctx=None):
2924  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2925 
2926  >>> RealSort()
2927  Real
2928  >>> x = Const('x', RealSort())
2929  >>> is_real(x)
2930  True
2931  >>> is_int(x)
2932  False
2933  >>> x.sort() == RealSort()
2934  True
2935  """
2936  ctx = _get_ctx(ctx)
2937  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2938 

Referenced by FreshReal(), Context.getRealSort(), Context.mkRealSort(), 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 2965 of file z3py.py.

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

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

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

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

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

◆ RealVector()

def z3py.RealVector (   prefix,
  sz,
  ctx = None 
)
Return a list of real constants of size `sz`.

>>> X = RealVector('x', 3)
>>> X
[x__0, x__1, x__2]
>>> Sum(X)
x__0 + x__1 + x__2
>>> Sum(X).sort()
Real

Definition at line 3084 of file z3py.py.

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

◆ RecAddDefinition()

def z3py.RecAddDefinition (   f,
  args,
  body 
)
Set the body of a recursive function.
   Recursive definitions are only unfolded during search.
>>> ctx = Context()
>>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
>>> n = Int('n', ctx)
>>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
>>> simplify(fac(5))
fac(5)
>>> s = Solver(ctx=ctx)
>>> s.add(fac(n) < 3)
>>> s.check()
sat
>>> s.model().eval(fac(5))
120

Definition at line 841 of file z3py.py.

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

◆ RecFunction()

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

Definition at line 824 of file z3py.py.

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

◆ Repeat()

def z3py.Repeat (   t,
  max = 4294967295,
  ctx = None 
)
Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.

>>> x, y = Ints('x y')
>>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
>>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
>>> r = t(c)
>>> for subgoal in r: print(subgoal)
[x == 0, y == 0, x > y]
[x == 0, y == 1, x > y]
[x == 1, y == 0, x > y]
[x == 1, y == 1, x > y]
>>> t = Then(t, Tactic('propagate-values'))
>>> t(c)
[[x == 1, y == 0]]

Definition at line 7860 of file z3py.py.

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

◆ RepeatBitVec()

def z3py.RepeatBitVec (   n,
  a 
)
Return an expression representing `n` copies of `a`.

>>> x = BitVec('x', 8)
>>> n = RepeatBitVec(4, x)
>>> n
RepeatBitVec(4, x)
>>> n.size()
32
>>> v0 = BitVecVal(10, 4)
>>> print("%.x" % v0.as_long())
a
>>> v = simplify(RepeatBitVec(4, v0))
>>> v.size()
16
>>> print("%.x" % v.as_long())
aaaa

Definition at line 4130 of file z3py.py.

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

◆ Replace()

def z3py.Replace (   s,
  src,
  dst 
)
Replace the first occurrence of 'src' by 'dst' in 's'
>>> r = Replace("aaa", "a", "b")
>>> simplify(r)
"baa"

Definition at line 10199 of file z3py.py.

10199 def Replace(s, src, dst):
10200  """Replace the first occurrence of 'src' by 'dst' in 's'
10201  >>> r = Replace("aaa", "a", "b")
10202  >>> simplify(r)
10203  "baa"
10204  """
10205  ctx = _get_ctx2(dst, s)
10206  if ctx is None and is_expr(src):
10207  ctx = src.ctx
10208  src = _coerce_seq(src, ctx)
10209  dst = _coerce_seq(dst, ctx)
10210  s = _coerce_seq(s, ctx)
10211  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10212 

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

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

Referenced by Context.mkReSort().

◆ RNA()

def z3py.RNA (   ctx = None)

Definition at line 8992 of file z3py.py.

8992 def RNA (ctx=None):
8993  ctx = _get_ctx(ctx)
8994  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
8995 

Referenced by get_default_rounding_mode().

◆ RNE()

def z3py.RNE (   ctx = None)

Definition at line 8984 of file z3py.py.

8984 def RNE (ctx=None):
8985  ctx = _get_ctx(ctx)
8986  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
8987 

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

4044 def RotateLeft(a, b):
4045  """Return an expression representing `a` rotated to the left `b` times.
4046 
4047  >>> a, b = BitVecs('a b', 16)
4048  >>> RotateLeft(a, b)
4049  RotateLeft(a, b)
4050  >>> simplify(RotateLeft(a, 0))
4051  a
4052  >>> simplify(RotateLeft(a, 16))
4053  a
4054  """
4055  _check_bv_args(a, b)
4056  a, b = _coerce_exprs(a, b)
4057  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4058 

◆ RotateRight()

def z3py.RotateRight (   a,
  b 
)
Return an expression representing `a` rotated to the right `b` times.

>>> a, b = BitVecs('a b', 16)
>>> RotateRight(a, b)
RotateRight(a, b)
>>> simplify(RotateRight(a, 0))
a
>>> simplify(RotateRight(a, 16))
a

Definition at line 4059 of file z3py.py.

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

◆ RoundNearestTiesToAway()

def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 8988 of file z3py.py.

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

◆ RoundNearestTiesToEven()

def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 8980 of file z3py.py.

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

◆ RoundTowardNegative()

def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9004 of file z3py.py.

9004 def RoundTowardNegative(ctx=None):
9005  ctx = _get_ctx(ctx)
9006  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9007 

◆ RoundTowardPositive()

def z3py.RoundTowardPositive (   ctx = None)

Definition at line 8996 of file z3py.py.

8996 def RoundTowardPositive(ctx=None):
8997  ctx = _get_ctx(ctx)
8998  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
8999 

◆ RoundTowardZero()

def z3py.RoundTowardZero (   ctx = None)

Definition at line 9012 of file z3py.py.

9012 def RoundTowardZero(ctx=None):
9013  ctx = _get_ctx(ctx)
9014  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9015 

◆ RTN()

def z3py.RTN (   ctx = None)

Definition at line 9008 of file z3py.py.

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

Referenced by get_default_rounding_mode().

◆ RTP()

def z3py.RTP (   ctx = None)

Definition at line 9000 of file z3py.py.

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

Referenced by get_default_rounding_mode().

◆ RTZ()

def z3py.RTZ (   ctx = None)

Definition at line 9016 of file z3py.py.

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

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

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

◆ SeqSort()

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

Definition at line 9980 of file z3py.py.

9980 def SeqSort(s):
9981  """Create a sequence sort over elements provided in the argument
9982  >>> s = SeqSort(IntSort())
9983  >>> s == Unit(IntVal(1)).sort()
9984  True
9985  """
9986  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
9987 

Referenced by Context.mkSeqSort(), and Context.mkStringSort().

◆ set_default_fp_sort()

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

Definition at line 8656 of file z3py.py.

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

◆ set_default_rounding_mode()

def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 8640 of file z3py.py.

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

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

4612 def SetAdd(s, e):
4613  """ Add element e to set s
4614  >>> a = Const('a', SetSort(IntSort()))
4615  >>> SetAdd(a, 1)
4616  Store(a, 1, True)
4617  """
4618  ctx = _ctx_from_ast_arg_list([s,e])
4619  e = _py2expr(e, ctx)
4620  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4621 

◆ SetComplement()

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

Definition at line 4632 of file z3py.py.

4632 def SetComplement(s):
4633  """ The complement of set s
4634  >>> a = Const('a', SetSort(IntSort()))
4635  >>> SetComplement(a)
4636  complement(a)
4637  """
4638  ctx = s.ctx
4639  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4640 

◆ SetDel()

def z3py.SetDel (   s,
  e 
)
Remove element e to set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetDel(a, 1)
Store(a, 1, False)

Definition at line 4622 of file z3py.py.

4622 def SetDel(s, e):
4623  """ Remove element e to set s
4624  >>> a = Const('a', SetSort(IntSort()))
4625  >>> SetDel(a, 1)
4626  Store(a, 1, False)
4627  """
4628  ctx = _ctx_from_ast_arg_list([s,e])
4629  e = _py2expr(e, ctx)
4630  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4631 

◆ SetDifference()

def z3py.SetDifference (   a,
  b 
)
The set difference of a and b
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetDifference(a, b)
setminus(a, b)

Definition at line 4641 of file z3py.py.

4641 def SetDifference(a, b):
4642  """ The set difference of a and b
4643  >>> a = Const('a', SetSort(IntSort()))
4644  >>> b = Const('b', SetSort(IntSort()))
4645  >>> SetDifference(a, b)
4646  setminus(a, b)
4647  """
4648  ctx = _ctx_from_ast_arg_list([a, b])
4649  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4650 

◆ SetHasSize()

def z3py.SetHasSize (   a,
  k 
)

Definition at line 4533 of file z3py.py.

4533 def SetHasSize(a, k):
4534  ctx = a.ctx
4535  k = _py2expr(k, ctx)
4536  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4537 

◆ SetIntersect()

def z3py.SetIntersect ( args)
Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetIntersect(a, b)
intersection(a, b)

Definition at line 4600 of file z3py.py.

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

◆ SetSort()

def z3py.SetSort (   s)

Sets.

Create a set sort over element sort s

Definition at line 4568 of file z3py.py.

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

Referenced by Context.mkSetSort().

◆ SetUnion()

def z3py.SetUnion ( args)
Take the union of sets
>>> a = Const('a', SetSort(IntSort()))
>>> b = Const('b', SetSort(IntSort()))
>>> SetUnion(a, b)
union(a, b)

Definition at line 4588 of file z3py.py.

4588 def SetUnion(*args):
4589  """ Take the union of sets
4590  >>> a = Const('a', SetSort(IntSort()))
4591  >>> b = Const('b', SetSort(IntSort()))
4592  >>> SetUnion(a, b)
4593  union(a, b)
4594  """
4595  args = _get_args(args)
4596  ctx = _ctx_from_ast_arg_list(args)
4597  _args, sz = _to_ast_array(args)
4598  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4599 

◆ SignExt()

def z3py.SignExt (   n,
  a 
)
Return a bit-vector expression with `n` extra sign-bits.

>>> x = BitVec('x', 16)
>>> n = SignExt(8, x)
>>> n.size()
24
>>> n
SignExt(8, x)
>>> n.sort()
BitVec(24)
>>> v0 = BitVecVal(2, 2)
>>> v0
2
>>> v0.size()
2
>>> v  = simplify(SignExt(6, v0))
>>> v
254
>>> v.size()
8
>>> print("%.x" % v.as_long())
fe

Definition at line 4074 of file z3py.py.

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

◆ SimpleSolver()

def z3py.SimpleSolver (   ctx = None,
  logFile = None 
)
Return a simple general purpose solver with limited amount of preprocessing.

>>> s = SimpleSolver()
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.check()
sat

Definition at line 6931 of file z3py.py.

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

◆ simplify()

def z3py.simplify (   a,
arguments,
**  keywords 
)

Utils.

Simplify the expression `a` using the given options.

This function has many options. Use `help_simplify` to obtain the complete list.

>>> x = Int('x')
>>> y = Int('y')
>>> simplify(x + 1 + y + x + 1)
2 + 2*x + y
>>> simplify((x + 1)*(y + 1), som=True)
1 + x + y + x*y
>>> simplify(Distinct(x, y, 1), blast_distinct=True)
And(Not(x == y), Not(x == 1), Not(y == 1))
>>> simplify(And(x == 0, y == 1), elim_and=True)
Not(Or(Not(x == 0), Not(y == 1)))

Definition at line 8182 of file z3py.py.

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

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

8210 def simplify_param_descrs():
8211  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8212  return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8213 

◆ solve()

def z3py.solve ( args,
**  keywords 
)
Solve the constraints `*args`.

This is a simple function for creating demonstrations. It creates a solver,
configure it using the options in `keywords`, adds the constraints
in `args`, and invokes check.

>>> a = Int('a')
>>> solve(a > 0, a < 2)
[a = 1]

Definition at line 8401 of file z3py.py.

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

◆ solve_using()

def z3py.solve_using (   s,
args,
**  keywords 
)
Solve the constraints `*args` using solver `s`.

This is a simple function for creating demonstrations. It is similar to `solve`,
but it uses the given solver `s`.
It configures solver `s` using the options in `keywords`, adds the constraints
in `args`, and invokes check.

Definition at line 8429 of file z3py.py.

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

◆ SolverFor()

def z3py.SolverFor (   logic,
  ctx = None,
  logFile = None 
)
Create a solver customized for the given logic.

The parameter `logic` is a string. It should be contains
the name of a SMT-LIB logic.
See http://www.smtlib.org/ for the name of all available logics.

>>> s = SolverFor("QF_LIA")
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.add(x < 2)
>>> s.check()
sat
>>> s.model()
[x = 1]

Definition at line 6911 of file z3py.py.

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

◆ Sqrt()

def z3py.Sqrt (   a,
  ctx = None 
)
Return a Z3 expression which represents the square root of a.

>>> x = Real('x')
>>> Sqrt(x)
x**(1/2)

Definition at line 3160 of file z3py.py.

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

◆ SRem()

def z3py.SRem (   a,
  b 
)
Create the Z3 expression signed remainder.

Use the operator % for signed modulus, and URem() for unsigned remainder.

>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> SRem(x, y)
SRem(x, y)
>>> SRem(x, y).sort()
BitVec(32)
>>> (x % y).sexpr()
'(bvsmod x y)'
>>> SRem(x, y).sexpr()
'(bvsrem x y)'

Definition at line 3993 of file z3py.py.

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

◆ Star()

def z3py.Star (   re)
Create the regular expression accepting zero or more repetitions of argument.
>>> re = Star(Re("a"))
>>> print(simplify(InRe("aa", re)))
True
>>> print(simplify(InRe("ab", re)))
False
>>> print(simplify(InRe("", re)))
True

Definition at line 10390 of file z3py.py.

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

◆ Store()

def z3py.Store (   a,
  i,
  v 
)
Return a Z3 store array expression.

>>> a    = Array('a', IntSort(), IntSort())
>>> i, v = Ints('i v')
>>> s    = Store(a, i, v)
>>> s.sort()
Array(Int, Int)
>>> prove(s[i] == v)
proved
>>> j    = Int('j')
>>> prove(Implies(i != j, s[j] == a[j]))
proved

Definition at line 4448 of file z3py.py.

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

◆ String()

def z3py.String (   name,
  ctx = None 
)
Return a string constant named `name`. If `ctx=None`, then the global context is used.

>>> x = String('x')

Definition at line 10085 of file z3py.py.

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

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

◆ Strings()

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

Definition at line 10093 of file z3py.py.

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

Referenced by SubSeq().

◆ StringSort()

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

Definition at line 9970 of file z3py.py.

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

Referenced by String().

◆ StringVal()

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

Definition at line 10080 of file z3py.py.

10080 def StringVal(s, ctx=None):
10081  """create a string expression"""
10082  ctx = _get_ctx(ctx)
10083  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10084 

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

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

◆ SubSeq()

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

Definition at line 10104 of file z3py.py.

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

◆ substitute()

def z3py.substitute (   t,
m 
)
Apply substitution m on t, m is a list of pairs of the form (from, to). Every occurrence in t of from is replaced with to.

>>> x = Int('x')
>>> y = Int('y')
>>> substitute(x + 1, (x, y + 1))
y + 1 + 1
>>> f = Function('f', IntSort(), IntSort())
>>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
1 + 1

Definition at line 8214 of file z3py.py.

8214 def substitute(t, *m):
8215  """Apply substitution m on t, m is a list of pairs of the form (from, to). Every occurrence in t of from is replaced with to.
8216 
8217  >>> x = Int('x')
8218  >>> y = Int('y')
8219  >>> substitute(x + 1, (x, y + 1))
8220  y + 1 + 1
8221  >>> f = Function('f', IntSort(), IntSort())
8222  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8223  1 + 1
8224  """
8225  if isinstance(m, tuple):
8226  m1 = _get_args(m)
8227  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8228  m = m1
8229  if z3_debug():
8230  _z3_assert(is_expr(t), "Z3 expression expected")
8231  _z3_assert(all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) and p[0].sort().eq(p[1].sort()) for p in m]), "Z3 invalid substitution, expression pairs expected.")
8232  num = len(m)
8233  _from = (Ast * num)()
8234  _to = (Ast * num)()
8235  for i in range(num):
8236  _from[i] = m[i][0].as_ast()
8237  _to[i] = m[i][1].as_ast()
8238  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8239 

◆ substitute_vars()

def z3py.substitute_vars (   t,
m 
)
Substitute the free variables in t with the expression in m.

>>> v0 = Var(0, IntSort())
>>> v1 = Var(1, IntSort())
>>> x  = Int('x')
>>> f  = Function('f', IntSort(), IntSort(), IntSort())
>>> # replace v0 with x+1 and v1 with x
>>> substitute_vars(f(v0, v1), x + 1, x)
f(x + 1, x)

Definition at line 8240 of file z3py.py.

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

◆ SubString()

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

Definition at line 10100 of file z3py.py.

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

◆ SuffixOf()

def z3py.SuffixOf (   a,
  b 
)
Check if 'a' is a suffix of 'b'
>>> s1 = SuffixOf("ab", "abc")
>>> simplify(s1)
False
>>> s2 = SuffixOf("bc", "abc")
>>> simplify(s2)
True

Definition at line 10166 of file z3py.py.

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

◆ Sum()

def z3py.Sum ( args)
Create the sum of the Z3 expressions.

>>> a, b, c = Ints('a b c')
>>> Sum(a, b, c)
a + b + c
>>> Sum([a, b, c])
a + b + c
>>> A = IntVector('a', 5)
>>> Sum(A)
a__0 + a__1 + a__2 + a__3 + a__4

Definition at line 8260 of file z3py.py.

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

◆ tactic_description()

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

>>> d = tactic_description('simplify')

Definition at line 7897 of file z3py.py.

7897 def tactic_description(name, ctx=None):
7898  """Return a short description for the tactic named `name`.
7899 
7900  >>> d = tactic_description('simplify')
7901  """
7902  ctx = _get_ctx(ctx)
7903  return Z3_tactic_get_descr(ctx.ref(), name)
7904 

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

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

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

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

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

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

◆ ToReal()

def z3py.ToReal (   a)
Return the Z3 expression ToReal(a).

>>> x = Int('x')
>>> x.sort()
Int
>>> n = ToReal(x)
>>> n
ToReal(x)
>>> n.sort()
Real

Definition at line 3110 of file z3py.py.

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

◆ TransitiveClosure()

def z3py.TransitiveClosure (   f)
Given a binary relation R, such that the two arguments have the same sort
create the transitive closure relation R+.
The transitive closure R+ is a new relation.

Definition at line 10440 of file z3py.py.

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

◆ TreeOrder()

def z3py.TreeOrder (   a,
  index 
)

Definition at line 10434 of file z3py.py.

10434 def TreeOrder(a, index):
10435  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10436 

◆ TryFor()

def z3py.TryFor (   t,
  ms,
  ctx = None 
)
Return a tactic that applies `t` to a given goal for `ms` milliseconds.

If `t` does not terminate in `ms` milliseconds, then it fails.

Definition at line 7879 of file z3py.py.

7879 def TryFor(t, ms, ctx=None):
7880  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7881 
7882  If `t` does not terminate in `ms` milliseconds, then it fails.
7883  """
7884  t = _to_tactic(t, ctx)
7885  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7886 

◆ TupleSort()

def z3py.TupleSort (   name,
  sorts,
  ctx = None 
)
Create a named tuple sort base on a set of underlying sorts
Example:
    >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])

Definition at line 4971 of file z3py.py.

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

Referenced by Context.mkTupleSort().

◆ UDiv()

def z3py.UDiv (   a,
  b 
)
Create the Z3 expression (unsigned) division `self / other`.

Use the operator / for signed division.

>>> x = BitVec('x', 32)
>>> y = BitVec('y', 32)
>>> UDiv(x, y)
UDiv(x, y)
>>> UDiv(x, y).sort()
BitVec(32)
>>> (x / y).sexpr()
'(bvsdiv x y)'
>>> UDiv(x, y).sexpr()
'(bvudiv x y)'

Definition at line 3953 of file z3py.py.

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

◆ UGE()

def z3py.UGE (   a,
  b 
)
Create the Z3 expression (unsigned) `other >= self`.

Use the operator >= for signed greater than or equal to.

>>> x, y = BitVecs('x y', 32)
>>> UGE(x, y)
UGE(x, y)
>>> (x >= y).sexpr()
'(bvsge x y)'
>>> UGE(x, y).sexpr()
'(bvuge x y)'

Definition at line 3919 of file z3py.py.

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

◆ UGT()

def z3py.UGT (   a,
  b 
)
Create the Z3 expression (unsigned) `other > self`.

Use the operator > for signed greater than.

>>> x, y = BitVecs('x y', 32)
>>> UGT(x, y)
UGT(x, y)
>>> (x > y).sexpr()
'(bvsgt x y)'
>>> UGT(x, y).sexpr()
'(bvugt x y)'

Definition at line 3936 of file z3py.py.

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

◆ ULE()

def z3py.ULE (   a,
  b 
)
Create the Z3 expression (unsigned) `other <= self`.

Use the operator <= for signed less than or equal to.

>>> x, y = BitVecs('x y', 32)
>>> ULE(x, y)
ULE(x, y)
>>> (x <= y).sexpr()
'(bvsle x y)'
>>> ULE(x, y).sexpr()
'(bvule x y)'

Definition at line 3885 of file z3py.py.

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

◆ ULT()

def z3py.ULT (   a,
  b 
)
Create the Z3 expression (unsigned) `other < self`.

Use the operator < for signed less than.

>>> x, y = BitVecs('x y', 32)
>>> ULT(x, y)
ULT(x, y)
>>> (x < y).sexpr()
'(bvslt x y)'
>>> ULT(x, y).sexpr()
'(bvult x y)'

Definition at line 3902 of file z3py.py.

3902 def ULT(a, b):
3903  """Create the Z3 expression (unsigned) `other < self`.
3904 
3905  Use the operator < for signed less than.
3906 
3907  >>> x, y = BitVecs('x y', 32)
3908  >>> ULT(x, y)
3909  ULT(x, y)
3910  >>> (x < y).sexpr()
3911  '(bvslt x y)'
3912  >>> ULT(x, y).sexpr()
3913  '(bvult x y)'
3914  """
3915  _check_bv_args(a, b)
3916  a, b = _coerce_exprs(a, b)
3917  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3918 

◆ Union()

def z3py.Union ( args)
Create union of regular expressions.
>>> re = Union(Re("a"), Re("b"), Re("c"))
>>> print (simplify(InRe("d", re)))
False

Definition at line 10326 of file z3py.py.

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

Referenced by ReRef.__add__().

◆ Unit()

def z3py.Unit (   a)
Create a singleton sequence

Definition at line 10148 of file z3py.py.

10148 def Unit(a):
10149  """Create a singleton sequence"""
10150  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10151 

◆ Update()

def z3py.Update (   a,
  i,
  v 
)
Return a Z3 store array expression.

>>> a    = Array('a', IntSort(), IntSort())
>>> i, v = Ints('i v')
>>> s    = Update(a, i, v)
>>> s.sort()
Array(Int, Int)
>>> prove(s[i] == v)
proved
>>> j    = Int('j')
>>> prove(Implies(i != j, s[j] == a[j]))
proved

Definition at line 4416 of file z3py.py.

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

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

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

◆ Var()

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

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

Definition at line 1331 of file z3py.py.

1331 def Var(idx, s):
1332  """Create a Z3 free variable. Free variables are used to create quantified formulas.
1333 
1334  >>> Var(0, IntSort())
1335  Var(0)
1336  >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1337  False
1338  """
1339  if z3_debug():
1340  _z3_assert(is_sort(s), "Z3 sort expected")
1341  return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1342 

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

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

◆ With()

def z3py.With (   t,
args,
**  keys 
)
Return a tactic that applies tactic `t` using the given configuration options.

>>> x, y = Ints('x y')
>>> t = With(Tactic('simplify'), som=True)
>>> t((x + 1)*(y + 2) == 0)
[[2*x + y + x*y == -2]]

Definition at line 7834 of file z3py.py.

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

◆ WithParams()

def z3py.WithParams (   t,
  p 
)
Return a tactic that applies tactic `t` using the given configuration options.

>>> x, y = Ints('x y')
>>> p = ParamsRef()
>>> p.set("som", True)
>>> t = WithParams(Tactic('simplify'), p)
>>> t((x + 1)*(y + 2) == 0)
[[2*x + y + x*y == -2]]

Definition at line 7847 of file z3py.py.

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

◆ Xor()

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

>>> p, q = Bools('p q')
>>> Xor(p, q)
Xor(p, q)
>>> simplify(Xor(p, q))
Not(p) == q

Definition at line 1634 of file z3py.py.

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

◆ 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(), AlgebraicNumRef.as_decimal(), IntNumRef.as_long(), AtLeast(), AtMost(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), ExprRef.children(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), describe_probes(), Distinct(), FuncDeclRef.domain(), EnumSort(), AstRef.eq(), eq(), Ext(), Extract(), FiniteDomainVal(), fpIsPositive(), fpNeg(), FPSort(), fpToFPUnsigned(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), Function(), get_as_array_func(), ModelRef.get_interp(), get_map_func(), ModelRef.get_universe(), get_var_index(), If(), Intersect(), is_quantifier(), is_sort(), IsInt(), K(), Map(), MultiPattern(), QuantifierRef.no_pattern(), ExprRef.num_args(), Or(), OrElse(), Tactic.param_descrs(), ParOr(), ParThen(), QuantifierRef.pattern(), prove(), RatVal(), RealSort(), RecFunction(), DatatypeSortRef.recognizer(), RepeatBitVec(), Select(), ParamsRef.set(), set_param(), SignExt(), simplify(), solve_using(), substitute(), substitute_vars(), ToInt(), ToReal(), AstRef.translate(), Goal.translate(), ModelRef.translate(), Solver.translate(), Union(), Update(), Var(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and ZeroExt().

◆ z3_error_handler()

def z3py.z3_error_handler (   c,
  e 
)

Definition at line 156 of file z3py.py.

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

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

Variable Documentation

◆ sat

Definition at line 6432 of file z3py.py.

◆ unknown

Definition at line 6434 of file z3py.py.

◆ unsat

Definition at line 6433 of file z3py.py.

◆ Z3_DEBUG

Z3_DEBUG = __debug__

Definition at line 54 of file z3py.py.

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:3070
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:9278
z3py.RNA
def RNA(ctx=None)
Definition: z3py.py:8992
z3py.fpLT
def fpLT(a, b, ctx=None)
Definition: z3py.py:9631
z3py.fpRoundToIntegral
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9576
z3py.RepeatBitVec
def RepeatBitVec(n, a)
Definition: z3py.py:4130
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:8783
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:8996
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:3097
z3py.is_distinct
def is_distinct(a)
Definition: z3py.py:1522
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:9020
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:9592
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:4971
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:2722
z3py.fpBVToFP
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9763
z3py.fpMinusInfinity
def fpMinusInfinity(s)
Definition: z3py.py:9273
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:9367
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:4103
z3py.ParOr
def ParOr(*ts, **ks)
Definition: z3py.py:7798
z3py.IsMember
def IsMember(e, s)
Definition: z3py.py:4651
z3py.SetIntersect
def SetIntersect(*args)
Definition: z3py.py:4600
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:3127
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:4982
z3py.Strings
def Strings(names, ctx=None)
Definition: z3py.py:10093
z3py.is_fp
def is_fp(a)
Definition: z3py.py:9156
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:4533
z3py.RealSort
def RealSort(ctx=None)
Definition: z3py.py:2923
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:4290
z3py.FPVal
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9300
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:1353
z3py.fpToUBV
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9879
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:1312
z3py.RTP
def RTP(ctx=None)
Definition: z3py.py:9000
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.
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:10440
z3py.Var
def Var(idx, s)
Definition: z3py.py:1331
z3py.AtLeast
def AtLeast(*args)
Definition: z3py.py:8328
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:8078
z3py.SignExt
def SignExt(n, a)
Definition: z3py.py:4074
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:3431
z3py.BVSubNoOverflow
def BVSubNoOverflow(a, b)
Definition: z3py.py:4177
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:8583
z3py.reset_params
def reset_params()
Definition: z3py.py:263
z3py.ULT
def ULT(a, b)
Definition: z3py.py:3902
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:9004
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:2983
z3py.IntVal
def IntVal(val, ctx=None)
Definition: z3py.py:2954
z3py.SetDifference
def SetDifference(a, b)
Definition: z3py.py:4641
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:9725
z3py.fpGT
def fpGT(a, b, ctx=None)
Definition: z3py.py:9653
z3py.tactics
def tactics(ctx=None)
Definition: z3py.py:7887
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:9832
z3py.IsInt
def IsInt(a)
Definition: z3py.py:3144
z3py.RTN
def RTN(ctx=None)
Definition: z3py.py:9008
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:2178
z3py.RotateLeft
def RotateLeft(a, b)
Definition: z3py.py:4044
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:1713
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:10434
z3py.BoolVector
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1594
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:10402
z3py.SubSeq
def SubSeq(s, offset, length)
Definition: z3py.py:10104
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.SimpleSolver
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6931
z3py.With
def With(t, *args, **keys)
Definition: z3py.py:7834
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:4538
z3py.simplify
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8182
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:9970
z3py.is_gt
def is_gt(a)
Definition: z3py.py:2700
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.
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:2061
z3py.is_implies
def is_implies(a)
Definition: z3py.py:1491
z3py.to_symbol
def to_symbol(s, ctx=None)
Definition: z3py.py:109
z3py.is_map
def is_map(a)
Definition: z3py.py:4331
z3py.is_or
def is_or(a)
Definition: z3py.py:1480
z3py.fpMul
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9497
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:9664
z3py.is_string_value
def is_string_value(a)
Definition: z3py.py:10070
z3py.is_app
def is_app(a)
Definition: z3py.py:1137
z3py.IndexOf
def IndexOf(s, substr)
Definition: z3py.py:10213
z3py.fpEQ
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9675
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:4013
z3py.is_default
def is_default(a)
Definition: z3py.py:4346
z3py.fpRem
def fpRem(a, b, ctx=None)
Definition: z3py.py:9525
z3py.substitute
def substitute(t, *m)
Definition: z3py.py:8214
z3py.Union
def Union(*args)
Definition: z3py.py:10326
z3py.fpMinusZero
def fpMinusZero(s)
Definition: z3py.py:9289
z3py.RotateRight
def RotateRight(a, b)
Definition: z3py.py:4059
z3py.FiniteDomainSort
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7221
z3py.is_ge
def is_ge(a)
Definition: z3py.py:2689
z3py.is_and
def is_and(a)
Definition: z3py.py:1469
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:1776
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:10152
z3py.InRe
def InRe(s, re)
Definition: z3py.py:10313
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:1680
z3py.UGE
def UGE(a, b)
Definition: z3py.py:3919
z3py.Cbrt
def Cbrt(a, ctx=None)
Definition: z3py.py:3172
z3py.disable_trace
def disable_trace(msg)
Definition: z3py.py:70
z3py.Float64
def Float64(ctx=None)
Definition: z3py.py:8749
z3py.BitVecVal
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3754
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:4319
z3py.Float32
def Float32(ctx=None)
Definition: z3py.py:8739
z3py.Range
def Range(lo, hi, ctx=None)
Definition: z3py.py:10414
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:8166
z3py.is_fp_value
def is_fp_value(a)
Definition: z3py.py:9169
z3py.is_finite_domain_sort
def is_finite_domain_sort(s)
Definition: z3py.py:7228
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:9552
z3py.RealVal
def RealVal(val, ctx=None)
Definition: z3py.py:2965
z3py.PbLe
def PbLe(args, k)
Definition: z3py.py:8370
z3py.solve
def solve(*args, **keywords)
Definition: z3py.py:8401
z3py.RoundNearestTiesToEven
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:8980
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:1301
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:2044
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:9849
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:8764
z3py.eq
def eq(a, b)
Definition: z3py.py:432
z3py.fpAbs
def fpAbs(a, ctx=None)
Definition: z3py.py:9385
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:1248
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:8640
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:4294
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:1667
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:6244
z3py.fpFMA
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9566
z3py.is_not
def is_not(a)
Definition: z3py.py:1502
z3py.Int
def Int(name, ctx=None)
Definition: z3py.py:3010
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:8210
z3py.EmptySet
def EmptySet(s)
Definition: z3py.py:4572
z3py.SuffixOf
def SuffixOf(a, b)
Definition: z3py.py:10166
z3py.fpSignedToFP
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9815
z3py.get_default_rounding_mode
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8626
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:8390
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:9032
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:4159
z3py.is_quantifier
def is_quantifier(a)
Definition: z3py.py:1997
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:10242
z3py.get_ctx
def get_ctx(ctx)
Definition: z3py.py:237
z3py.BVAddNoOverflow
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4165
z3py.is_eq
def is_eq(a)
Definition: z3py.py:1513
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:9581
z3py.URem
def URem(a, b)
Definition: z3py.py:3973
z3py.is_const
def is_const(a)
Definition: z3py.py:1162
z3py.Star
def Star(re)
Definition: z3py.py:10390
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:2515
z3py.is_mod
def is_mod(a)
Definition: z3py.py:2656
z3py.Ints
def Ints(names, ctx=None)
Definition: z3py.py:3022
z3py.Model
def Model(ctx=None)
Definition: z3py.py:6236
z3py.Extract
def Extract(high, low, a)
Definition: z3py.py:3858
z3py.Int2BV
def Int2BV(a, num_bits)
Definition: z3py.py:3732
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:10199
z3py.FreshBool
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1608
z3py.Array
def Array(name, dom, rng)
Definition: z3py.py:4403
z3py.CreateDatatypes
def CreateDatatypes(*ds)
Definition: z3py.py:4782
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:8984
z3py.ParAndThen
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7830
z3py.BVAddNoUnderflow
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4171
z3py.FloatDouble
def FloatDouble(ctx=None)
Definition: z3py.py:8754
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:8729
z3py.Bools
def Bools(names, ctx=None)
Definition: z3py.py:1579
z3py.Intersect
def Intersect(*args)
Definition: z3py.py:10345
z3py.Sum
def Sum(*args)
Definition: z3py.py:8260
z3py.RoundNearestTiesToAway
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:8988
z3py.is_pattern
def is_pattern(a)
Definition: z3py.py:1759
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:8603
z3py.substitute_vars
def substitute_vars(t, *m)
Definition: z3py.py:8240
z3py.is_le
def is_le(a)
Definition: z3py.py:2667
z3py.help_simplify
def help_simplify()
Definition: z3py.py:8206
z3py.IsSubset
def IsSubset(a, b)
Definition: z3py.py:4661
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.Implies
def Implies(a, b, ctx=None)
Definition: z3py.py:1621
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:4190
z3py.is_arith
def is_arith(a)
Definition: z3py.py:2477
z3py.BitVec
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3770
z3py.is_sort
def is_sort(s)
Definition: z3py.py:596
z3py.is_int_value
def is_int_value(a)
Definition: z3py.py:2539
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:3110
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:3793
z3py.is_re
def is_re(s)
Definition: z3py.py:10309
z3py.is_int
def is_int(a)
Definition: z3py.py:2497
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:10233
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:10063
z3py.Default
def Default(a)
Definition: z3py.py:4437
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:4354
z3py.Distinct
def Distinct(*args)
Definition: z3py.py:1270
z3py.fpIsNormal
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9607
z3py.FreshConst
def FreshConst(sort, prefix='c')
Definition: z3py.py:1326
z3py.PbGe
def PbGe(args, k)
Definition: z3py.py:8380
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:1439
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:4568
z3py.Real
def Real(name, ctx=None)
Definition: z3py.py:3058
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:8088
z3py.Lambda
def Lambda(vs, body)
Definition: z3py.py:2081
z3py.tactic_description
def tactic_description(name, ctx=None)
Definition: z3py.py:7897
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:10080
z3py.StrToInt
def StrToInt(s)
Definition: z3py.py:10251
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:9697
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:9284
z3py.fpNaN
def fpNaN(s)
Definition: z3py.py:9241
z3py.FPSort
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9183
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:10148
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:7250
z3py.fpZero
def fpZero(s, negative)
Definition: z3py.py:9294
z3py.fpSqrt
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9571
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:1343
z3py.FP
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9344
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:9511
z3py.is_as_array
def is_as_array(n)
Definition: z3py.py:6240
z3py.set_default_fp_sort
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8656
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:10437
z3py.is_store
def is_store(a)
Definition: z3py.py:4550
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:4464
z3py.AtMost
def AtMost(*args)
Definition: z3py.py:8311
z3py.RecAddDefinition
def RecAddDefinition(f, args, body)
Definition: z3py.py:841
z3py.fpToSBV
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9858
z3py.is_div
def is_div(a)
Definition: z3py.py:2629
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:10274
z3py.FullSet
def FullSet(s)
Definition: z3py.py:4580
z3py.OrElse
def OrElse(*ts, **ks)
Definition: z3py.py:7778
z3py.is_probe
def is_probe(p)
Definition: z3py.py:8062
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:2607
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:3045
z3py.fpPlusInfinity
def fpPlusInfinity(s)
Definition: z3py.py:9257
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:8429
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:10362
z3py.append_log
def append_log(s)
Definition: z3py.py:105
z3py.FiniteDomainVal
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7289
z3py.Float128
def Float128(ctx=None)
Definition: z3py.py:8759
z3py.is_add
def is_add(a)
Definition: z3py.py:2596
z3py.Then
def Then(*ts, **ks)
Definition: z3py.py:7766
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:10431
z3py.ArraySort
def ArraySort(*sig)
Definition: z3py.py:4371
z3py.BitVecSort
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3740
z3py.fpAdd
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9467
z3py.Contains
def Contains(a, b)
Definition: z3py.py:10180
z3py.is_finite_domain_value
def is_finite_domain_value(a)
Definition: z3py.py:7303
z3py.Bool
def Bool(name, ctx=None)
Definition: z3py.py:1568
z3py.SetUnion
def SetUnion(*args)
Definition: z3py.py:4588
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:9483
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:4307
z3py.Product
def Product(*args)
Definition: z3py.py:8286
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:10267
z3py.TryFor
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7879
z3py.SetDel
def SetDel(s, e)
Definition: z3py.py:4622
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.SRem
def SRem(a, b)
Definition: z3py.py:3993
z3py.get_var_index
def get_var_index(a)
Definition: z3py.py:1204
z3py.fpNeg
def fpNeg(a, ctx=None)
Definition: z3py.py:9407
z3py.fpLEQ
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9642
z3py.EnumSort
def EnumSort(name, values, ctx=None)
Definition: z3py.py:4994
z3py.BoolVal
def BoolVal(val, ctx=None)
Definition: z3py.py:1550
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:8653
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:3696
z3py.is_idiv
def is_idiv(a)
Definition: z3py.py:2645
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:3813
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:6911
z3py.describe_probes
def describe_probes()
Definition: z3py.py:8096
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:1649
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:4501
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:4153
z3py.is_fp_sort
def is_fp_sort(s)
Definition: z3py.py:8773
z3py.is_var
def is_var(a)
Definition: z3py.py:1180
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:4196
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:3034
z3py.is_bv_sort
def is_bv_sort(s)
Definition: z3py.py:3222
z3py.Full
def Full(s)
Definition: z3py.py:10134
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:2711
z3py.AndThen
def AndThen(*ts, **ks)
Definition: z3py.py:7747
z3py.IntSort
def IntSort(ctx=None)
Definition: z3py.py:2907
z3py.fpIsZero
def fpIsZero(a, ctx=None)
Definition: z3py.py:9602
z3py.is_rational_value
def is_rational_value(a)
Definition: z3py.py:2562
z3py.PartialOrder
def PartialOrder(a, index)
Definition: z3py.py:10428
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:3936
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:3953
z3py.BV2Int
def BV2Int(a, is_signed=False)
Definition: z3py.py:3710
z3py.is_func_decl
def is_func_decl(a)
Definition: z3py.py:787
z3py.RoundTowardZero
def RoundTowardZero(ctx=None)
Definition: z3py.py:9012
z3py.WithParams
def WithParams(t, p)
Definition: z3py.py:7847
z3py.RecFunction
def RecFunction(name, *sig)
Definition: z3py.py:824
z3py.Xor
def Xor(a, b, ctx=None)
Definition: z3py.py:1634
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:2583
z3py.BVMulNoUnderflow
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4209
z3py.is_to_int
def is_to_int(a)
Definition: z3py.py:2736
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:8458
z3py.is_bv
def is_bv(a)
Definition: z3py.py:3683
z3py.fpMin
def fpMin(a, b, ctx=None)
Definition: z3py.py:9538
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:1115
z3py.Sqrt
def Sqrt(a, ctx=None)
Definition: z3py.py:3160
z3py.SetComplement
def SetComplement(s)
Definition: z3py.py:4632
z3py.is_app_of
def is_app_of(a, k)
Definition: z3py.py:1236
z3py.BVMulNoOverflow
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4202
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:7860
z3py.fpToReal
def fpToReal(x, ctx=None)
Definition: z3py.py:9900
z3py.Update
def Update(a, i, v)
Definition: z3py.py:4416
z3py.describe_tactics
def describe_tactics()
Definition: z3py.py:7905
z3py.is_bool
def is_bool(a)
Definition: z3py.py:1422
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:2678
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:8734
z3py.fpIsSubnormal
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9612
z3py.SetAdd
def SetAdd(s, e)
Definition: z3py.py:4612
z3py.Ext
def Ext(a, b)
Definition: z3py.py:4522
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:9617
z3py.fpFPToFP
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9779
z3py.fpNEQ
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9686
z3py.SeqSort
def SeqSort(s)
Definition: z3py.py:9980
z3py.Map
def Map(f, *args)
Definition: z3py.py:4479
z3py.BVSubNoUnderflow
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4184
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:7816
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:5070
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:1456
z3py.Store
def Store(a, i, v)
Definition: z3py.py:4448
z3py.FloatSingle
def FloatSingle(ctx=None)
Definition: z3py.py:8744
z3py.ULE
def ULE(a, b)
Definition: z3py.py:3885
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:8129
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:1533
z3py.get_param
def get_param(name)
Definition: z3py.py:273
z3py.fpRealToFP
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9798
z3py.Complement
def Complement(re)
Definition: z3py.py:10386
z3py.RealVector
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3084
z3py.Empty
def Empty(s)
Definition: z3py.py:10115
z3py.Option
def Option(re)
Definition: z3py.py:10374
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:9622
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:10294
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:9016
z3py.is_sub
def is_sub(a)
Definition: z3py.py:2618
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:10100
z3py.When
def When(p, t, ctx=None)
Definition: z3py.py:8148
z3py.is_seq
def is_seq(a)
Definition: z3py.py:10054
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:9919
z3py.Q
def Q(a, b, ctx=None)
Definition: z3py.py:2998
z3py.String
def String(name, ctx=None)
Definition: z3py.py:10085
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.