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

Variables

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

Function Documentation

◆ And()

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

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

Definition at line 1700 of file z3py.py.

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

Referenced by Fixedpoint.add_rule(), Goal.as_expr(), Fixedpoint.query(), Fixedpoint.query_from_lvl(), and Fixedpoint.update_rule().

◆ AndThen()

def z3py.AndThen ( ts,
**  ks 
)
Return a tactic that applies the tactics in `*ts` in sequence.

>>> x, y = Ints('x y')
>>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
>>> t(And(x == 0, y > x + 1))
[[Not(y <= 1)]]
>>> t(And(x == 0, y > x + 1)).as_expr()
Not(y <= 1)

Definition at line 7770 of file z3py.py.

7770 def AndThen(*ts, **ks):
7771  """Return a tactic that applies the tactics in `*ts` in sequence.
7772 
7773  >>> x, y = Ints('x y')
7774  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7775  >>> t(And(x == 0, y > x + 1))
7776  [[Not(y <= 1)]]
7777  >>> t(And(x == 0, y > x + 1)).as_expr()
7778  Not(y <= 1)
7779  """
7780  if z3_debug():
7781  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7782  ctx = ks.get('ctx', None)
7783  num = len(ts)
7784  r = ts[0]
7785  for i in range(num - 1):
7786  r = _and_then(r, ts[i+1], ctx)
7787  return r
7788 

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

5093 def args2params(arguments, keywords, ctx=None):
5094  """Convert python arguments into a Z3_params object.
5095  A ':' is added to the keywords, and '_' is replaced with '-'
5096 
5097  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5098  (params model true relevancy 2 elim_and true)
5099  """
5100  if z3_debug():
5101  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5102  prev = None
5103  r = ParamsRef(ctx)
5104  for a in arguments:
5105  if prev is None:
5106  prev = a
5107  else:
5108  r.set(prev, a)
5109  prev = None
5110  for k in keywords:
5111  v = keywords[k]
5112  r.set(k, v)
5113  return r
5114 

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

4426 def Array(name, dom, rng):
4427  """Return an array constant named `name` with the given domain and range sorts.
4428 
4429  >>> a = Array('a', IntSort(), IntSort())
4430  >>> a.sort()
4431  Array(Int, Int)
4432  >>> a[0]
4433  a[0]
4434  """
4435  s = ArraySort(dom, rng)
4436  ctx = s.ctx
4437  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4438 

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

4394 def ArraySort(*sig):
4395  """Return the Z3 array sort with the given domain and range sorts.
4396 
4397  >>> A = ArraySort(IntSort(), BoolSort())
4398  >>> A
4399  Array(Int, Bool)
4400  >>> A.domain()
4401  Int
4402  >>> A.range()
4403  Bool
4404  >>> AA = ArraySort(IntSort(), A)
4405  >>> AA
4406  Array(Int, Array(Int, Bool))
4407  """
4408  sig = _get_args(sig)
4409  if z3_debug():
4410  _z3_assert(len(sig) > 1, "At least two arguments expected")
4411  arity = len(sig) - 1
4412  r = sig[arity]
4413  d = sig[0]
4414  if z3_debug():
4415  for s in sig:
4416  _z3_assert(is_sort(s), "Z3 sort expected")
4417  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4418  ctx = d.ctx
4419  if len(sig) == 2:
4420  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4421  dom = (Sort * arity)()
4422  for i in range(arity):
4423  dom[i] = sig[i].ast
4424  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4425 

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

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

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

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

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

3793 def BitVec(name, bv, ctx=None):
3794  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
3795  If `ctx=None`, then the global context is used.
3796 
3797  >>> x = BitVec('x', 16)
3798  >>> is_bv(x)
3799  True
3800  >>> x.size()
3801  16
3802  >>> x.sort()
3803  BitVec(16)
3804  >>> word = BitVecSort(16)
3805  >>> x2 = BitVec('x', word)
3806  >>> eq(x, x2)
3807  True
3808  """
3809  if isinstance(bv, BitVecSortRef):
3810  ctx = bv.ctx
3811  else:
3812  ctx = _get_ctx(ctx)
3813  bv = BitVecSort(bv, ctx)
3814  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
3815 

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

3816 def BitVecs(names, bv, ctx=None):
3817  """Return a tuple of bit-vector constants of size bv.
3818 
3819  >>> x, y, z = BitVecs('x y z', 16)
3820  >>> x.size()
3821  16
3822  >>> x.sort()
3823  BitVec(16)
3824  >>> Sum(x, y, z)
3825  0 + x + y + z
3826  >>> Product(x, y, z)
3827  1*x*y*z
3828  >>> simplify(Product(x, y, z))
3829  x*y*z
3830  """
3831  ctx = _get_ctx(ctx)
3832  if isinstance(names, str):
3833  names = names.split(" ")
3834  return [BitVec(name, bv, ctx) for name in names]
3835 

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

3763 def BitVecSort(sz, ctx=None):
3764  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3765 
3766  >>> Byte = BitVecSort(8)
3767  >>> Word = BitVecSort(16)
3768  >>> Byte
3769  BitVec(8)
3770  >>> x = Const('x', Byte)
3771  >>> eq(x, BitVec('x', 8))
3772  True
3773  """
3774  ctx = _get_ctx(ctx)
3775  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
3776 

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

3777 def BitVecVal(val, bv, ctx=None):
3778  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
3779 
3780  >>> v = BitVecVal(10, 32)
3781  >>> v
3782  10
3783  >>> print("0x%.8x" % v.as_long())
3784  0x0000000a
3785  """
3786  if is_bv_sort(bv):
3787  ctx = bv.ctx
3788  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
3789  else:
3790  ctx = _get_ctx(ctx)
3791  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
3792 

◆ Bool()

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

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

Definition at line 1588 of file z3py.py.

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

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

◆ Bools()

def z3py.Bools (   names,
  ctx = None 
)
Return a tuple of Boolean constants.

`names` is a single string containing all names separated by blank spaces.
If `ctx=None`, then the global context is used.

>>> p, q, r = Bools('p q r')
>>> And(p, Or(q, r))
And(p, Or(q, r))

Definition at line 1599 of file z3py.py.

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

◆ BoolSort()

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

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

Definition at line 1553 of file z3py.py.

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

Referenced by Goal.assert_exprs(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), Bool(), 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 1570 of file z3py.py.

1570 def BoolVal(val, ctx=None):
1571  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1572 
1573  >>> BoolVal(True)
1574  True
1575  >>> is_true(BoolVal(True))
1576  True
1577  >>> is_true(True)
1578  False
1579  >>> is_false(BoolVal(False))
1580  True
1581  """
1582  ctx = _get_ctx(ctx)
1583  if val == False:
1584  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1585  else:
1586  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1587 

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

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

◆ BV2Int()

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

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

Definition at line 3733 of file z3py.py.

3733 def BV2Int(a, is_signed=False):
3734  """Return the Z3 expression BV2Int(a).
3735 
3736  >>> b = BitVec('b', 3)
3737  >>> BV2Int(b).sort()
3738  Int
3739  >>> x = Int('x')
3740  >>> x > BV2Int(b)
3741  x > BV2Int(b)
3742  >>> x > BV2Int(b, is_signed=False)
3743  x > BV2Int(b)
3744  >>> x > BV2Int(b, is_signed=True)
3745  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3746  >>> solve(x > BV2Int(b), b == 1, x < 3)
3747  [x = 2, b = 1]
3748  """
3749  if z3_debug():
3750  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3751  ctx = a.ctx
3752 
3753  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3754 

◆ BVAddNoOverflow()

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

Definition at line 4188 of file z3py.py.

4188 def BVAddNoOverflow(a, b, signed):
4189  """A predicate the determines that bit-vector addition does not overflow"""
4190  _check_bv_args(a, b)
4191  a, b = _coerce_exprs(a, b)
4192  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4193 

◆ BVAddNoUnderflow()

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

Definition at line 4194 of file z3py.py.

4194 def BVAddNoUnderflow(a, b):
4195  """A predicate the determines that signed bit-vector addition does not underflow"""
4196  _check_bv_args(a, b)
4197  a, b = _coerce_exprs(a, b)
4198  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4199 

◆ BVMulNoOverflow()

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

Definition at line 4225 of file z3py.py.

4225 def BVMulNoOverflow(a, b, signed):
4226  """A predicate the determines that bit-vector multiplication does not overflow"""
4227  _check_bv_args(a, b)
4228  a, b = _coerce_exprs(a, b)
4229  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4230 
4231 

◆ BVMulNoUnderflow()

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

Definition at line 4232 of file z3py.py.

4232 def BVMulNoUnderflow(a, b):
4233  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4234  _check_bv_args(a, b)
4235  a, b = _coerce_exprs(a, b)
4236  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4237 
4238 
4239 

◆ BVRedAnd()

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

Definition at line 4176 of file z3py.py.

4176 def BVRedAnd(a):
4177  """Return the reduction-and expression of `a`."""
4178  if z3_debug():
4179  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4180  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4181 

◆ BVRedOr()

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

Definition at line 4182 of file z3py.py.

4182 def BVRedOr(a):
4183  """Return the reduction-or expression of `a`."""
4184  if z3_debug():
4185  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4186  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4187 

◆ BVSDivNoOverflow()

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

Definition at line 4213 of file z3py.py.

4213 def BVSDivNoOverflow(a, b):
4214  """A predicate the determines that bit-vector signed division does not overflow"""
4215  _check_bv_args(a, b)
4216  a, b = _coerce_exprs(a, b)
4217  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4218 

◆ BVSNegNoOverflow()

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

Definition at line 4219 of file z3py.py.

4219 def BVSNegNoOverflow(a):
4220  """A predicate the determines that bit-vector unary negation does not overflow"""
4221  if z3_debug():
4222  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4223  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4224 

◆ BVSubNoOverflow()

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

Definition at line 4200 of file z3py.py.

4200 def BVSubNoOverflow(a, b):
4201  """A predicate the determines that bit-vector subtraction does not overflow"""
4202  _check_bv_args(a, b)
4203  a, b = _coerce_exprs(a, b)
4204  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4205 
4206 

◆ BVSubNoUnderflow()

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

Definition at line 4207 of file z3py.py.

4207 def BVSubNoUnderflow(a, b, signed):
4208  """A predicate the determines that bit-vector subtraction does not underflow"""
4209  _check_bv_args(a, b)
4210  a, b = _coerce_exprs(a, b)
4211  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4212 

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

3195 def Cbrt(a, ctx=None):
3196  """ Return a Z3 expression which represents the cubic root of a.
3197 
3198  >>> x = Real('x')
3199  >>> Cbrt(x)
3200  x**(1/3)
3201  """
3202  if not is_expr(a):
3203  ctx = _get_ctx(ctx)
3204  a = RealVal(a, ctx)
3205  return a ** "1/3"
3206 

◆ Complement()

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

Definition at line 10412 of file z3py.py.

10412 def Complement(re):
10413  """Create the complement regular expression."""
10414  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10415 

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

3836 def Concat(*args):
3837  """Create a Z3 bit-vector concatenation expression.
3838 
3839  >>> v = BitVecVal(1, 4)
3840  >>> Concat(v, v+1, v)
3841  Concat(Concat(1, 1 + 1), 1)
3842  >>> simplify(Concat(v, v+1, v))
3843  289
3844  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
3845  121
3846  """
3847  args = _get_args(args)
3848  sz = len(args)
3849  if z3_debug():
3850  _z3_assert(sz >= 2, "At least two arguments expected.")
3851 
3852  ctx = None
3853  for a in args:
3854  if is_expr(a):
3855  ctx = a.ctx
3856  break
3857  if is_seq(args[0]) or isinstance(args[0], str):
3858  args = [_coerce_seq(s, ctx) for s in args]
3859  if z3_debug():
3860  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
3861  v = (Ast * sz)()
3862  for i in range(sz):
3863  v[i] = args[i].as_ast()
3864  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
3865 
3866  if is_re(args[0]):
3867  if z3_debug():
3868  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
3869  v = (Ast * sz)()
3870  for i in range(sz):
3871  v[i] = args[i].as_ast()
3872  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
3873 
3874  if z3_debug():
3875  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
3876  r = args[0]
3877  for i in range(sz - 1):
3878  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i+1].as_ast()), ctx)
3879  return r
3880 

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

8189 def Cond(p, t1, t2, ctx=None):
8190  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8191 
8192  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8193  """
8194  p = _to_probe(p, ctx)
8195  t1 = _to_tactic(t1, ctx)
8196  t2 = _to_tactic(t2, ctx)
8197  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8198 

Referenced by If().

◆ Const()

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

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

Definition at line 1321 of file z3py.py.

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

Referenced by Consts().

◆ Consts()

def z3py.Consts (   names,
  sort 
)
Create several constants of the given sort.

`names` is a string containing the names of all constants to be created.
Blank spaces separate the names of different constants.

>>> x, y, z = Consts('x y z', IntSort())
>>> x + y + z
x + y + z

Definition at line 1332 of file z3py.py.

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

◆ Contains()

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

Definition at line 10206 of file z3py.py.

10206 def Contains(a, b):
10207  """Check if 'a' contains 'b'
10208  >>> s1 = Contains("abc", "ab")
10209  >>> simplify(s1)
10210  True
10211  >>> s2 = Contains("abc", "bc")
10212  >>> simplify(s2)
10213  True
10214  >>> x, y, z = Strings('x y z')
10215  >>> s3 = Contains(Concat(x,y,z), y)
10216  >>> simplify(s3)
10217  True
10218  """
10219  ctx = _get_ctx2(a, b)
10220  a = _coerce_seq(a, ctx)
10221  b = _coerce_seq(b, ctx)
10222  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10223 
10224 

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

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

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

4460 def Default(a):
4461  """ Return a default value for array expression.
4462  >>> b = K(IntSort(), 1)
4463  >>> prove(Default(b) == 1)
4464  proved
4465  """
4466  if z3_debug():
4467  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4468  return a.default()
4469 
4470 

◆ describe_probes()

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

Definition at line 8119 of file z3py.py.

8119 def describe_probes():
8120  """Display a (tabular) description of all available probes in Z3."""
8121  if in_html_mode():
8122  even = True
8123  print('<table border="1" cellpadding="2" cellspacing="0">')
8124  for p in probes():
8125  if even:
8126  print('<tr style="background-color:#CFCFCF">')
8127  even = False
8128  else:
8129  print('<tr>')
8130  even = True
8131  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8132  print('</table>')
8133  else:
8134  for p in probes():
8135  print('%s : %s' % (p, probe_description(p)))
8136 

◆ describe_tactics()

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

Definition at line 7928 of file z3py.py.

7928 def describe_tactics():
7929  """Display a (tabular) description of all available tactics in Z3."""
7930  if in_html_mode():
7931  even = True
7932  print('<table border="1" cellpadding="2" cellspacing="0">')
7933  for t in tactics():
7934  if even:
7935  print('<tr style="background-color:#CFCFCF">')
7936  even = False
7937  else:
7938  print('<tr>')
7939  even = True
7940  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7941  print('</table>')
7942  else:
7943  for t in tactics():
7944  print('%s : %s' % (t, tactic_description(t)))
7945 

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

5005 def DisjointSum(name, sorts, ctx=None):
5006  """Create a named tagged union sort base on a set of underlying sorts
5007  Example:
5008  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5009  """
5010  sum = Datatype(name, ctx)
5011  for i in range(len(sorts)):
5012  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5013  sum = sum.create()
5014  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5015 
5016 

◆ Distinct()

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

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

Definition at line 1290 of file z3py.py.

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

◆ Empty()

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

Definition at line 10141 of file z3py.py.

10141 def Empty(s):
10142  """Create the empty sequence of the given sort
10143  >>> e = Empty(StringSort())
10144  >>> e2 = StringVal("")
10145  >>> print(e.eq(e2))
10146  True
10147  >>> e3 = Empty(SeqSort(IntSort()))
10148  >>> print(e3)
10149  Empty(Seq(Int))
10150  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10151  >>> print(e4)
10152  Empty(ReSort(Seq(Int)))
10153  """
10154  if isinstance(s, SeqSortRef):
10155  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10156  if isinstance(s, ReSortRef):
10157  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10158  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10159 

◆ EmptySet()

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

Definition at line 4595 of file z3py.py.

4595 def EmptySet(s):
4596  """Create the empty set
4597  >>> EmptySet(IntSort())
4598  K(Int, False)
4599  """
4600  ctx = s.ctx
4601  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4602 

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

5017 def EnumSort(name, values, ctx=None):
5018  """Return a new enumeration sort named `name` containing the given values.
5019 
5020  The result is a pair (sort, list of constants).
5021  Example:
5022  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5023  """
5024  if z3_debug():
5025  _z3_assert(isinstance(name, str), "Name must be a string")
5026  _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5027  _z3_assert(len(values) > 0, "At least one value expected")
5028  ctx = _get_ctx(ctx)
5029  num = len(values)
5030  _val_names = (Symbol * num)()
5031  for i in range(num):
5032  _val_names[i] = to_symbol(values[i])
5033  _values = (FuncDecl * num)()
5034  _testers = (FuncDecl * num)()
5035  name = to_symbol(name)
5036  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5037  V = []
5038  for i in range(num):
5039  V.append(FuncDeclRef(_values[i], ctx))
5040  V = [a() for a in V]
5041  return S, V
5042 

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

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

Referenced by Fixedpoint.abstract().

◆ Ext()

def z3py.Ext (   a,
  b 
)
Return extensionality index for one-dimensional arrays.
>> a, b = Consts('a b', SetSort(IntSort()))
>> Ext(a, b)
Ext(a, b)

Definition at line 4545 of file z3py.py.

4545 def Ext(a, b):
4546  """Return extensionality index for one-dimensional arrays.
4547  >> a, b = Consts('a b', SetSort(IntSort()))
4548  >> Ext(a, b)
4549  Ext(a, b)
4550  """
4551  ctx = a.ctx
4552  if z3_debug():
4553  _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4554  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4555 

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

3881 def Extract(high, low, a):
3882  """Create a Z3 bit-vector extraction expression, or create a string extraction expression.
3883 
3884  >>> x = BitVec('x', 8)
3885  >>> Extract(6, 2, x)
3886  Extract(6, 2, x)
3887  >>> Extract(6, 2, x).sort()
3888  BitVec(5)
3889  >>> simplify(Extract(StringVal("abcd"),2,1))
3890  "c"
3891  """
3892  if isinstance(high, str):
3893  high = StringVal(high)
3894  if is_seq(high):
3895  s = high
3896  offset, length = _coerce_exprs(low, a, s.ctx)
3897  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
3898  if z3_debug():
3899  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
3900  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0, "First and second arguments must be non negative integers")
3901  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
3902  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
3903 

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

8152 def FailIf(p, ctx=None):
8153  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8154 
8155  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8156 
8157  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8158  >>> x, y = Ints('x y')
8159  >>> g = Goal()
8160  >>> g.add(x > 0)
8161  >>> g.add(y > 0)
8162  >>> t(g)
8163  [[x > 0, y > 0]]
8164  >>> g.add(x == y + 1)
8165  >>> t(g)
8166  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8167  """
8168  p = _to_probe(p, ctx)
8169  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8170 

◆ FiniteDomainSort()

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

Definition at line 7244 of file z3py.py.

7244 def FiniteDomainSort(name, sz, ctx=None):
7245  """Create a named finite domain sort of a given size sz"""
7246  if not isinstance(name, Symbol):
7247  name = to_symbol(name)
7248  ctx = _get_ctx(ctx)
7249  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7250 

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

7312 def FiniteDomainVal(val, sort, ctx=None):
7313  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7314 
7315  >>> s = FiniteDomainSort('S', 256)
7316  >>> FiniteDomainVal(255, s)
7317  255
7318  >>> FiniteDomainVal('100', s)
7319  100
7320  """
7321  if z3_debug():
7322  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7323  ctx = sort.ctx
7324  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7325 

◆ Float128()

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

Definition at line 8782 of file z3py.py.

8782 def Float128(ctx=None):
8783  """Floating-point 128-bit (quadruple) sort."""
8784  ctx = _get_ctx(ctx)
8785  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8786 

◆ Float16()

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

Definition at line 8752 of file z3py.py.

8752 def Float16(ctx=None):
8753  """Floating-point 16-bit (half) sort."""
8754  ctx = _get_ctx(ctx)
8755  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8756 

◆ Float32()

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

Definition at line 8762 of file z3py.py.

8762 def Float32(ctx=None):
8763  """Floating-point 32-bit (single) sort."""
8764  ctx = _get_ctx(ctx)
8765  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8766 

◆ Float64()

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

Definition at line 8772 of file z3py.py.

8772 def Float64(ctx=None):
8773  """Floating-point 64-bit (double) sort."""
8774  ctx = _get_ctx(ctx)
8775  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8776 

◆ FloatDouble()

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

Definition at line 8777 of file z3py.py.

8777 def FloatDouble(ctx=None):
8778  """Floating-point 64-bit (double) sort."""
8779  ctx = _get_ctx(ctx)
8780  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8781 

◆ FloatHalf()

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

Definition at line 8757 of file z3py.py.

8757 def FloatHalf(ctx=None):
8758  """Floating-point 16-bit (half) sort."""
8759  ctx = _get_ctx(ctx)
8760  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8761 

◆ FloatQuadruple()

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

Definition at line 8787 of file z3py.py.

8787 def FloatQuadruple(ctx=None):
8788  """Floating-point 128-bit (quadruple) sort."""
8789  ctx = _get_ctx(ctx)
8790  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8791 

◆ FloatSingle()

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

Definition at line 8767 of file z3py.py.

8767 def FloatSingle(ctx=None):
8768  """Floating-point 32-bit (single) sort."""
8769  ctx = _get_ctx(ctx)
8770  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8771 

◆ ForAll()

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

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

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

Definition at line 2065 of file z3py.py.

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

Referenced by Fixedpoint.abstract().

◆ FP()

def z3py.FP (   name,
  fpsort,
  ctx = None 
)
Return a floating-point constant named `name`.
`fpsort` is the floating-point sort.
If `ctx=None`, then the global context is used.

>>> x  = FP('x', FPSort(8, 24))
>>> is_fp(x)
True
>>> x.ebits()
8
>>> x.sort()
FPSort(8, 24)
>>> word = FPSort(8, 24)
>>> x2 = FP('x', word)
>>> eq(x, x2)
True

Definition at line 9367 of file z3py.py.

9367 def FP(name, fpsort, ctx=None):
9368  """Return a floating-point constant named `name`.
9369  `fpsort` is the floating-point sort.
9370  If `ctx=None`, then the global context is used.
9371 
9372  >>> x = FP('x', FPSort(8, 24))
9373  >>> is_fp(x)
9374  True
9375  >>> x.ebits()
9376  8
9377  >>> x.sort()
9378  FPSort(8, 24)
9379  >>> word = FPSort(8, 24)
9380  >>> x2 = FP('x', word)
9381  >>> eq(x, x2)
9382  True
9383  """
9384  if isinstance(fpsort, FPSortRef) and ctx is None:
9385  ctx = fpsort.ctx
9386  else:
9387  ctx = _get_ctx(ctx)
9388  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9389 

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

9408 def fpAbs(a, ctx=None):
9409  """Create a Z3 floating-point absolute value expression.
9410 
9411  >>> s = FPSort(8, 24)
9412  >>> rm = RNE()
9413  >>> x = FPVal(1.0, s)
9414  >>> fpAbs(x)
9415  fpAbs(1)
9416  >>> y = FPVal(-20.0, s)
9417  >>> y
9418  -1.25*(2**4)
9419  >>> fpAbs(y)
9420  fpAbs(-1.25*(2**4))
9421  >>> fpAbs(-1.25*(2**4))
9422  fpAbs(-1.25*(2**4))
9423  >>> fpAbs(x).sort()
9424  FPSort(8, 24)
9425  """
9426  ctx = _get_ctx(ctx)
9427  [a] = _coerce_fp_expr_list([a], ctx)
9428  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
9429 

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

9490 def fpAdd(rm, a, b, ctx=None):
9491  """Create a Z3 floating-point addition expression.
9492 
9493  >>> s = FPSort(8, 24)
9494  >>> rm = RNE()
9495  >>> x = FP('x', s)
9496  >>> y = FP('y', s)
9497  >>> fpAdd(rm, x, y)
9498  fpAdd(RNE(), x, y)
9499  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9500  x + y
9501  >>> fpAdd(rm, x, y).sort()
9502  FPSort(8, 24)
9503  """
9504  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9505 

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

9786 def fpBVToFP(v, sort, ctx=None):
9787  """Create a Z3 floating-point conversion expression that represents the
9788  conversion from a bit-vector term to a floating-point term.
9789 
9790  >>> x_bv = BitVecVal(0x3F800000, 32)
9791  >>> x_fp = fpBVToFP(x_bv, Float32())
9792  >>> x_fp
9793  fpToFP(1065353216)
9794  >>> simplify(x_fp)
9795  1
9796  """
9797  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9798  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9799  ctx = _get_ctx(ctx)
9800  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9801 

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

9534 def fpDiv(rm, a, b, ctx=None):
9535  """Create a Z3 floating-point division expression.
9536 
9537  >>> s = FPSort(8, 24)
9538  >>> rm = RNE()
9539  >>> x = FP('x', s)
9540  >>> y = FP('y', s)
9541  >>> fpDiv(rm, x, y)
9542  fpDiv(RNE(), x, y)
9543  >>> fpDiv(rm, x, y).sort()
9544  FPSort(8, 24)
9545  """
9546  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9547 

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

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

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

9589 def fpFMA(rm, a, b, c, ctx=None):
9590  """Create a Z3 floating-point fused multiply-add expression.
9591  """
9592  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9593 

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

9720 def fpFP(sgn, exp, sig, ctx=None):
9721  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9722 
9723  >>> s = FPSort(8, 24)
9724  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9725  >>> print(x)
9726  fpFP(1, 127, 4194304)
9727  >>> xv = FPVal(-1.5, s)
9728  >>> print(xv)
9729  -1.5
9730  >>> slvr = Solver()
9731  >>> slvr.add(fpEQ(x, xv))
9732  >>> slvr.check()
9733  sat
9734  >>> xv = FPVal(+1.5, s)
9735  >>> print(xv)
9736  1.5
9737  >>> slvr = Solver()
9738  >>> slvr.add(fpEQ(x, xv))
9739  >>> slvr.check()
9740  unsat
9741  """
9742  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9743  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9744  ctx = _get_ctx(ctx)
9745  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9746  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9747 

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

9802 def fpFPToFP(rm, v, sort, ctx=None):
9803  """Create a Z3 floating-point conversion expression that represents the
9804  conversion from a floating-point term to a floating-point term of different precision.
9805 
9806  >>> x_sgl = FPVal(1.0, Float32())
9807  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9808  >>> x_dbl
9809  fpToFP(RNE(), 1)
9810  >>> simplify(x_dbl)
9811  1
9812  >>> x_dbl.sort()
9813  FPSort(11, 53)
9814  """
9815  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9816  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9817  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9818  ctx = _get_ctx(ctx)
9819  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9820 

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

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

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

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

Referenced by FPRef.__gt__().

◆ fpInfinity()

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

Definition at line 9301 of file z3py.py.

9301 def fpInfinity(s, negative):
9302  """Create a Z3 floating-point +oo or -oo term."""
9303  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9304  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9305  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9306 

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

9615 def fpIsInf(a, ctx=None):
9616  """Create a Z3 floating-point isInfinite expression.
9617 
9618  >>> s = FPSort(8, 24)
9619  >>> x = FP('x', s)
9620  >>> fpIsInf(x)
9621  fpIsInf(x)
9622  """
9623  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9624 

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

9604 def fpIsNaN(a, ctx=None):
9605  """Create a Z3 floating-point isNaN expression.
9606 
9607  >>> s = FPSort(8, 24)
9608  >>> x = FP('x', s)
9609  >>> y = FP('y', s)
9610  >>> fpIsNaN(x)
9611  fpIsNaN(x)
9612  """
9613  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9614 

◆ fpIsNegative()

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

Definition at line 9640 of file z3py.py.

9640 def fpIsNegative(a, ctx=None):
9641  """Create a Z3 floating-point isNegative expression.
9642  """
9643  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9644 

◆ fpIsNormal()

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

Definition at line 9630 of file z3py.py.

9630 def fpIsNormal(a, ctx=None):
9631  """Create a Z3 floating-point isNormal expression.
9632  """
9633  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9634 

◆ fpIsPositive()

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

Definition at line 9645 of file z3py.py.

9645 def fpIsPositive(a, ctx=None):
9646  """Create a Z3 floating-point isPositive expression.
9647  """
9648  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9649 

◆ fpIsSubnormal()

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

Definition at line 9635 of file z3py.py.

9635 def fpIsSubnormal(a, ctx=None):
9636  """Create a Z3 floating-point isSubnormal expression.
9637  """
9638  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9639 

◆ fpIsZero()

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

Definition at line 9625 of file z3py.py.

9625 def fpIsZero(a, ctx=None):
9626  """Create a Z3 floating-point isZero expression.
9627  """
9628  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9629 

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

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

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

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

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

9575 def fpMax(a, b, ctx=None):
9576  """Create a Z3 floating-point maximum expression.
9577 
9578  >>> s = FPSort(8, 24)
9579  >>> rm = RNE()
9580  >>> x = FP('x', s)
9581  >>> y = FP('y', s)
9582  >>> fpMax(x, y)
9583  fpMax(x, y)
9584  >>> fpMax(x, y).sort()
9585  FPSort(8, 24)
9586  """
9587  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9588 

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

9561 def fpMin(a, b, ctx=None):
9562  """Create a Z3 floating-point minimum expression.
9563 
9564  >>> s = FPSort(8, 24)
9565  >>> rm = RNE()
9566  >>> x = FP('x', s)
9567  >>> y = FP('y', s)
9568  >>> fpMin(x, y)
9569  fpMin(x, y)
9570  >>> fpMin(x, y).sort()
9571  FPSort(8, 24)
9572  """
9573  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9574 

◆ fpMinusInfinity()

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

Definition at line 9296 of file z3py.py.

9296 def fpMinusInfinity(s):
9297  """Create a Z3 floating-point -oo term."""
9298  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9299  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9300 

Referenced by FPVal().

◆ fpMinusZero()

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

Definition at line 9312 of file z3py.py.

9312 def fpMinusZero(s):
9313  """Create a Z3 floating-point -0.0 term."""
9314  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9315  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9316 

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

9520 def fpMul(rm, a, b, ctx=None):
9521  """Create a Z3 floating-point multiplication expression.
9522 
9523  >>> s = FPSort(8, 24)
9524  >>> rm = RNE()
9525  >>> x = FP('x', s)
9526  >>> y = FP('y', s)
9527  >>> fpMul(rm, x, y)
9528  fpMul(RNE(), x, y)
9529  >>> fpMul(rm, x, y).sort()
9530  FPSort(8, 24)
9531  """
9532  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
9533 

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

9264 def fpNaN(s):
9265  """Create a Z3 floating-point NaN term.
9266 
9267  >>> s = FPSort(8, 24)
9268  >>> set_fpa_pretty(True)
9269  >>> fpNaN(s)
9270  NaN
9271  >>> pb = get_fpa_pretty()
9272  >>> set_fpa_pretty(False)
9273  >>> fpNaN(s)
9274  fpNaN(FPSort(8, 24))
9275  >>> set_fpa_pretty(pb)
9276  """
9277  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9278  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9279 

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

9430 def fpNeg(a, ctx=None):
9431  """Create a Z3 floating-point addition expression.
9432 
9433  >>> s = FPSort(8, 24)
9434  >>> rm = RNE()
9435  >>> x = FP('x', s)
9436  >>> fpNeg(x)
9437  -x
9438  >>> fpNeg(x).sort()
9439  FPSort(8, 24)
9440  """
9441  ctx = _get_ctx(ctx)
9442  [a] = _coerce_fp_expr_list([a], ctx)
9443  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9444 

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

9709 def fpNEQ(a, b, ctx=None):
9710  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9711 
9712  >>> x, y = FPs('x y', FPSort(8, 24))
9713  >>> fpNEQ(x, y)
9714  Not(fpEQ(x, y))
9715  >>> (x != y).sexpr()
9716  '(distinct x y)'
9717  """
9718  return Not(fpEQ(a, b, ctx))
9719 

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

9280 def fpPlusInfinity(s):
9281  """Create a Z3 floating-point +oo term.
9282 
9283  >>> s = FPSort(8, 24)
9284  >>> pb = get_fpa_pretty()
9285  >>> set_fpa_pretty(True)
9286  >>> fpPlusInfinity(s)
9287  +oo
9288  >>> set_fpa_pretty(False)
9289  >>> fpPlusInfinity(s)
9290  fpPlusInfinity(FPSort(8, 24))
9291  >>> set_fpa_pretty(pb)
9292  """
9293  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9294  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9295 

Referenced by FPVal().

◆ fpPlusZero()

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

Definition at line 9307 of file z3py.py.

9307 def fpPlusZero(s):
9308  """Create a Z3 floating-point +0.0 term."""
9309  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9310  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9311 

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

9821 def fpRealToFP(rm, v, sort, ctx=None):
9822  """Create a Z3 floating-point conversion expression that represents the
9823  conversion from a real term to a floating-point term.
9824 
9825  >>> x_r = RealVal(1.5)
9826  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9827  >>> x_fp
9828  fpToFP(RNE(), 3/2)
9829  >>> simplify(x_fp)
9830  1.5
9831  """
9832  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9833  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9834  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9835  ctx = _get_ctx(ctx)
9836  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9837 

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

9548 def fpRem(a, b, ctx=None):
9549  """Create a Z3 floating-point remainder expression.
9550 
9551  >>> s = FPSort(8, 24)
9552  >>> x = FP('x', s)
9553  >>> y = FP('y', s)
9554  >>> fpRem(x, y)
9555  fpRem(x, y)
9556  >>> fpRem(x, y).sort()
9557  FPSort(8, 24)
9558  """
9559  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9560 

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

9599 def fpRoundToIntegral(rm, a, ctx=None):
9600  """Create a Z3 floating-point roundToIntegral expression.
9601  """
9602  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9603 

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

9390 def FPs(names, fpsort, ctx=None):
9391  """Return an array of floating-point constants.
9392 
9393  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9394  >>> x.sort()
9395  FPSort(8, 24)
9396  >>> x.sbits()
9397  24
9398  >>> x.ebits()
9399  8
9400  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9401  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9402  """
9403  ctx = _get_ctx(ctx)
9404  if isinstance(names, str):
9405  names = names.split(" ")
9406  return [FP(name, fpsort, ctx) for name in names]
9407 

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

9838 def fpSignedToFP(rm, v, sort, ctx=None):
9839  """Create a Z3 floating-point conversion expression that represents the
9840  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9841 
9842  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9843  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9844  >>> x_fp
9845  fpToFP(RNE(), 4294967291)
9846  >>> simplify(x_fp)
9847  -1.25*(2**2)
9848  """
9849  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9850  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9851  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9852  ctx = _get_ctx(ctx)
9853  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9854 

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

9206 def FPSort(ebits, sbits, ctx=None):
9207  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9208 
9209  >>> Single = FPSort(8, 24)
9210  >>> Double = FPSort(11, 53)
9211  >>> Single
9212  FPSort(8, 24)
9213  >>> x = Const('x', Single)
9214  >>> eq(x, FP('x', FPSort(8, 24)))
9215  True
9216  """
9217  ctx = _get_ctx(ctx)
9218  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9219 

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

9594 def fpSqrt(rm, a, ctx=None):
9595  """Create a Z3 floating-point square root expression.
9596  """
9597  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9598 

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

9506 def fpSub(rm, a, b, ctx=None):
9507  """Create a Z3 floating-point subtraction expression.
9508 
9509  >>> s = FPSort(8, 24)
9510  >>> rm = RNE()
9511  >>> x = FP('x', s)
9512  >>> y = FP('y', s)
9513  >>> fpSub(rm, x, y)
9514  fpSub(RNE(), x, y)
9515  >>> fpSub(rm, x, y).sort()
9516  FPSort(8, 24)
9517  """
9518  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
9519 

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

9748 def fpToFP(a1, a2=None, a3=None, ctx=None):
9749  """Create a Z3 floating-point conversion expression from other term sorts
9750  to floating-point.
9751 
9752  From a bit-vector term in IEEE 754-2008 format:
9753  >>> x = FPVal(1.0, Float32())
9754  >>> x_bv = fpToIEEEBV(x)
9755  >>> simplify(fpToFP(x_bv, Float32()))
9756  1
9757 
9758  From a floating-point term with different precision:
9759  >>> x = FPVal(1.0, Float32())
9760  >>> x_db = fpToFP(RNE(), x, Float64())
9761  >>> x_db.sort()
9762  FPSort(11, 53)
9763 
9764  From a real term:
9765  >>> x_r = RealVal(1.5)
9766  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9767  1.5
9768 
9769  From a signed bit-vector term:
9770  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9771  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9772  -1.25*(2**2)
9773  """
9774  ctx = _get_ctx(ctx)
9775  if is_bv(a1) and is_fp_sort(a2):
9776  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9777  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9778  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9779  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9780  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9781  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9782  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9783  else:
9784  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9785 

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

9872 def fpToFPUnsigned(rm, x, s, ctx=None):
9873  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9874  if z3_debug():
9875  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9876  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9877  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9878  ctx = _get_ctx(ctx)
9879  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9880 

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

9942 def fpToIEEEBV(x, ctx=None):
9943  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9944 
9945  The size of the resulting bit-vector is automatically determined.
9946 
9947  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9948  knows only one NaN and it will always produce the same bit-vector representation of
9949  that NaN.
9950 
9951  >>> x = FP('x', FPSort(8, 24))
9952  >>> y = fpToIEEEBV(x)
9953  >>> print(is_fp(x))
9954  True
9955  >>> print(is_bv(y))
9956  True
9957  >>> print(is_fp(y))
9958  False
9959  >>> print(is_bv(x))
9960  False
9961  """
9962  if z3_debug():
9963  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9964  ctx = _get_ctx(ctx)
9965  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
9966 
9967 
9968 

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

9923 def fpToReal(x, ctx=None):
9924  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9925 
9926  >>> x = FP('x', FPSort(8, 24))
9927  >>> y = fpToReal(x)
9928  >>> print(is_fp(x))
9929  True
9930  >>> print(is_real(y))
9931  True
9932  >>> print(is_fp(y))
9933  False
9934  >>> print(is_real(x))
9935  False
9936  """
9937  if z3_debug():
9938  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9939  ctx = _get_ctx(ctx)
9940  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9941 

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

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

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

9902 def fpToUBV(rm, x, s, ctx=None):
9903  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9904 
9905  >>> x = FP('x', FPSort(8, 24))
9906  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9907  >>> print(is_fp(x))
9908  True
9909  >>> print(is_bv(y))
9910  True
9911  >>> print(is_fp(y))
9912  False
9913  >>> print(is_bv(x))
9914  False
9915  """
9916  if z3_debug():
9917  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9918  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9919  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9920  ctx = _get_ctx(ctx)
9921  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9922 

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

9855 def fpUnsignedToFP(rm, v, sort, ctx=None):
9856  """Create a Z3 floating-point conversion expression that represents the
9857  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9858 
9859  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9860  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9861  >>> x_fp
9862  fpToFPUnsigned(RNE(), 4294967291)
9863  >>> simplify(x_fp)
9864  1*(2**32)
9865  """
9866  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9867  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9868  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9869  ctx = _get_ctx(ctx)
9870  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9871 

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

9323 def FPVal(sig, exp=None, fps=None, ctx=None):
9324  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9325 
9326  >>> v = FPVal(20.0, FPSort(8, 24))
9327  >>> v
9328  1.25*(2**4)
9329  >>> print("0x%.8x" % v.exponent_as_long(False))
9330  0x00000004
9331  >>> v = FPVal(2.25, FPSort(8, 24))
9332  >>> v
9333  1.125*(2**1)
9334  >>> v = FPVal(-2.25, FPSort(8, 24))
9335  >>> v
9336  -1.125*(2**1)
9337  >>> FPVal(-0.0, FPSort(8, 24))
9338  -0.0
9339  >>> FPVal(0.0, FPSort(8, 24))
9340  +0.0
9341  >>> FPVal(+0.0, FPSort(8, 24))
9342  +0.0
9343  """
9344  ctx = _get_ctx(ctx)
9345  if is_fp_sort(exp):
9346  fps = exp
9347  exp = None
9348  elif fps is None:
9349  fps = _dflt_fps(ctx)
9350  _z3_assert(is_fp_sort(fps), "sort mismatch")
9351  if exp is None:
9352  exp = 0
9353  val = _to_float_str(sig)
9354  if val == "NaN" or val == "nan":
9355  return fpNaN(fps)
9356  elif val == "-0.0":
9357  return fpMinusZero(fps)
9358  elif val == "0.0" or val == "+0.0":
9359  return fpPlusZero(fps)
9360  elif val == "+oo" or val == "+inf" or val == "+Inf":
9361  return fpPlusInfinity(fps)
9362  elif val == "-oo" or val == "-inf" or val == "-Inf":
9363  return fpMinusInfinity(fps)
9364  else:
9365  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9366 

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

9317 def fpZero(s, negative):
9318  """Create a Z3 floating-point +0.0 or -0.0 term."""
9319  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9320  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9321  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9322 

◆ FreshBool()

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

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

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

Definition at line 1628 of file z3py.py.

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

◆ FreshConst()

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

Definition at line 1346 of file z3py.py.

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

◆ FreshFunction()

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

Definition at line 821 of file z3py.py.

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

◆ FreshInt()

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

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

Definition at line 3067 of file z3py.py.

3067 def FreshInt(prefix='x', ctx=None):
3068  """Return a fresh integer constant in the given context using the given prefix.
3069 
3070  >>> x = FreshInt()
3071  >>> y = FreshInt()
3072  >>> eq(x, y)
3073  False
3074  >>> x.sort()
3075  Int
3076  """
3077  ctx = _get_ctx(ctx)
3078  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3079 

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

3120 def FreshReal(prefix='b', ctx=None):
3121  """Return a fresh real constant in the given context using the given prefix.
3122 
3123  >>> x = FreshReal()
3124  >>> y = FreshReal()
3125  >>> eq(x, y)
3126  False
3127  >>> x.sort()
3128  Real
3129  """
3130  ctx = _get_ctx(ctx)
3131  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3132 

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

10160 def Full(s):
10161  """Create the regular expression that accepts the universal language
10162  >>> e = Full(ReSort(SeqSort(IntSort())))
10163  >>> print(e)
10164  Full(ReSort(Seq(Int)))
10165  >>> e1 = Full(ReSort(StringSort()))
10166  >>> print(e1)
10167  Full(ReSort(String))
10168  """
10169  if isinstance(s, ReSortRef):
10170  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10171  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10172 
10173 

◆ FullSet()

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

Definition at line 4603 of file z3py.py.

4603 def FullSet(s):
4604  """Create the full set
4605  >>> FullSet(IntSort())
4606  K(Int, True)
4607  """
4608  ctx = s.ctx
4609  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4610 

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

6267 def get_as_array_func(n):
6268  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6269  if z3_debug():
6270  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6271  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6272 

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

8676 def get_default_fp_sort(ctx=None):
8677  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8678 

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

8649 def get_default_rounding_mode(ctx=None):
8650  """Retrieves the global default rounding mode."""
8651  global _dflt_rounding_mode
8652  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8653  return RTZ(ctx)
8654  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8655  return RTN(ctx)
8656  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8657  return RTP(ctx)
8658  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8659  return RNE(ctx)
8660  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8661  return RNA(ctx)
8662 

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

4377 def get_map_func(a):
4378  """Return the function declaration associated with a Z3 map array expression.
4379 
4380  >>> f = Function('f', IntSort(), IntSort())
4381  >>> b = Array('b', IntSort(), IntSort())
4382  >>> a = Map(f, b)
4383  >>> eq(f, get_map_func(a))
4384  True
4385  >>> get_map_func(a)
4386  f
4387  >>> get_map_func(a)(0)
4388  f(0)
4389  """
4390  if z3_debug():
4391  _z3_assert(is_map(a), "Z3 array map expression expected.")
4392  return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4393 

◆ get_param()

def z3py.get_param (   name)
Return the value of a Z3 global (or module) parameter

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

Definition at line 273 of file z3py.py.

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

◆ get_var_index()

def z3py.get_var_index (   a)
Return the de-Bruijn index of the Z3 bounded variable `a`.

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

Definition at line 1224 of file z3py.py.

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

◆ get_version()

def z3py.get_version ( )

Definition at line 81 of file z3py.py.

81 def get_version():
82  major = ctypes.c_uint(0)
83  minor = ctypes.c_uint(0)
84  build = ctypes.c_uint(0)
85  rev = ctypes.c_uint(0)
86  Z3_get_version(major, minor, build, rev)
87  return (major.value, minor.value, build.value, rev.value)
88 

◆ get_version_string()

def z3py.get_version_string ( )

Definition at line 73 of file z3py.py.

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

◆ help_simplify()

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

Definition at line 8229 of file z3py.py.

8229 def help_simplify():
8230  """Return a string describing all options available for Z3 `simplify` procedure."""
8231  print(Z3_simplify_get_help(main_ctx().ref()))
8232 

◆ If()

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

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

Definition at line 1268 of file z3py.py.

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

Referenced by BoolRef.__mul__(), and ArithRef.__mul__().

◆ Implies()

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

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

Definition at line 1641 of file z3py.py.

1641 def Implies(a, b, ctx=None):
1642  """Create a Z3 implies expression.
1643 
1644  >>> p, q = Bools('p q')
1645  >>> Implies(p, q)
1646  Implies(p, q)
1647  """
1648  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1649  s = BoolSort(ctx)
1650  a = s.cast(a)
1651  b = s.cast(b)
1652  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1653 

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

◆ IndexOf() [1/2]

def z3py.IndexOf (   s,
  substr 
)

Definition at line 10239 of file z3py.py.

10239 def IndexOf(s, substr):
10240  return IndexOf(s, substr, IntVal(0))
10241 

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

10242 def IndexOf(s, substr, offset):
10243  """Retrieve the index of substring within a string starting at a specified offset.
10244  >>> simplify(IndexOf("abcabc", "bc", 0))
10245  1
10246  >>> simplify(IndexOf("abcabc", "bc", 2))
10247  4
10248  """
10249  ctx = None
10250  if is_expr(offset):
10251  ctx = offset.ctx
10252  ctx = _get_ctx2(s, substr, ctx)
10253  s = _coerce_seq(s, ctx)
10254  substr = _coerce_seq(substr, ctx)
10255  if _is_int(offset):
10256  offset = IntVal(offset, ctx)
10257  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10258 

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

10339 def InRe(s, re):
10340  """Create regular expression membership test
10341  >>> re = Union(Re("a"),Re("b"))
10342  >>> print (simplify(InRe("a", re)))
10343  True
10344  >>> print (simplify(InRe("b", re)))
10345  True
10346  >>> print (simplify(InRe("c", re)))
10347  False
10348  """
10349  s = _coerce_seq(s, re.ctx)
10350  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10351 

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

3031 def Int(name, ctx=None):
3032  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3033 
3034  >>> x = Int('x')
3035  >>> is_int(x)
3036  True
3037  >>> is_int(x + 1)
3038  True
3039  """
3040  ctx = _get_ctx(ctx)
3041  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3042 

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

3755 def Int2BV(a, num_bits):
3756  """Return the z3 expression Int2BV(a, num_bits).
3757  It is a bit-vector of width num_bits and represents the
3758  modulo of a by 2^num_bits
3759  """
3760  ctx = a.ctx
3761  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3762 

◆ Intersect()

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

Definition at line 10371 of file z3py.py.

10371 def Intersect(*args):
10372  """Create intersection of regular expressions.
10373  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10374  """
10375  args = _get_args(args)
10376  sz = len(args)
10377  if z3_debug():
10378  _z3_assert(sz > 0, "At least one argument expected.")
10379  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10380  if sz == 1:
10381  return args[0]
10382  ctx = args[0].ctx
10383  v = (Ast * sz)()
10384  for i in range(sz):
10385  v[i] = args[i].as_ast()
10386  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10387 

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

3043 def Ints(names, ctx=None):
3044  """Return a tuple of Integer constants.
3045 
3046  >>> x, y, z = Ints('x y z')
3047  >>> Sum(x, y, z)
3048  x + y + z
3049  """
3050  ctx = _get_ctx(ctx)
3051  if isinstance(names, str):
3052  names = names.split(" ")
3053  return [Int(name, ctx) for name in names]
3054 

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

2928 def IntSort(ctx=None):
2929  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2930 
2931  >>> IntSort()
2932  Int
2933  >>> x = Const('x', IntSort())
2934  >>> is_int(x)
2935  True
2936  >>> x.sort() == IntSort()
2937  True
2938  >>> x.sort() == BoolSort()
2939  False
2940  """
2941  ctx = _get_ctx(ctx)
2942  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2943 

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

◆ IntToStr()

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

Definition at line 10293 of file z3py.py.

10293 def IntToStr(s):
10294  """Convert integer expression to string"""
10295  if not is_expr(s):
10296  s = _py2expr(s)
10297  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10298 
10299 

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

2975 def IntVal(val, ctx=None):
2976  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
2977 
2978  >>> IntVal(1)
2979  1
2980  >>> IntVal("100")
2981  100
2982  """
2983  ctx = _get_ctx(ctx)
2984  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
2985 

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

3055 def IntVector(prefix, sz, ctx=None):
3056  """Return a list of integer constants of size `sz`.
3057 
3058  >>> X = IntVector('x', 3)
3059  >>> X
3060  [x__0, x__1, x__2]
3061  >>> Sum(X)
3062  x__0 + x__1 + x__2
3063  """
3064  ctx = _get_ctx(ctx)
3065  return [ Int('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3066 

◆ is_add()

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

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

Definition at line 2617 of file z3py.py.

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

◆ is_algebraic_value()

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

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

Definition at line 2604 of file z3py.py.

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

◆ is_and()

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

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

Definition at line 1489 of file z3py.py.

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

◆ is_app()

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

Note that, constants are function applications with 0 arguments.

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

Definition at line 1157 of file z3py.py.

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

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

◆ is_app_of()

def z3py.is_app_of (   a,
  k 
)
Return `True` if `a` is an application of the given kind `k`.

>>> x = Int('x')
>>> n = x + 1
>>> is_app_of(n, Z3_OP_ADD)
True
>>> is_app_of(n, Z3_OP_MUL)
False

Definition at line 1256 of file z3py.py.

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

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

◆ is_arith()

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

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

Definition at line 2498 of file z3py.py.

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

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

◆ is_arith_sort()

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

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

Definition at line 2199 of file z3py.py.

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

Referenced by ArithSortRef.subsort().

◆ is_array()

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

>>> a = Array('a', IntSort(), IntSort())
>>> is_array(a)
True
>>> is_array(Store(a, 0, 1))
True
>>> is_array(a[0])
False

Definition at line 4317 of file z3py.py.

4317 def is_array(a):
4318  """Return `True` if `a` is a Z3 array expression.
4319 
4320  >>> a = Array('a', IntSort(), IntSort())
4321  >>> is_array(a)
4322  True
4323  >>> is_array(Store(a, 0, 1))
4324  True
4325  >>> is_array(a[0])
4326  False
4327  """
4328  return isinstance(a, ArrayRef)
4329 

Referenced by Ext(), and Map().

◆ is_array_sort()

def z3py.is_array_sort (   a)

Definition at line 4313 of file z3py.py.

4313 def is_array_sort(a):
4314  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4315 
4316 

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

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

Referenced by get_as_array_func(), and ModelRef.get_interp().

◆ is_ast()

def z3py.is_ast (   a)
Return `True` if `a` is an AST node.

>>> is_ast(10)
False
>>> is_ast(IntVal(10))
True
>>> is_ast(Int('x'))
True
>>> is_ast(BoolSort())
True
>>> is_ast(Function('f', IntSort(), IntSort()))
True
>>> is_ast("x")
False
>>> is_ast(Solver())
False

Definition at line 412 of file z3py.py.

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

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

◆ is_bool()

def z3py.is_bool (   a)
Return `True` if `a` is a Z3 Boolean expression.

>>> p = Bool('p')
>>> is_bool(p)
True
>>> q = Bool('q')
>>> is_bool(And(p, q))
True
>>> x = Real('x')
>>> is_bool(x)
False
>>> is_bool(x == 0)
True

Definition at line 1442 of file z3py.py.

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

Referenced by is_quantifier(), and prove().

◆ is_bv()

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

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

Definition at line 3706 of file z3py.py.

3706 def is_bv(a):
3707  """Return `True` if `a` is a Z3 bit-vector expression.
3708 
3709  >>> b = BitVec('b', 32)
3710  >>> is_bv(b)
3711  True
3712  >>> is_bv(b + 10)
3713  True
3714  >>> is_bv(Int('x'))
3715  False
3716  """
3717  return isinstance(a, BitVecRef)
3718 

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

3245 def is_bv_sort(s):
3246  """Return True if `s` is a Z3 bit-vector sort.
3247 
3248  >>> is_bv_sort(BitVecSort(32))
3249  True
3250  >>> is_bv_sort(IntSort())
3251  False
3252  """
3253  return isinstance(s, BitVecSortRef)
3254 

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

3719 def is_bv_value(a):
3720  """Return `True` if `a` is a Z3 bit-vector numeral value.
3721 
3722  >>> b = BitVec('b', 32)
3723  >>> is_bv_value(b)
3724  False
3725  >>> b = BitVecVal(10, 32)
3726  >>> b
3727  10
3728  >>> is_bv_value(b)
3729  True
3730  """
3731  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3732 

◆ is_const()

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

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

Definition at line 1182 of file z3py.py.

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

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

◆ is_const_array()

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

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

Definition at line 4330 of file z3py.py.

4330 def is_const_array(a):
4331  """Return `True` if `a` is a Z3 constant array.
4332 
4333  >>> a = K(IntSort(), 10)
4334  >>> is_const_array(a)
4335  True
4336  >>> a = Array('a', IntSort(), IntSort())
4337  >>> is_const_array(a)
4338  False
4339  """
4340  return is_app_of(a, Z3_OP_CONST_ARRAY)
4341 

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

4369 def is_default(a):
4370  """Return `True` if `a` is a Z3 default array expression.
4371  >>> d = Default(K(IntSort(), 10))
4372  >>> is_default(d)
4373  True
4374  """
4375  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4376 

◆ is_distinct()

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

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

Definition at line 1542 of file z3py.py.

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

◆ is_div()

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

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

Definition at line 2650 of file z3py.py.

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

◆ is_eq()

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

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

Definition at line 1533 of file z3py.py.

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

Referenced by AstRef.__bool__().

◆ is_expr()

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

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

Definition at line 1135 of file z3py.py.

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

Referenced by SeqRef.__gt__(), 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 1476 of file z3py.py.

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

Referenced by AstRef.__bool__().

◆ is_finite_domain()

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

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

Definition at line 7273 of file z3py.py.

7273 def is_finite_domain(a):
7274  """Return `True` if `a` is a Z3 finite-domain expression.
7275 
7276  >>> s = FiniteDomainSort('S', 100)
7277  >>> b = Const('b', s)
7278  >>> is_finite_domain(b)
7279  True
7280  >>> is_finite_domain(Int('x'))
7281  False
7282  """
7283  return isinstance(a, FiniteDomainRef)
7284 
7285 

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

7251 def is_finite_domain_sort(s):
7252  """Return True if `s` is a Z3 finite-domain sort.
7253 
7254  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7255  True
7256  >>> is_finite_domain_sort(IntSort())
7257  False
7258  """
7259  return isinstance(s, FiniteDomainSortRef)
7260 
7261 

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

7326 def is_finite_domain_value(a):
7327  """Return `True` if `a` is a Z3 finite-domain value.
7328 
7329  >>> s = FiniteDomainSort('S', 100)
7330  >>> b = Const('b', s)
7331  >>> is_finite_domain_value(b)
7332  False
7333  >>> b = FiniteDomainVal(10, s)
7334  >>> b
7335  10
7336  >>> is_finite_domain_value(b)
7337  True
7338  """
7339  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7340 
7341 

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

9179 def is_fp(a):
9180  """Return `True` if `a` is a Z3 floating-point expression.
9181 
9182  >>> b = FP('b', FPSort(8, 24))
9183  >>> is_fp(b)
9184  True
9185  >>> is_fp(b + 1.0)
9186  True
9187  >>> is_fp(Int('x'))
9188  False
9189  """
9190  return isinstance(a, FPRef)
9191 

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

8796 def is_fp_sort(s):
8797  """Return True if `s` is a Z3 floating-point sort.
8798 
8799  >>> is_fp_sort(FPSort(8, 24))
8800  True
8801  >>> is_fp_sort(IntSort())
8802  False
8803  """
8804  return isinstance(s, FPSortRef)
8805 

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

9192 def is_fp_value(a):
9193  """Return `True` if `a` is a Z3 floating-point numeral value.
9194 
9195  >>> b = FP('b', FPSort(8, 24))
9196  >>> is_fp_value(b)
9197  False
9198  >>> b = FPVal(1.0, FPSort(8, 24))
9199  >>> b
9200  1
9201  >>> is_fp_value(b)
9202  True
9203  """
9204  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9205 

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

9043 def is_fprm(a):
9044  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9045 
9046  >>> rm = RNE()
9047  >>> is_fprm(rm)
9048  True
9049  >>> rm = 1.0
9050  >>> is_fprm(rm)
9051  False
9052  """
9053  return isinstance(a, FPRMRef)
9054 

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

8806 def is_fprm_sort(s):
8807  """Return True if `s` is a Z3 floating-point rounding mode sort.
8808 
8809  >>> is_fprm_sort(FPSort(8, 24))
8810  False
8811  >>> is_fprm_sort(RNE().sort())
8812  True
8813  """
8814  return isinstance(s, FPRMSortRef)
8815 

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

9055 def is_fprm_value(a):
9056  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9057  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9058 

Referenced by set_default_rounding_mode().

◆ is_func_decl()

def z3py.is_func_decl (   a)
Return `True` if `a` is a Z3 function declaration.

>>> f = Function('f', IntSort(), IntSort())
>>> is_func_decl(f)
True
>>> x = Real('x')
>>> is_func_decl(x)
False

Definition at line 787 of file z3py.py.

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

Referenced by Map(), and prove().

◆ is_ge()

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

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

Definition at line 2710 of file z3py.py.

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

◆ is_gt()

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

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

Definition at line 2721 of file z3py.py.

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

◆ is_idiv()

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

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

Definition at line 2666 of file z3py.py.

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

◆ is_implies()

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

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

Definition at line 1511 of file z3py.py.

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

◆ is_int()

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

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

Definition at line 2518 of file z3py.py.

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

◆ is_int_value()

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

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

Definition at line 2560 of file z3py.py.

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

◆ is_is_int()

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

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

Definition at line 2732 of file z3py.py.

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

◆ is_K()

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

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

Definition at line 4342 of file z3py.py.

4342 def is_K(a):
4343  """Return `True` if `a` is a Z3 constant array.
4344 
4345  >>> a = K(IntSort(), 10)
4346  >>> is_K(a)
4347  True
4348  >>> a = Array('a', IntSort(), IntSort())
4349  >>> is_K(a)
4350  False
4351  """
4352  return is_app_of(a, Z3_OP_CONST_ARRAY)
4353 

◆ is_le()

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

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

Definition at line 2688 of file z3py.py.

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

◆ is_lt()

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

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

Definition at line 2699 of file z3py.py.

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

◆ is_map()

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

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

Definition at line 4354 of file z3py.py.

4354 def is_map(a):
4355  """Return `True` if `a` is a Z3 map array expression.
4356 
4357  >>> f = Function('f', IntSort(), IntSort())
4358  >>> b = Array('b', IntSort(), IntSort())
4359  >>> a = Map(f, b)
4360  >>> a
4361  Map(f, b)
4362  >>> is_map(a)
4363  True
4364  >>> is_map(b)
4365  False
4366  """
4367  return is_app_of(a, Z3_OP_ARRAY_MAP)
4368 

Referenced by get_map_func().

◆ is_mod()

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

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

Definition at line 2677 of file z3py.py.

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

◆ is_mul()

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

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

Definition at line 2628 of file z3py.py.

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

◆ is_not()

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

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

Definition at line 1522 of file z3py.py.

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

Referenced by mk_not().

◆ is_or()

def z3py.is_or (   a)
Return `True` if `a` is a Z3 or expression.

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

Definition at line 1500 of file z3py.py.

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

◆ is_pattern()

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

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

Definition at line 1780 of file z3py.py.

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

Referenced by is_quantifier(), and MultiPattern().

◆ is_probe()

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

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

Definition at line 8085 of file z3py.py.

8085 def is_probe(p):
8086  """Return `True` if `p` is a Z3 probe.
8087 
8088  >>> is_probe(Int('x'))
8089  False
8090  >>> is_probe(Probe('memory'))
8091  True
8092  """
8093  return isinstance(p, Probe)
8094 

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

◆ is_quantifier()

def z3py.is_quantifier (   a)
Return `True` if `a` is a Z3 quantifier.

>>> f = Function('f', IntSort(), IntSort())
>>> x = Int('x')
>>> q = ForAll(x, f(x) == 0)
>>> is_quantifier(q)
True
>>> is_quantifier(f(x))
False

Definition at line 2018 of file z3py.py.

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

◆ is_rational_value()

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

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

Definition at line 2583 of file z3py.py.

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

◆ is_re()

def z3py.is_re (   s)

Definition at line 10335 of file z3py.py.

10335 def is_re(s):
10336  return isinstance(s, ReRef)
10337 
10338 

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

◆ is_real()

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

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

Definition at line 2536 of file z3py.py.

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

Referenced by fpRealToFP(), and fpToFP().

◆ is_select()

def z3py.is_select (   a)
Return `True` if `a` is a Z3 array select application.

>>> a = Array('a', IntSort(), IntSort())
>>> is_select(a)
False
>>> i = Int('i')
>>> is_select(a[i])
True

Definition at line 4561 of file z3py.py.

4561 def is_select(a):
4562  """Return `True` if `a` is a Z3 array select application.
4563 
4564  >>> a = Array('a', IntSort(), IntSort())
4565  >>> is_select(a)
4566  False
4567  >>> i = Int('i')
4568  >>> is_select(a[i])
4569  True
4570  """
4571  return is_app_of(a, Z3_OP_SELECT)
4572 

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

10080 def is_seq(a):
10081  """Return `True` if `a` is a Z3 sequence expression.
10082  >>> print (is_seq(Unit(IntVal(0))))
10083  True
10084  >>> print (is_seq(StringVal("abc")))
10085  True
10086  """
10087  return isinstance(a, SeqRef)
10088 

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

◆ is_sort()

def z3py.is_sort (   s)
Return `True` if `s` is a Z3 sort.

>>> is_sort(IntSort())
True
>>> is_sort(Int('x'))
False
>>> is_expr(Int('x'))
True

Definition at line 596 of file z3py.py.

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

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

◆ is_store()

def z3py.is_store (   a)
Return `True` if `a` is a Z3 array store application.

>>> a = Array('a', IntSort(), IntSort())
>>> is_store(a)
False
>>> is_store(Store(a, 0, 1))
True

Definition at line 4573 of file z3py.py.

4573 def is_store(a):
4574  """Return `True` if `a` is a Z3 array store application.
4575 
4576  >>> a = Array('a', IntSort(), IntSort())
4577  >>> is_store(a)
4578  False
4579  >>> is_store(Store(a, 0, 1))
4580  True
4581  """
4582  return is_app_of(a, Z3_OP_STORE)
4583 

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

10089 def is_string(a):
10090  """Return `True` if `a` is a Z3 string expression.
10091  >>> print (is_string(StringVal("ab")))
10092  True
10093  """
10094  return isinstance(a, SeqRef) and a.is_string()
10095 

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

10096 def is_string_value(a):
10097  """return 'True' if 'a' is a Z3 string constant expression.
10098  >>> print (is_string_value(StringVal("a")))
10099  True
10100  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10101  False
10102  """
10103  return isinstance(a, SeqRef) and a.is_string_value()
10104 
10105 

◆ is_sub()

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

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

Definition at line 2639 of file z3py.py.

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

◆ is_to_int()

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

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

Definition at line 2757 of file z3py.py.

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

◆ is_to_real()

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

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

Definition at line 2743 of file z3py.py.

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

◆ is_true()

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

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

Definition at line 1459 of file z3py.py.

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

Referenced by AstRef.__bool__().

◆ is_var()

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

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

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

Definition at line 1200 of file z3py.py.

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

Referenced by get_var_index().

◆ IsInt()

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

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

Definition at line 3167 of file z3py.py.

3167 def IsInt(a):
3168  """ Return the Z3 predicate IsInt(a).
3169 
3170  >>> x = Real('x')
3171  >>> IsInt(x + "1/2")
3172  IsInt(x + 1/2)
3173  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3174  [x = 1/2]
3175  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3176  no solution
3177  """
3178  if z3_debug():
3179  _z3_assert(a.is_real(), "Z3 real expression expected.")
3180  ctx = a.ctx
3181  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3182 

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

4674 def IsMember(e, s):
4675  """ Check if e is a member of set s
4676  >>> a = Const('a', SetSort(IntSort()))
4677  >>> IsMember(1, a)
4678  a[1]
4679  """
4680  ctx = _ctx_from_ast_arg_list([s,e])
4681  e = _py2expr(e, ctx)
4682  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4683 

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

4684 def IsSubset(a, b):
4685  """ Check if a is a subset of b
4686  >>> a = Const('a', SetSort(IntSort()))
4687  >>> b = Const('b', SetSort(IntSort()))
4688  >>> IsSubset(a, b)
4689  subset(a, b)
4690  """
4691  ctx = _ctx_from_ast_arg_list([a, b])
4692  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4693 
4694 

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

4524 def K(dom, v):
4525  """Return a Z3 constant array expression.
4526 
4527  >>> a = K(IntSort(), 10)
4528  >>> a
4529  K(Int, 10)
4530  >>> a.sort()
4531  Array(Int, Int)
4532  >>> i = Int('i')
4533  >>> a[i]
4534  K(Int, 10)[i]
4535  >>> simplify(a[i])
4536  10
4537  """
4538  if z3_debug():
4539  _z3_assert(is_sort(dom), "Z3 sort expected")
4540  ctx = dom.ctx
4541  if not is_expr(v):
4542  v = _py2expr(v, ctx)
4543  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4544 

◆ Lambda()

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

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

Definition at line 2102 of file z3py.py.

2102 def Lambda(vs, body):
2103  """Create a Z3 lambda expression.
2104 
2105  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2106  >>> mem0 = Array('mem0', IntSort(), IntSort())
2107  >>> lo, hi, e, i = Ints('lo hi e i')
2108  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2109  >>> mem1
2110  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2111  """
2112  ctx = body.ctx
2113  if is_app(vs):
2114  vs = [vs]
2115  num_vars = len(vs)
2116  _vs = (Ast * num_vars)()
2117  for i in range(num_vars):
2118 
2119  _vs[i] = vs[i].as_ast()
2120  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2121 

◆ LastIndexOf()

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

Definition at line 10259 of file z3py.py.

10259 def LastIndexOf(s, substr):
10260  """Retrieve the last index of substring within a string"""
10261  ctx = None
10262  ctx = _get_ctx2(s, substr, ctx)
10263  s = _coerce_seq(s, ctx)
10264  substr = _coerce_seq(substr, ctx)
10265  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10266 
10267 

◆ Length()

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

Definition at line 10268 of file z3py.py.

10268 def Length(s):
10269  """Obtain the length of a sequence 's'
10270  >>> l = Length(StringVal("abc"))
10271  >>> simplify(l)
10272  3
10273  """
10274  s = _coerce_seq(s)
10275  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10276 

◆ LinearOrder()

def z3py.LinearOrder (   a,
  index 
)

Definition at line 10457 of file z3py.py.

10457 def LinearOrder(a, index):
10458  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10459 

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

10428 def Loop(re, lo, hi=0):
10429  """Create the regular expression accepting between a lower and upper bound repetitions
10430  >>> re = Loop(Re("a"), 1, 3)
10431  >>> print(simplify(InRe("aa", re)))
10432  True
10433  >>> print(simplify(InRe("aaaa", re)))
10434  False
10435  >>> print(simplify(InRe("", re)))
10436  False
10437  """
10438  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10439 

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

4036 def LShR(a, b):
4037  """Create the Z3 expression logical right shift.
4038 
4039  Use the operator >> for the arithmetical right shift.
4040 
4041  >>> x, y = BitVecs('x y', 32)
4042  >>> LShR(x, y)
4043  LShR(x, y)
4044  >>> (x >> y).sexpr()
4045  '(bvashr x y)'
4046  >>> LShR(x, y).sexpr()
4047  '(bvlshr x y)'
4048  >>> BitVecVal(4, 3)
4049  4
4050  >>> BitVecVal(4, 3).as_signed_long()
4051  -4
4052  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4053  -2
4054  >>> simplify(BitVecVal(4, 3) >> 1)
4055  6
4056  >>> simplify(LShR(BitVecVal(4, 3), 1))
4057  2
4058  >>> simplify(BitVecVal(2, 3) >> 1)
4059  1
4060  >>> simplify(LShR(BitVecVal(2, 3), 1))
4061  1
4062  """
4063  _check_bv_args(a, b)
4064  a, b = _coerce_exprs(a, b)
4065  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4066 

◆ main_ctx()

def z3py.main_ctx ( )
Return a reference to the global Z3 context.

>>> x = Real('x')
>>> x.ctx == main_ctx()
True
>>> c = Context()
>>> c == main_ctx()
False
>>> x2 = Real('x', c)
>>> x2.ctx == c
True
>>> eq(x, x2)
False

Definition at line 211 of file z3py.py.

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

Referenced by SeqRef.__gt__(), help_simplify(), and simplify_param_descrs().

◆ Map()

def z3py.Map (   f,
args 
)
Return a Z3 map array expression.

>>> f = Function('f', IntSort(), IntSort(), IntSort())
>>> a1 = Array('a1', IntSort(), IntSort())
>>> a2 = Array('a2', IntSort(), IntSort())
>>> b  = Map(f, a1, a2)
>>> b
Map(f, a1, a2)
>>> prove(b[0] == f(a1[0], a2[0]))
proved

Definition at line 4502 of file z3py.py.

4502 def Map(f, *args):
4503  """Return a Z3 map array expression.
4504 
4505  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4506  >>> a1 = Array('a1', IntSort(), IntSort())
4507  >>> a2 = Array('a2', IntSort(), IntSort())
4508  >>> b = Map(f, a1, a2)
4509  >>> b
4510  Map(f, a1, a2)
4511  >>> prove(b[0] == f(a1[0], a2[0]))
4512  proved
4513  """
4514  args = _get_args(args)
4515  if z3_debug():
4516  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4517  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4518  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4519  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4520  _args, sz = _to_ast_array(args)
4521  ctx = f.ctx
4522  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4523 

Referenced by Context.Context().

◆ mk_not()

def z3py.mk_not (   a)

Definition at line 1687 of file z3py.py.

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

◆ Model()

def z3py.Model (   ctx = None)

Definition at line 6259 of file z3py.py.

6259 def Model(ctx = None):
6260  ctx = _get_ctx(ctx)
6261  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6262 

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

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

◆ Not()

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

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

Definition at line 1669 of file z3py.py.

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

Referenced by fpNEQ(), mk_not(), and prove().

◆ open_log()

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

Definition at line 101 of file z3py.py.

101 def open_log(fname):
102  """Log interaction to a file. This function must be invoked immediately after init(). """
103  Z3_open_log(fname)
104 

◆ Option()

def z3py.Option (   re)
Create the regular expression that optionally accepts the argument.
>>> re = Option(Re("a"))
>>> print(simplify(InRe("a", re)))
True
>>> print(simplify(InRe("", re)))
True
>>> print(simplify(InRe("aa", re)))
False

Definition at line 10400 of file z3py.py.

10400 def Option(re):
10401  """Create the regular expression that optionally accepts the argument.
10402  >>> re = Option(Re("a"))
10403  >>> print(simplify(InRe("a", re)))
10404  True
10405  >>> print(simplify(InRe("", re)))
10406  True
10407  >>> print(simplify(InRe("aa", re)))
10408  False
10409  """
10410  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10411 

◆ Or()

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

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

Definition at line 1732 of file z3py.py.

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

Referenced by ApplyResult.as_expr().

◆ OrElse()

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

>>> x = Int('x')
>>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
>>> # Tactic split-clause fails if there is no clause in the given goal.
>>> t(x == 0)
[[x == 0]]
>>> t(Or(x == 0, x == 1))
[[x == 0], [x == 1]]

Definition at line 7801 of file z3py.py.

7801 def OrElse(*ts, **ks):
7802  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7803 
7804  >>> x = Int('x')
7805  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7806  >>> # Tactic split-clause fails if there is no clause in the given goal.
7807  >>> t(x == 0)
7808  [[x == 0]]
7809  >>> t(Or(x == 0, x == 1))
7810  [[x == 0], [x == 1]]
7811  """
7812  if z3_debug():
7813  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7814  ctx = ks.get('ctx', None)
7815  num = len(ts)
7816  r = ts[0]
7817  for i in range(num - 1):
7818  r = _or_else(r, ts[i+1], ctx)
7819  return r
7820 

◆ ParAndThen()

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

Definition at line 7853 of file z3py.py.

7853 def ParAndThen(t1, t2, ctx=None):
7854  """Alias for ParThen(t1, t2, ctx)."""
7855  return ParThen(t1, t2, ctx)
7856 

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

7821 def ParOr(*ts, **ks):
7822  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7823 
7824  >>> x = Int('x')
7825  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7826  >>> t(x + 1 == 2)
7827  [[x == 1]]
7828  """
7829  if z3_debug():
7830  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7831  ctx = _get_ctx(ks.get('ctx', None))
7832  ts = [ _to_tactic(t, ctx) for t in ts ]
7833  sz = len(ts)
7834  _args = (TacticObj * sz)()
7835  for i in range(sz):
7836  _args[i] = ts[i].tactic
7837  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7838 

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

8626 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8627  """Parse a file in SMT 2.0 format using the given sorts and decls.
8628 
8629  This function is similar to parse_smt2_string().
8630  """
8631  ctx = _get_ctx(ctx)
8632  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8633  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8634  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8635 
8636 

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

8606 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8607  """Parse a string in SMT 2.0 format using the given sorts and decls.
8608 
8609  The arguments sorts and decls are Python dictionaries used to initialize
8610  the symbol table used for the SMT 2.0 parser.
8611 
8612  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8613  [x > 0, x < 10]
8614  >>> x, y = Ints('x y')
8615  >>> f = Function('f', IntSort(), IntSort())
8616  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8617  [x + f(y) > 0]
8618  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8619  [a > 0]
8620  """
8621  ctx = _get_ctx(ctx)
8622  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8623  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8624  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8625 

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

7839 def ParThen(t1, t2, ctx=None):
7840  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7841 
7842  >>> x, y = Ints('x y')
7843  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7844  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7845  [[x == 1, y == 2], [x == 2, y == 3]]
7846  """
7847  t1 = _to_tactic(t1, ctx)
7848  t2 = _to_tactic(t2, ctx)
7849  if z3_debug():
7850  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7851  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7852 

Referenced by ParAndThen().

◆ PartialOrder()

def z3py.PartialOrder (   a,
  index 
)

Definition at line 10454 of file z3py.py.

10454 def PartialOrder(a, index):
10455  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10456 

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

8413 def PbEq(args, k, ctx = None):
8414  """Create a Pseudo-Boolean inequality k constraint.
8415 
8416  >>> a, b, c = Bools('a b c')
8417  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8418  """
8419  _z3_check_cint_overflow(k, "k")
8420  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8421  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8422 
8423 

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

8403 def PbGe(args, k):
8404  """Create a Pseudo-Boolean inequality k constraint.
8405 
8406  >>> a, b, c = Bools('a b c')
8407  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8408  """
8409  _z3_check_cint_overflow(k, "k")
8410  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8411  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8412 

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

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

◆ PiecewiseLinearOrder()

def z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 10463 of file z3py.py.

10463 def PiecewiseLinearOrder(a, index):
10464  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10465 

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

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

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

10178 def PrefixOf(a, b):
10179  """Check if 'a' is a prefix of 'b'
10180  >>> s1 = PrefixOf("ab", "abc")
10181  >>> simplify(s1)
10182  True
10183  >>> s2 = PrefixOf("bc", "abc")
10184  >>> simplify(s2)
10185  False
10186  """
10187  ctx = _get_ctx2(a, b)
10188  a = _coerce_seq(a, ctx)
10189  b = _coerce_seq(b, ctx)
10190  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10191 

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

8111 def probe_description(name, ctx=None):
8112  """Return a short description for the probe named `name`.
8113 
8114  >>> d = probe_description('memory')
8115  """
8116  ctx = _get_ctx(ctx)
8117  return Z3_probe_get_descr(ctx.ref(), name)
8118 

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

8101 def probes(ctx=None):
8102  """Return a list of all available probes in Z3.
8103 
8104  >>> l = probes()
8105  >>> l.count('memory') == 1
8106  True
8107  """
8108  ctx = _get_ctx(ctx)
8109  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8110 

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

8309 def Product(*args):
8310  """Create the product of the Z3 expressions.
8311 
8312  >>> a, b, c = Ints('a b c')
8313  >>> Product(a, b, c)
8314  a*b*c
8315  >>> Product([a, b, c])
8316  a*b*c
8317  >>> A = IntVector('a', 5)
8318  >>> Product(A)
8319  a__0*a__1*a__2*a__3*a__4
8320  """
8321  args = _get_args(args)
8322  if len(args) == 0:
8323  return 1
8324  ctx = _ctx_from_ast_arg_list(args)
8325  if ctx is None:
8326  return _reduce(lambda a, b: a * b, args, 1)
8327  args = _coerce_expr_list(args, ctx)
8328  if is_bv(args[0]):
8329  return _reduce(lambda a, b: a * b, args, 1)
8330  else:
8331  _args, sz = _to_ast_array(args)
8332  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8333 

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

8481 def prove(claim, **keywords):
8482  """Try to prove the given claim.
8483 
8484  This is a simple function for creating demonstrations. It tries to prove
8485  `claim` by showing the negation is unsatisfiable.
8486 
8487  >>> p, q = Bools('p q')
8488  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8489  proved
8490  """
8491  if z3_debug():
8492  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8493  s = Solver()
8494  s.set(**keywords)
8495  s.add(Not(claim))
8496  if keywords.get('show', False):
8497  print(s)
8498  r = s.check()
8499  if r == unsat:
8500  print("proved")
8501  elif r == unknown:
8502  print("failed to prove")
8503  print(s.model())
8504  else:
8505  print("counterexample")
8506  print(s.model())
8507 

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

3019 def Q(a, b, ctx=None):
3020  """Return a Z3 rational a/b.
3021 
3022  If `ctx=None`, then the global context is used.
3023 
3024  >>> Q(3,5)
3025  3/5
3026  >>> Q(3,5).sort()
3027  Real
3028  """
3029  return simplify(RatVal(a, b))
3030 

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

10440 def Range(lo, hi, ctx = None):
10441  """Create the range regular expression over two sequences of length 1
10442  >>> range = Range("a","z")
10443  >>> print(simplify(InRe("b", range)))
10444  True
10445  >>> print(simplify(InRe("bb", range)))
10446  False
10447  """
10448  lo = _coerce_seq(lo, ctx)
10449  hi = _coerce_seq(hi, ctx)
10450  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10451 
10452 # Special Relations
10453 

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

3004 def RatVal(a, b, ctx=None):
3005  """Return a Z3 rational a/b.
3006 
3007  If `ctx=None`, then the global context is used.
3008 
3009  >>> RatVal(3,5)
3010  3/5
3011  >>> RatVal(3,5).sort()
3012  Real
3013  """
3014  if z3_debug():
3015  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3016  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3017  return simplify(RealVal(a, ctx)/RealVal(b, ctx))
3018 

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

10300 def Re(s, ctx=None):
10301  """The regular expression that accepts sequence 's'
10302  >>> s1 = Re("ab")
10303  >>> s2 = Re(StringVal("ab"))
10304  >>> s3 = Re(Unit(BoolVal(True)))
10305  """
10306  s = _coerce_seq(s, ctx)
10307  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10308 
10309 
10310 
10311 

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

3080 def Real(name, ctx=None):
3081  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3082 
3083  >>> x = Real('x')
3084  >>> is_real(x)
3085  True
3086  >>> is_real(x + 1)
3087  True
3088  """
3089  ctx = _get_ctx(ctx)
3090  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3091 

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

3092 def Reals(names, ctx=None):
3093  """Return a tuple of real constants.
3094 
3095  >>> x, y, z = Reals('x y z')
3096  >>> Sum(x, y, z)
3097  x + y + z
3098  >>> Sum(x, y, z).sort()
3099  Real
3100  """
3101  ctx = _get_ctx(ctx)
3102  if isinstance(names, str):
3103  names = names.split(" ")
3104  return [Real(name, ctx) for name in names]
3105 

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

2944 def RealSort(ctx=None):
2945  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2946 
2947  >>> RealSort()
2948  Real
2949  >>> x = Const('x', RealSort())
2950  >>> is_real(x)
2951  True
2952  >>> is_int(x)
2953  False
2954  >>> x.sort() == RealSort()
2955  True
2956  """
2957  ctx = _get_ctx(ctx)
2958  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2959 

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

2986 def RealVal(val, ctx=None):
2987  """Return a Z3 real value.
2988 
2989  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
2990  If `ctx=None`, then the global context is used.
2991 
2992  >>> RealVal(1)
2993  1
2994  >>> RealVal(1).sort()
2995  Real
2996  >>> RealVal("3/5")
2997  3/5
2998  >>> RealVal("1.5")
2999  3/2
3000  """
3001  ctx = _get_ctx(ctx)
3002  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3003 

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

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

Referenced by RealVarVector().

◆ RealVarVector()

def z3py.RealVarVector (   n,
  ctx = None 
)
Create a list of Real free variables.
The variables have ids: 0, 1, ..., n-1

>>> x0, x1, x2, x3 = RealVarVector(4)
>>> x2
Var(2)

Definition at line 1373 of file z3py.py.

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

◆ RealVector()

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

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

Definition at line 3106 of file z3py.py.

3106 def RealVector(prefix, sz, ctx=None):
3107  """Return a list of real constants of size `sz`.
3108 
3109  >>> X = RealVector('x', 3)
3110  >>> X
3111  [x__0, x__1, x__2]
3112  >>> Sum(X)
3113  x__0 + x__1 + x__2
3114  >>> Sum(X).sort()
3115  Real
3116  """
3117  ctx = _get_ctx(ctx)
3118  return [ Real('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3119 

◆ RecAddDefinition()

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

Definition at line 860 of file z3py.py.

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

◆ RecFunction()

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

Definition at line 843 of file z3py.py.

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

◆ Repeat()

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

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

Definition at line 7883 of file z3py.py.

7883 def Repeat(t, max=4294967295, ctx=None):
7884  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7885 
7886  >>> x, y = Ints('x y')
7887  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7888  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7889  >>> r = t(c)
7890  >>> for subgoal in r: print(subgoal)
7891  [x == 0, y == 0, x > y]
7892  [x == 0, y == 1, x > y]
7893  [x == 1, y == 0, x > y]
7894  [x == 1, y == 1, x > y]
7895  >>> t = Then(t, Tactic('propagate-values'))
7896  >>> t(c)
7897  [[x == 1, y == 0]]
7898  """
7899  t = _to_tactic(t, ctx)
7900  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7901 

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

4153 def RepeatBitVec(n, a):
4154  """Return an expression representing `n` copies of `a`.
4155 
4156  >>> x = BitVec('x', 8)
4157  >>> n = RepeatBitVec(4, x)
4158  >>> n
4159  RepeatBitVec(4, x)
4160  >>> n.size()
4161  32
4162  >>> v0 = BitVecVal(10, 4)
4163  >>> print("%.x" % v0.as_long())
4164  a
4165  >>> v = simplify(RepeatBitVec(4, v0))
4166  >>> v.size()
4167  16
4168  >>> print("%.x" % v.as_long())
4169  aaaa
4170  """
4171  if z3_debug():
4172  _z3_assert(_is_int(n), "First argument must be an integer")
4173  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4174  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4175 

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

10225 def Replace(s, src, dst):
10226  """Replace the first occurrence of 'src' by 'dst' in 's'
10227  >>> r = Replace("aaa", "a", "b")
10228  >>> simplify(r)
10229  "baa"
10230  """
10231  ctx = _get_ctx2(dst, s)
10232  if ctx is None and is_expr(src):
10233  ctx = src.ctx
10234  src = _coerce_seq(src, ctx)
10235  dst = _coerce_seq(dst, ctx)
10236  s = _coerce_seq(s, ctx)
10237  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10238 

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

10320 def ReSort(s):
10321  if is_ast(s):
10322  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10323  if s is None or isinstance(s, Context):
10324  ctx = _get_ctx(s)
10325  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10326  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10327 
10328 

Referenced by Context.mkReSort().

◆ RNA()

def z3py.RNA (   ctx = None)

Definition at line 9015 of file z3py.py.

9015 def RNA (ctx=None):
9016  ctx = _get_ctx(ctx)
9017  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9018 

Referenced by get_default_rounding_mode().

◆ RNE()

def z3py.RNE (   ctx = None)

Definition at line 9007 of file z3py.py.

9007 def RNE (ctx=None):
9008  ctx = _get_ctx(ctx)
9009  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9010 

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

4067 def RotateLeft(a, b):
4068  """Return an expression representing `a` rotated to the left `b` times.
4069 
4070  >>> a, b = BitVecs('a b', 16)
4071  >>> RotateLeft(a, b)
4072  RotateLeft(a, b)
4073  >>> simplify(RotateLeft(a, 0))
4074  a
4075  >>> simplify(RotateLeft(a, 16))
4076  a
4077  """
4078  _check_bv_args(a, b)
4079  a, b = _coerce_exprs(a, b)
4080  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4081 

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

4082 def RotateRight(a, b):
4083  """Return an expression representing `a` rotated to the right `b` times.
4084 
4085  >>> a, b = BitVecs('a b', 16)
4086  >>> RotateRight(a, b)
4087  RotateRight(a, b)
4088  >>> simplify(RotateRight(a, 0))
4089  a
4090  >>> simplify(RotateRight(a, 16))
4091  a
4092  """
4093  _check_bv_args(a, b)
4094  a, b = _coerce_exprs(a, b)
4095  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4096 

◆ RoundNearestTiesToAway()

def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 9011 of file z3py.py.

9011 def RoundNearestTiesToAway(ctx=None):
9012  ctx = _get_ctx(ctx)
9013  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9014 

◆ RoundNearestTiesToEven()

def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 9003 of file z3py.py.

9003 def RoundNearestTiesToEven(ctx=None):
9004  ctx = _get_ctx(ctx)
9005  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9006 

◆ RoundTowardNegative()

def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9027 of file z3py.py.

9027 def RoundTowardNegative(ctx=None):
9028  ctx = _get_ctx(ctx)
9029  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9030 

◆ RoundTowardPositive()

def z3py.RoundTowardPositive (   ctx = None)

Definition at line 9019 of file z3py.py.

9019 def RoundTowardPositive(ctx=None):
9020  ctx = _get_ctx(ctx)
9021  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9022 

◆ RoundTowardZero()

def z3py.RoundTowardZero (   ctx = None)

Definition at line 9035 of file z3py.py.

9035 def RoundTowardZero(ctx=None):
9036  ctx = _get_ctx(ctx)
9037  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9038 

◆ RTN()

def z3py.RTN (   ctx = None)

Definition at line 9031 of file z3py.py.

9031 def RTN(ctx=None):
9032  ctx = _get_ctx(ctx)
9033  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9034 

Referenced by get_default_rounding_mode().

◆ RTP()

def z3py.RTP (   ctx = None)

Definition at line 9023 of file z3py.py.

9023 def RTP(ctx=None):
9024  ctx = _get_ctx(ctx)
9025  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9026 

Referenced by get_default_rounding_mode().

◆ RTZ()

def z3py.RTZ (   ctx = None)

Definition at line 9039 of file z3py.py.

9039 def RTZ(ctx=None):
9040  ctx = _get_ctx(ctx)
9041  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9042 

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

4487 def Select(a, i):
4488  """Return a Z3 select array expression.
4489 
4490  >>> a = Array('a', IntSort(), IntSort())
4491  >>> i = Int('i')
4492  >>> Select(a, i)
4493  a[i]
4494  >>> eq(Select(a, i), a[i])
4495  True
4496  """
4497  if z3_debug():
4498  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4499  return a[i]
4500 
4501 

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

10003 def SeqSort(s):
10004  """Create a sequence sort over elements provided in the argument
10005  >>> s = SeqSort(IntSort())
10006  >>> s == Unit(IntVal(1)).sort()
10007  True
10008  """
10009  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10010 

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

◆ set_default_fp_sort()

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

Definition at line 8679 of file z3py.py.

8679 def set_default_fp_sort(ebits, sbits, ctx=None):
8680  global _dflt_fpsort_ebits
8681  global _dflt_fpsort_sbits
8682  _dflt_fpsort_ebits = ebits
8683  _dflt_fpsort_sbits = sbits
8684 

◆ set_default_rounding_mode()

def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 8663 of file z3py.py.

8663 def set_default_rounding_mode(rm, ctx=None):
8664  global _dflt_rounding_mode
8665  if is_fprm_value(rm):
8666  _dflt_rounding_mode = rm.decl().kind()
8667  else:
8668  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8669  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8670  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8671  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8672  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8673  "illegal rounding mode")
8674  _dflt_rounding_mode = rm
8675 

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

4635 def SetAdd(s, e):
4636  """ Add element e to set s
4637  >>> a = Const('a', SetSort(IntSort()))
4638  >>> SetAdd(a, 1)
4639  Store(a, 1, True)
4640  """
4641  ctx = _ctx_from_ast_arg_list([s,e])
4642  e = _py2expr(e, ctx)
4643  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4644 

◆ SetComplement()

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

Definition at line 4655 of file z3py.py.

4655 def SetComplement(s):
4656  """ The complement of set s
4657  >>> a = Const('a', SetSort(IntSort()))
4658  >>> SetComplement(a)
4659  complement(a)
4660  """
4661  ctx = s.ctx
4662  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4663 

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

4645 def SetDel(s, e):
4646  """ Remove element e to set s
4647  >>> a = Const('a', SetSort(IntSort()))
4648  >>> SetDel(a, 1)
4649  Store(a, 1, False)
4650  """
4651  ctx = _ctx_from_ast_arg_list([s,e])
4652  e = _py2expr(e, ctx)
4653  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4654 

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

4664 def SetDifference(a, b):
4665  """ The set difference of a and b
4666  >>> a = Const('a', SetSort(IntSort()))
4667  >>> b = Const('b', SetSort(IntSort()))
4668  >>> SetDifference(a, b)
4669  setminus(a, b)
4670  """
4671  ctx = _ctx_from_ast_arg_list([a, b])
4672  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4673 

◆ SetHasSize()

def z3py.SetHasSize (   a,
  k 
)

Definition at line 4556 of file z3py.py.

4556 def SetHasSize(a, k):
4557  ctx = a.ctx
4558  k = _py2expr(k, ctx)
4559  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4560 

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

4623 def SetIntersect(*args):
4624  """ Take the union of sets
4625  >>> a = Const('a', SetSort(IntSort()))
4626  >>> b = Const('b', SetSort(IntSort()))
4627  >>> SetIntersect(a, b)
4628  intersection(a, b)
4629  """
4630  args = _get_args(args)
4631  ctx = _ctx_from_ast_arg_list(args)
4632  _args, sz = _to_ast_array(args)
4633  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4634 

◆ SetSort()

def z3py.SetSort (   s)

Sets.

Create a set sort over element sort s

Definition at line 4591 of file z3py.py.

4591 def SetSort(s):
4592  """ Create a set sort over element sort s"""
4593  return ArraySort(s, BoolSort())
4594 

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

4611 def SetUnion(*args):
4612  """ Take the union of sets
4613  >>> a = Const('a', SetSort(IntSort()))
4614  >>> b = Const('b', SetSort(IntSort()))
4615  >>> SetUnion(a, b)
4616  union(a, b)
4617  """
4618  args = _get_args(args)
4619  ctx = _ctx_from_ast_arg_list(args)
4620  _args, sz = _to_ast_array(args)
4621  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4622 

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

4097 def SignExt(n, a):
4098  """Return a bit-vector expression with `n` extra sign-bits.
4099 
4100  >>> x = BitVec('x', 16)
4101  >>> n = SignExt(8, x)
4102  >>> n.size()
4103  24
4104  >>> n
4105  SignExt(8, x)
4106  >>> n.sort()
4107  BitVec(24)
4108  >>> v0 = BitVecVal(2, 2)
4109  >>> v0
4110  2
4111  >>> v0.size()
4112  2
4113  >>> v = simplify(SignExt(6, v0))
4114  >>> v
4115  254
4116  >>> v.size()
4117  8
4118  >>> print("%.x" % v.as_long())
4119  fe
4120  """
4121  if z3_debug():
4122  _z3_assert(_is_int(n), "First argument must be an integer")
4123  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4124  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4125 

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

6954 def SimpleSolver(ctx=None, logFile=None):
6955  """Return a simple general purpose solver with limited amount of preprocessing.
6956 
6957  >>> s = SimpleSolver()
6958  >>> x = Int('x')
6959  >>> s.add(x > 0)
6960  >>> s.check()
6961  sat
6962  """
6963  ctx = _get_ctx(ctx)
6964  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6965 

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

8205 def simplify(a, *arguments, **keywords):
8206  """Simplify the expression `a` using the given options.
8207 
8208  This function has many options. Use `help_simplify` to obtain the complete list.
8209 
8210  >>> x = Int('x')
8211  >>> y = Int('y')
8212  >>> simplify(x + 1 + y + x + 1)
8213  2 + 2*x + y
8214  >>> simplify((x + 1)*(y + 1), som=True)
8215  1 + x + y + x*y
8216  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8217  And(Not(x == y), Not(x == 1), Not(y == 1))
8218  >>> simplify(And(x == 0, y == 1), elim_and=True)
8219  Not(Or(Not(x == 0), Not(y == 1)))
8220  """
8221  if z3_debug():
8222  _z3_assert(is_expr(a), "Z3 expression expected")
8223  if len(arguments) > 0 or len(keywords) > 0:
8224  p = args2params(arguments, keywords, a.ctx)
8225  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8226  else:
8227  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8228 

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

8233 def simplify_param_descrs():
8234  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8235  return ParamDescrsRef(Z3_simplify_get_param_descrs(main_ctx().ref()), main_ctx())
8236 

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

8424 def solve(*args, **keywords):
8425  """Solve the constraints `*args`.
8426 
8427  This is a simple function for creating demonstrations. It creates a solver,
8428  configure it using the options in `keywords`, adds the constraints
8429  in `args`, and invokes check.
8430 
8431  >>> a = Int('a')
8432  >>> solve(a > 0, a < 2)
8433  [a = 1]
8434  """
8435  s = Solver()
8436  s.set(**keywords)
8437  s.add(*args)
8438  if keywords.get('show', False):
8439  print(s)
8440  r = s.check()
8441  if r == unsat:
8442  print("no solution")
8443  elif r == unknown:
8444  print("failed to solve")
8445  try:
8446  print(s.model())
8447  except Z3Exception:
8448  return
8449  else:
8450  print(s.model())
8451 

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

8452 def solve_using(s, *args, **keywords):
8453  """Solve the constraints `*args` using solver `s`.
8454 
8455  This is a simple function for creating demonstrations. It is similar to `solve`,
8456  but it uses the given solver `s`.
8457  It configures solver `s` using the options in `keywords`, adds the constraints
8458  in `args`, and invokes check.
8459  """
8460  if z3_debug():
8461  _z3_assert(isinstance(s, Solver), "Solver object expected")
8462  s.set(**keywords)
8463  s.add(*args)
8464  if keywords.get('show', False):
8465  print("Problem:")
8466  print(s)
8467  r = s.check()
8468  if r == unsat:
8469  print("no solution")
8470  elif r == unknown:
8471  print("failed to solve")
8472  try:
8473  print(s.model())
8474  except Z3Exception:
8475  return
8476  else:
8477  if keywords.get('show', False):
8478  print("Solution:")
8479  print(s.model())
8480 

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

6934 def SolverFor(logic, ctx=None, logFile=None):
6935  """Create a solver customized for the given logic.
6936 
6937  The parameter `logic` is a string. It should be contains
6938  the name of a SMT-LIB logic.
6939  See http://www.smtlib.org/ for the name of all available logics.
6940 
6941  >>> s = SolverFor("QF_LIA")
6942  >>> x = Int('x')
6943  >>> s.add(x > 0)
6944  >>> s.add(x < 2)
6945  >>> s.check()
6946  sat
6947  >>> s.model()
6948  [x = 1]
6949  """
6950  ctx = _get_ctx(ctx)
6951  logic = to_symbol(logic)
6952  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6953 

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

3183 def Sqrt(a, ctx=None):
3184  """ Return a Z3 expression which represents the square root of a.
3185 
3186  >>> x = Real('x')
3187  >>> Sqrt(x)
3188  x**(1/2)
3189  """
3190  if not is_expr(a):
3191  ctx = _get_ctx(ctx)
3192  a = RealVal(a, ctx)
3193  return a ** "1/2"
3194 

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

4016 def SRem(a, b):
4017  """Create the Z3 expression signed remainder.
4018 
4019  Use the operator % for signed modulus, and URem() for unsigned remainder.
4020 
4021  >>> x = BitVec('x', 32)
4022  >>> y = BitVec('y', 32)
4023  >>> SRem(x, y)
4024  SRem(x, y)
4025  >>> SRem(x, y).sort()
4026  BitVec(32)
4027  >>> (x % y).sexpr()
4028  '(bvsmod x y)'
4029  >>> SRem(x, y).sexpr()
4030  '(bvsrem x y)'
4031  """
4032  _check_bv_args(a, b)
4033  a, b = _coerce_exprs(a, b)
4034  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4035 

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

10416 def Star(re):
10417  """Create the regular expression accepting zero or more repetitions of argument.
10418  >>> re = Star(Re("a"))
10419  >>> print(simplify(InRe("aa", re)))
10420  True
10421  >>> print(simplify(InRe("ab", re)))
10422  False
10423  >>> print(simplify(InRe("", re)))
10424  True
10425  """
10426  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10427 

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

4471 def Store(a, i, v):
4472  """Return a Z3 store array expression.
4473 
4474  >>> a = Array('a', IntSort(), IntSort())
4475  >>> i, v = Ints('i v')
4476  >>> s = Store(a, i, v)
4477  >>> s.sort()
4478  Array(Int, Int)
4479  >>> prove(s[i] == v)
4480  proved
4481  >>> j = Int('j')
4482  >>> prove(Implies(i != j, s[j] == a[j]))
4483  proved
4484  """
4485  return Update(a, i, v)
4486 

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

10111 def String(name, ctx=None):
10112  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10113 
10114  >>> x = String('x')
10115  """
10116  ctx = _get_ctx(ctx)
10117  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10118 

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

10119 def Strings(names, ctx=None):
10120  """Return string constants"""
10121  ctx = _get_ctx(ctx)
10122  if isinstance(names, str):
10123  names = names.split(" ")
10124  return [String(name, ctx) for name in names]
10125 

Referenced by SubSeq().

◆ StringSort()

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

Definition at line 9993 of file z3py.py.

9993 def StringSort(ctx=None):
9994  """Create a string sort
9995  >>> s = StringSort()
9996  >>> print(s)
9997  String
9998  """
9999  ctx = _get_ctx(ctx)
10000  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10001 
10002 

Referenced by String().

◆ StringVal()

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

Definition at line 10106 of file z3py.py.

10106 def StringVal(s, ctx=None):
10107  """create a string expression"""
10108  ctx = _get_ctx(ctx)
10109  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10110 

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

10277 def StrToInt(s):
10278  """Convert string expression to integer
10279  >>> a = StrToInt("1")
10280  >>> simplify(1 == a)
10281  True
10282  >>> b = StrToInt("2")
10283  >>> simplify(1 == b)
10284  False
10285  >>> c = StrToInt(IntToStr(2))
10286  >>> simplify(1 == c)
10287  False
10288  """
10289  s = _coerce_seq(s)
10290  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10291 
10292 

◆ SubSeq()

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

Definition at line 10130 of file z3py.py.

10130 def SubSeq(s, offset, length):
10131  """Extract substring or subsequence starting at offset"""
10132  return Extract(s, offset, length)
10133 

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

8237 def substitute(t, *m):
8238  """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.
8239 
8240  >>> x = Int('x')
8241  >>> y = Int('y')
8242  >>> substitute(x + 1, (x, y + 1))
8243  y + 1 + 1
8244  >>> f = Function('f', IntSort(), IntSort())
8245  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8246  1 + 1
8247  """
8248  if isinstance(m, tuple):
8249  m1 = _get_args(m)
8250  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8251  m = m1
8252  if z3_debug():
8253  _z3_assert(is_expr(t), "Z3 expression expected")
8254  _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.")
8255  num = len(m)
8256  _from = (Ast * num)()
8257  _to = (Ast * num)()
8258  for i in range(num):
8259  _from[i] = m[i][0].as_ast()
8260  _to[i] = m[i][1].as_ast()
8261  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8262 

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

8263 def substitute_vars(t, *m):
8264  """Substitute the free variables in t with the expression in m.
8265 
8266  >>> v0 = Var(0, IntSort())
8267  >>> v1 = Var(1, IntSort())
8268  >>> x = Int('x')
8269  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8270  >>> # replace v0 with x+1 and v1 with x
8271  >>> substitute_vars(f(v0, v1), x + 1, x)
8272  f(x + 1, x)
8273  """
8274  if z3_debug():
8275  _z3_assert(is_expr(t), "Z3 expression expected")
8276  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8277  num = len(m)
8278  _to = (Ast * num)()
8279  for i in range(num):
8280  _to[i] = m[i].as_ast()
8281  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8282 

◆ SubString()

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

Definition at line 10126 of file z3py.py.

10126 def SubString(s, offset, length):
10127  """Extract substring or subsequence starting at offset"""
10128  return Extract(s, offset, length)
10129 

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

10192 def SuffixOf(a, b):
10193  """Check if 'a' is a suffix of 'b'
10194  >>> s1 = SuffixOf("ab", "abc")
10195  >>> simplify(s1)
10196  False
10197  >>> s2 = SuffixOf("bc", "abc")
10198  >>> simplify(s2)
10199  True
10200  """
10201  ctx = _get_ctx2(a, b)
10202  a = _coerce_seq(a, ctx)
10203  b = _coerce_seq(b, ctx)
10204  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10205 

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

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

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

7920 def tactic_description(name, ctx=None):
7921  """Return a short description for the tactic named `name`.
7922 
7923  >>> d = tactic_description('simplify')
7924  """
7925  ctx = _get_ctx(ctx)
7926  return Z3_tactic_get_descr(ctx.ref(), name)
7927 

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

7910 def tactics(ctx=None):
7911  """Return a list of all available tactics in Z3.
7912 
7913  >>> l = tactics()
7914  >>> l.count('simplify') == 1
7915  True
7916  """
7917  ctx = _get_ctx(ctx)
7918  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7919 

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

7789 def Then(*ts, **ks):
7790  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7791 
7792  >>> x, y = Ints('x y')
7793  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7794  >>> t(And(x == 0, y > x + 1))
7795  [[Not(y <= 1)]]
7796  >>> t(And(x == 0, y > x + 1)).as_expr()
7797  Not(y <= 1)
7798  """
7799  return AndThen(*ts, **ks)
7800 

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

3150 def ToInt(a):
3151  """ Return the Z3 expression ToInt(a).
3152 
3153  >>> x = Real('x')
3154  >>> x.sort()
3155  Real
3156  >>> n = ToInt(x)
3157  >>> n
3158  ToInt(x)
3159  >>> n.sort()
3160  Int
3161  """
3162  if z3_debug():
3163  _z3_assert(a.is_real(), "Z3 real expression expected.")
3164  ctx = a.ctx
3165  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3166 

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

3133 def ToReal(a):
3134  """ Return the Z3 expression ToReal(a).
3135 
3136  >>> x = Int('x')
3137  >>> x.sort()
3138  Int
3139  >>> n = ToReal(x)
3140  >>> n
3141  ToReal(x)
3142  >>> n.sort()
3143  Real
3144  """
3145  if z3_debug():
3146  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3147  ctx = a.ctx
3148  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3149 

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

10466 def TransitiveClosure(f):
10467  """Given a binary relation R, such that the two arguments have the same sort
10468  create the transitive closure relation R+.
10469  The transitive closure R+ is a new relation.
10470  """
10471  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)

◆ TreeOrder()

def z3py.TreeOrder (   a,
  index 
)

Definition at line 10460 of file z3py.py.

10460 def TreeOrder(a, index):
10461  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10462 

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

7902 def TryFor(t, ms, ctx=None):
7903  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7904 
7905  If `t` does not terminate in `ms` milliseconds, then it fails.
7906  """
7907  t = _to_tactic(t, ctx)
7908  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7909 

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

4994 def TupleSort(name, sorts, ctx = None):
4995  """Create a named tuple sort base on a set of underlying sorts
4996  Example:
4997  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
4998  """
4999  tuple = Datatype(name, ctx)
5000  projects = [ ('project%d' % i, sorts[i]) for i in range(len(sorts)) ]
5001  tuple.declare(name, *projects)
5002  tuple = tuple.create()
5003  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5004 

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

3976 def UDiv(a, b):
3977  """Create the Z3 expression (unsigned) division `self / other`.
3978 
3979  Use the operator / for signed division.
3980 
3981  >>> x = BitVec('x', 32)
3982  >>> y = BitVec('y', 32)
3983  >>> UDiv(x, y)
3984  UDiv(x, y)
3985  >>> UDiv(x, y).sort()
3986  BitVec(32)
3987  >>> (x / y).sexpr()
3988  '(bvsdiv x y)'
3989  >>> UDiv(x, y).sexpr()
3990  '(bvudiv x y)'
3991  """
3992  _check_bv_args(a, b)
3993  a, b = _coerce_exprs(a, b)
3994  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3995 

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

3942 def UGE(a, b):
3943  """Create the Z3 expression (unsigned) `other >= self`.
3944 
3945  Use the operator >= for signed greater than or equal to.
3946 
3947  >>> x, y = BitVecs('x y', 32)
3948  >>> UGE(x, y)
3949  UGE(x, y)
3950  >>> (x >= y).sexpr()
3951  '(bvsge x y)'
3952  >>> UGE(x, y).sexpr()
3953  '(bvuge x y)'
3954  """
3955  _check_bv_args(a, b)
3956  a, b = _coerce_exprs(a, b)
3957  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3958 

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

3959 def UGT(a, b):
3960  """Create the Z3 expression (unsigned) `other > self`.
3961 
3962  Use the operator > for signed greater than.
3963 
3964  >>> x, y = BitVecs('x y', 32)
3965  >>> UGT(x, y)
3966  UGT(x, y)
3967  >>> (x > y).sexpr()
3968  '(bvsgt x y)'
3969  >>> UGT(x, y).sexpr()
3970  '(bvugt x y)'
3971  """
3972  _check_bv_args(a, b)
3973  a, b = _coerce_exprs(a, b)
3974  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3975 

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

3908 def ULE(a, b):
3909  """Create the Z3 expression (unsigned) `other <= self`.
3910 
3911  Use the operator <= for signed less than or equal to.
3912 
3913  >>> x, y = BitVecs('x y', 32)
3914  >>> ULE(x, y)
3915  ULE(x, y)
3916  >>> (x <= y).sexpr()
3917  '(bvsle x y)'
3918  >>> ULE(x, y).sexpr()
3919  '(bvule x y)'
3920  """
3921  _check_bv_args(a, b)
3922  a, b = _coerce_exprs(a, b)
3923  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3924 

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

3925 def ULT(a, b):
3926  """Create the Z3 expression (unsigned) `other < self`.
3927 
3928  Use the operator < for signed less than.
3929 
3930  >>> x, y = BitVecs('x y', 32)
3931  >>> ULT(x, y)
3932  ULT(x, y)
3933  >>> (x < y).sexpr()
3934  '(bvslt x y)'
3935  >>> ULT(x, y).sexpr()
3936  '(bvult x y)'
3937  """
3938  _check_bv_args(a, b)
3939  a, b = _coerce_exprs(a, b)
3940  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3941 

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

10352 def Union(*args):
10353  """Create union of regular expressions.
10354  >>> re = Union(Re("a"), Re("b"), Re("c"))
10355  >>> print (simplify(InRe("d", re)))
10356  False
10357  """
10358  args = _get_args(args)
10359  sz = len(args)
10360  if z3_debug():
10361  _z3_assert(sz > 0, "At least one argument expected.")
10362  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10363  if sz == 1:
10364  return args[0]
10365  ctx = args[0].ctx
10366  v = (Ast * sz)()
10367  for i in range(sz):
10368  v[i] = args[i].as_ast()
10369  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10370 

Referenced by ReRef.__add__().

◆ Unit()

def z3py.Unit (   a)
Create a singleton sequence

Definition at line 10174 of file z3py.py.

10174 def Unit(a):
10175  """Create a singleton sequence"""
10176  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10177 

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

4439 def Update(a, i, v):
4440  """Return a Z3 store array expression.
4441 
4442  >>> a = Array('a', IntSort(), IntSort())
4443  >>> i, v = Ints('i v')
4444  >>> s = Update(a, i, v)
4445  >>> s.sort()
4446  Array(Int, Int)
4447  >>> prove(s[i] == v)
4448  proved
4449  >>> j = Int('j')
4450  >>> prove(Implies(i != j, s[j] == a[j]))
4451  proved
4452  """
4453  if z3_debug():
4454  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4455  i = a.sort().domain().cast(i)
4456  v = a.sort().range().cast(v)
4457  ctx = a.ctx
4458  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4459 

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

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

◆ Var()

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

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

Definition at line 1351 of file z3py.py.

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

Referenced by RealVar().

◆ When()

def z3py.When (   p,
  t,
  ctx = None 
)
Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.

>>> t = When(Probe('size') > 2, Tactic('simplify'))
>>> x, y = Ints('x y')
>>> g = Goal()
>>> g.add(x > 0)
>>> g.add(y > 0)
>>> t(g)
[[x > 0, y > 0]]
>>> g.add(x == y + 1)
>>> t(g)
[[Not(x <= 0), Not(y <= 0), x == 1 + y]]

Definition at line 8171 of file z3py.py.

8171 def When(p, t, ctx=None):
8172  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8173 
8174  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8175  >>> x, y = Ints('x y')
8176  >>> g = Goal()
8177  >>> g.add(x > 0)
8178  >>> g.add(y > 0)
8179  >>> t(g)
8180  [[x > 0, y > 0]]
8181  >>> g.add(x == y + 1)
8182  >>> t(g)
8183  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8184  """
8185  p = _to_probe(p, ctx)
8186  t = _to_tactic(t, ctx)
8187  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8188 

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

7857 def With(t, *args, **keys):
7858  """Return a tactic that applies tactic `t` using the given configuration options.
7859 
7860  >>> x, y = Ints('x y')
7861  >>> t = With(Tactic('simplify'), som=True)
7862  >>> t((x + 1)*(y + 2) == 0)
7863  [[2*x + y + x*y == -2]]
7864  """
7865  ctx = keys.pop('ctx', None)
7866  t = _to_tactic(t, ctx)
7867  p = args2params(args, keys, t.ctx)
7868  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7869 

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

7870 def WithParams(t, p):
7871  """Return a tactic that applies tactic `t` using the given configuration options.
7872 
7873  >>> x, y = Ints('x y')
7874  >>> p = ParamsRef()
7875  >>> p.set("som", True)
7876  >>> t = WithParams(Tactic('simplify'), p)
7877  >>> t((x + 1)*(y + 2) == 0)
7878  [[2*x + y + x*y == -2]]
7879  """
7880  t = _to_tactic(t, None)
7881  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7882 

◆ Xor()

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

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

Definition at line 1654 of file z3py.py.

1654 def Xor(a, b, ctx=None):
1655  """Create a Z3 Xor expression.
1656 
1657  >>> p, q = Bools('p q')
1658  >>> Xor(p, q)
1659  Xor(p, q)
1660  >>> simplify(Xor(p, q))
1661  Not(p) == q
1662  """
1663  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1664  s = BoolSort(ctx)
1665  a = s.cast(a)
1666  b = s.cast(b)
1667  return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1668 

◆ z3_debug()

def z3py.z3_debug ( )

Definition at line 56 of file z3py.py.

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

Referenced by FuncDeclRef.__call__(), Probe.__call__(), QuantifierRef.__getitem__(), ModelRef.__getitem__(), Context.__init__(), Goal.__init__(), ArithRef.__mod__(), ArithRef.__rmod__(), DatatypeSortRef.accessor(), And(), AndThen(), Tactic.apply(), ExprRef.arg(), args2params(), ArraySort(), AlgebraicNumRef.as_decimal(), IntNumRef.as_long(), AtLeast(), AtMost(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), SortRef.cast(), BoolSortRef.cast(), ArithSortRef.cast(), BitVecSortRef.cast(), FPSortRef.cast(), ExprRef.children(), Concat(), Const(), DatatypeSortRef.constructor(), Goal.convert_model(), CreateDatatypes(), ExprRef.decl(), Datatype.declare(), Datatype.declare_core(), Default(), describe_probes(), Distinct(), FuncDeclRef.domain(), EnumSort(), eq(), AstRef.eq(), Ext(), Extract(), FiniteDomainVal(), fpIsPositive(), fpNeg(), FPSort(), fpToFPUnsigned(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), FreshFunction(), 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 4126 of file z3py.py.

4126 def ZeroExt(n, a):
4127  """Return a bit-vector expression with `n` extra zero-bits.
4128 
4129  >>> x = BitVec('x', 16)
4130  >>> n = ZeroExt(8, x)
4131  >>> n.size()
4132  24
4133  >>> n
4134  ZeroExt(8, x)
4135  >>> n.sort()
4136  BitVec(24)
4137  >>> v0 = BitVecVal(2, 2)
4138  >>> v0
4139  2
4140  >>> v0.size()
4141  2
4142  >>> v = simplify(ZeroExt(6, v0))
4143  >>> v
4144  2
4145  >>> v.size()
4146  8
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 bit-vector expression")
4151  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4152 

Variable Documentation

◆ sat

Definition at line 6455 of file z3py.py.

◆ unknown

Definition at line 6457 of file z3py.py.

◆ unsat

Definition at line 6456 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:3092
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:9301
z3py.RNA
def RNA(ctx=None)
Definition: z3py.py:9015
z3py.fpLT
def fpLT(a, b, ctx=None)
Definition: z3py.py:9654
z3py.fpRoundToIntegral
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9599
z3py.RepeatBitVec
def RepeatBitVec(n, a)
Definition: z3py.py:4153
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:8806
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:9019
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:3120
z3py.is_distinct
def is_distinct(a)
Definition: z3py.py:1542
z3py.enable_trace
def enable_trace(msg)
Definition: z3py.py:67
Z3_mk_int_to_str
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
Z3_mk_re_complement
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
z3py.is_fprm
def is_fprm(a)
Definition: z3py.py:9043
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:9615
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:4994
Z3_mk_true
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
z3py.is_to_real
def is_to_real(a)
Definition: z3py.py:2743
z3py.fpBVToFP
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9786
z3py.fpMinusInfinity
def fpMinusInfinity(s)
Definition: z3py.py:9296
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:9390
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:4126
z3py.ParOr
def ParOr(*ts, **ks)
Definition: z3py.py:7821
z3py.IsMember
def IsMember(e, s)
Definition: z3py.py:4674
z3py.SetIntersect
def SetIntersect(*args)
Definition: z3py.py:4623
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:3150
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:5005
z3py.Strings
def Strings(names, ctx=None)
Definition: z3py.py:10119
z3py.is_fp
def is_fp(a)
Definition: z3py.py:9179
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:4556
z3py.RealSort
def RealSort(ctx=None)
Definition: z3py.py:2944
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:4313
z3py.FPVal
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9323
Z3_mk_fpa_sort_64
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
z3py.RealVarVector
def RealVarVector(n, ctx=None)
Definition: z3py.py:1373
z3py.fpToUBV
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9902
Z3_tactic_try_for
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms)
Return a tactic that applies t to a given goal for ms milliseconds. If t does not terminate in ms mil...
z3py.Consts
def Consts(names, sort)
Definition: z3py.py:1332
z3py.RTP
def RTP(ctx=None)
Definition: z3py.py:9023
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:10466
z3py.Var
def Var(idx, s)
Definition: z3py.py:1351
z3py.AtLeast
def AtLeast(*args)
Definition: z3py.py:8351
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:8101
z3py.SignExt
def SignExt(n, a)
Definition: z3py.py:4097
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:3488
z3py.BVSubNoOverflow
def BVSubNoOverflow(a, b)
Definition: z3py.py:4200
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:8606
z3py.reset_params
def reset_params()
Definition: z3py.py:263
z3py.ULT
def ULT(a, b)
Definition: z3py.py:3925
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:9027
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:3004
z3py.IntVal
def IntVal(val, ctx=None)
Definition: z3py.py:2975
z3py.SetDifference
def SetDifference(a, b)
Definition: z3py.py:4664
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:9748
z3py.fpGT
def fpGT(a, b, ctx=None)
Definition: z3py.py:9676
z3py.tactics
def tactics(ctx=None)
Definition: z3py.py:7910
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:9855
z3py.IsInt
def IsInt(a)
Definition: z3py.py:3167
z3py.RTN
def RTN(ctx=None)
Definition: z3py.py:9031
Z3_mk_set_del
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
z3py.is_arith_sort
def is_arith_sort(s)
Definition: z3py.py:2199
z3py.RotateLeft
def RotateLeft(a, b)
Definition: z3py.py:4067
Z3_mk_fpa_round_nearest_ties_to_even
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_even(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
z3py.Or
def Or(*args)
Definition: z3py.py:1732
Z3_mk_seq_suffix
Z3_ast Z3_API Z3_mk_seq_suffix(Z3_context c, Z3_ast suffix, Z3_ast s)
Check if suffix is a suffix of s.
z3py.TreeOrder
def TreeOrder(a, index)
Definition: z3py.py:10460
z3py.BoolVector
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1614
Z3_mk_xor
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
Z3_mk_bvneg_no_overflow
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.
z3py.Loop
def Loop(re, lo, hi=0)
Definition: z3py.py:10428
z3py.SubSeq
def SubSeq(s, offset, length)
Definition: z3py.py:10130
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:6954
z3py.With
def With(t, *args, **keys)
Definition: z3py.py:7857
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:4561
z3py.simplify
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8205
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:9993
z3py.is_gt
def is_gt(a)
Definition: z3py.py:2721
Z3_mk_finite_domain_sort
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.
Z3_mk_set_union
Z3_ast Z3_API Z3_mk_set_union(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the union of a list of sets.
Z3_mk_set_intersect
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.
z3py.Exists
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2082
z3py.is_implies
def is_implies(a)
Definition: z3py.py:1511
z3py.to_symbol
def to_symbol(s, ctx=None)
Definition: z3py.py:109
z3py.is_map
def is_map(a)
Definition: z3py.py:4354
z3py.is_or
def is_or(a)
Definition: z3py.py:1500
z3py.fpMul
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9520
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:9687
z3py.is_string_value
def is_string_value(a)
Definition: z3py.py:10096
z3py.is_app
def is_app(a)
Definition: z3py.py:1157
z3py.IndexOf
def IndexOf(s, substr)
Definition: z3py.py:10239
z3py.fpEQ
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9698
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:4036
z3py.is_default
def is_default(a)
Definition: z3py.py:4369
z3py.fpRem
def fpRem(a, b, ctx=None)
Definition: z3py.py:9548
z3py.substitute
def substitute(t, *m)
Definition: z3py.py:8237
z3py.Union
def Union(*args)
Definition: z3py.py:10352
z3py.fpMinusZero
def fpMinusZero(s)
Definition: z3py.py:9312
z3py.RotateRight
def RotateRight(a, b)
Definition: z3py.py:4082
z3py.FiniteDomainSort
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7244
z3py.is_ge
def is_ge(a)
Definition: z3py.py:2710
z3py.is_and
def is_and(a)
Definition: z3py.py:1489
Z3_mk_model
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_mk_re_loop
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...
z3py.MultiPattern
def MultiPattern(*args)
Definition: z3py.py:1797
Z3_mk_linear_order
Z3_func_decl Z3_API Z3_mk_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a linear ordering relation over signature a. The relation is identified by the index id.
Z3_is_as_array
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a)
The (_ as-array f) AST node is a construct for assigning interpretations for arrays in Z3....
z3py.PrefixOf
def PrefixOf(a, b)
Definition: z3py.py:10178
z3py.InRe
def InRe(s, re)
Definition: z3py.py:10339
Z3_mk_fpa_to_sbv
Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
Z3_mk_add
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].
z3py.z3_error_handler
def z3_error_handler(c, e)
Definition: z3py.py:156
z3py.And
def And(*args)
Definition: z3py.py:1700
z3py.UGE
def UGE(a, b)
Definition: z3py.py:3942
z3py.Cbrt
def Cbrt(a, ctx=None)
Definition: z3py.py:3195
z3py.disable_trace
def disable_trace(msg)
Definition: z3py.py:70
z3py.Float64
def Float64(ctx=None)
Definition: z3py.py:8772
z3py.BitVecVal
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3777
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:4342
z3py.Float32
def Float32(ctx=None)
Definition: z3py.py:8762
z3py.Range
def Range(lo, hi, ctx=None)
Definition: z3py.py:10440
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:8189
z3py.is_fp_value
def is_fp_value(a)
Definition: z3py.py:9192
z3py.is_finite_domain_sort
def is_finite_domain_sort(s)
Definition: z3py.py:7251
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:9575
z3py.RealVal
def RealVal(val, ctx=None)
Definition: z3py.py:2986
z3py.PbLe
def PbLe(args, k)
Definition: z3py.py:8393
z3py.solve
def solve(*args, **keywords)
Definition: z3py.py:8424
z3py.RoundNearestTiesToEven
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9003
Z3_mk_seq_unit
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
z3py.Const
def Const(name, sort)
Definition: z3py.py:1321
Z3_get_sort_kind
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_mk_pbeq
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_mk_numeral
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
z3py.ForAll
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2065
Z3_mk_bvadd_no_overflow
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.
z3py.fpToFPUnsigned
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9872
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:8787
z3py.eq
def eq(a, b)
Definition: z3py.py:432
z3py.fpAbs
def fpAbs(a, ctx=None)
Definition: z3py.py:9408
Z3_mk_bvredor
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
z3py.If
def If(a, b, c, ctx=None)
Definition: z3py.py:1268
Z3_mk_fpa_sort
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
Z3_mk_fpa_to_fp_unsigned
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.
z3py.set_default_rounding_mode
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8663
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:4317
Z3_mk_seq_length
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_mk_re_star
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
z3py.mk_not
def mk_not(a)
Definition: z3py.py:1687
Z3_mk_fpa_sort_quadruple
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_array_ext
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...
Z3_mk_map
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const *args)
Map f on the argument arrays.
z3py.get_as_array_func
def get_as_array_func(n)
Definition: z3py.py:6267
z3py.fpFMA
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9589
z3py.is_not
def is_not(a)
Definition: z3py.py:1522
z3py.Int
def Int(name, ctx=None)
Definition: z3py.py:3031
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:8233
z3py.EmptySet
def EmptySet(s)
Definition: z3py.py:4595
z3py.SuffixOf
def SuffixOf(a, b)
Definition: z3py.py:10192
z3py.fpSignedToFP
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9838
z3py.get_default_rounding_mode
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8649
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:8413
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:9055
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:4182
z3py.is_quantifier
def is_quantifier(a)
Definition: z3py.py:2018
Z3_mk_seq_last_index
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast, Z3_ast substr)
Return the last occurrence of substr in s. If s does not contain substr, then the value is -1,...
z3py.Length
def Length(s)
Definition: z3py.py:10268
z3py.get_ctx
def get_ctx(ctx)
Definition: z3py.py:237
z3py.BVAddNoOverflow
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4188
z3py.is_eq
def is_eq(a)
Definition: z3py.py:1533
Z3_mk_constructor
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort_opt const sorts[], unsigned sort_refs[])
Create a constructor.
z3py.fpIsNaN
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9604
z3py.URem
def URem(a, b)
Definition: z3py.py:3996
z3py.is_const
def is_const(a)
Definition: z3py.py:1182
z3py.Star
def Star(re)
Definition: z3py.py:10416
Z3_mk_fpa_sort_128
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_fpa_to_ieee_bv
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
z3py.is_real
def is_real(a)
Definition: z3py.py:2536
z3py.is_mod
def is_mod(a)
Definition: z3py.py:2677
z3py.Ints
def Ints(names, ctx=None)
Definition: z3py.py:3043
z3py.Model
def Model(ctx=None)
Definition: z3py.py:6259
z3py.Extract
def Extract(high, low, a)
Definition: z3py.py:3881
z3py.Int2BV
def Int2BV(a, num_bits)
Definition: z3py.py:3755
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:10225
z3py.FreshBool
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1628
z3py.Array
def Array(name, dom, rng)
Definition: z3py.py:4426
z3py.CreateDatatypes
def CreateDatatypes(*ds)
Definition: z3py.py:4805
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:9007
z3py.ParAndThen
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7853
z3py.BVAddNoUnderflow
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4194
z3py.FloatDouble
def FloatDouble(ctx=None)
Definition: z3py.py:8777
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:8752
z3py.Bools
def Bools(names, ctx=None)
Definition: z3py.py:1599
z3py.Intersect
def Intersect(*args)
Definition: z3py.py:10371
z3py.Sum
def Sum(*args)
Definition: z3py.py:8283
z3py.RoundNearestTiesToAway
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9011
z3py.is_pattern
def is_pattern(a)
Definition: z3py.py:1780
Z3_mk_re_range
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.
z3py.parse_smt2_file
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8626
z3py.substitute_vars
def substitute_vars(t, *m)
Definition: z3py.py:8263
Z3_mk_fresh_func_decl
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.
z3py.is_le
def is_le(a)
Definition: z3py.py:2688
z3py.help_simplify
def help_simplify()
Definition: z3py.py:8229
z3py.IsSubset
def IsSubset(a, b)
Definition: z3py.py:4684
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:1641
Z3_mk_seq_in_re
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.
Z3_mk_set_difference
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
Z3_mk_bvule
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
z3py.BVSDivNoOverflow
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4213
z3py.is_arith
def is_arith(a)
Definition: z3py.py:2498
z3py.BitVec
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3793
z3py.is_sort
def is_sort(s)
Definition: z3py.py:596
z3py.is_int_value
def is_int_value(a)
Definition: z3py.py:2560
Z3_mk_bool_sort
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
z3py.ToReal
def ToReal(a)
Definition: z3py.py:3133
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:3816
z3py.is_re
def is_re(s)
Definition: z3py.py:10335
z3py.is_int
def is_int(a)
Definition: z3py.py:2518
Z3_tactic_cond
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...
z3py.LastIndexOf
def LastIndexOf(s, substr)
Definition: z3py.py:10259
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:10089
z3py.Default
def Default(a)
Definition: z3py.py:4460
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:4377
z3py.Distinct
def Distinct(*args)
Definition: z3py.py:1290
z3py.fpIsNormal
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9630
z3py.FreshConst
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346
z3py.PbGe
def PbGe(args, k)
Definition: z3py.py:8403
Z3_tactic_repeat
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...
Z3_mk_ext_rotate_right
Z3_ast Z3_API Z3_mk_ext_rotate_right(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the right t2 times.
Z3_mk_fpa_sort_32
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
z3py.z3_debug
def z3_debug()
Definition: z3py.py:56
z3py.is_true
def is_true(a)
Definition: z3py.py:1459
Z3_mk_const
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
z3py.SetSort
def SetSort(s)
Sets.
Definition: z3py.py:4591
z3py.Real
def Real(name, ctx=None)
Definition: z3py.py:3080
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:8111
z3py.Lambda
def Lambda(vs, body)
Definition: z3py.py:2102
z3py.tactic_description
def tactic_description(name, ctx=None)
Definition: z3py.py:7920
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:10106
z3py.StrToInt
def StrToInt(s)
Definition: z3py.py:10277
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:9720
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:9307
z3py.fpNaN
def fpNaN(s)
Definition: z3py.py:9264
z3py.FPSort
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9206
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:10174
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:7273
z3py.fpZero
def fpZero(s, negative)
Definition: z3py.py:9317
z3py.fpSqrt
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9594
Z3_mk_seq_replace
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.
z3py.RealVar
def RealVar(idx, ctx=None)
Definition: z3py.py:1363
z3py.FP
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9367
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:9534
z3py.is_as_array
def is_as_array(n)
Definition: z3py.py:6263
z3py.set_default_fp_sort
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8679
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:10463
z3py.is_store
def is_store(a)
Definition: z3py.py:4573
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:4487
z3py.FreshFunction
def FreshFunction(*sig)
Definition: z3py.py:821
z3py.AtMost
def AtMost(*args)
Definition: z3py.py:8334
z3py.RecAddDefinition
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
z3py.fpToSBV
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9881
z3py.is_div
def is_div(a)
Definition: z3py.py:2650
Z3_mk_string_sort
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for 8 bit strings.
Z3_probe_not
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
z3py.Re
def Re(s, ctx=None)
Definition: z3py.py:10300
z3py.FullSet
def FullSet(s)
Definition: z3py.py:4603
z3py.OrElse
def OrElse(*ts, **ks)
Definition: z3py.py:7801
z3py.is_probe
def is_probe(p)
Definition: z3py.py:8085
Z3_mk_array_sort
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
z3py.is_mul
def is_mul(a)
Definition: z3py.py:2628
Z3_mk_int2bv
Z3_ast Z3_API Z3_mk_int2bv(Z3_context c, unsigned n, Z3_ast t1)
Create an n bit bit-vector from the integer argument t1.
z3py.FreshInt
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3067
z3py.fpPlusInfinity
def fpPlusInfinity(s)
Definition: z3py.py:9280
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:8452
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:10388
z3py.append_log
def append_log(s)
Definition: z3py.py:105
z3py.FiniteDomainVal
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7312
z3py.Float128
def Float128(ctx=None)
Definition: z3py.py:8782
z3py.is_add
def is_add(a)
Definition: z3py.py:2617
z3py.Then
def Then(*ts, **ks)
Definition: z3py.py:7789
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:10457
z3py.ArraySort
def ArraySort(*sig)
Definition: z3py.py:4394
z3py.BitVecSort
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3763
z3py.fpAdd
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9490
z3py.Contains
def Contains(a, b)
Definition: z3py.py:10206
z3py.is_finite_domain_value
def is_finite_domain_value(a)
Definition: z3py.py:7326
z3py.Bool
def Bool(name, ctx=None)
Definition: z3py.py:1588
z3py.SetUnion
def SetUnion(*args)
Definition: z3py.py:4611
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:9506
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:4330
z3py.Product
def Product(*args)
Definition: z3py.py:8309
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:10293
z3py.TryFor
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7902
z3py.SetDel
def SetDel(s, e)
Definition: z3py.py:4645
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:4016
z3py.get_var_index
def get_var_index(a)
Definition: z3py.py:1224
z3py.fpNeg
def fpNeg(a, ctx=None)
Definition: z3py.py:9430
z3py.fpLEQ
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9665
z3py.EnumSort
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5017
z3py.BoolVal
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
z3py.is_ast
def is_ast(a)
Definition: z3py.py:412
z3py.get_default_fp_sort
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8676
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:3719
z3py.is_idiv
def is_idiv(a)
Definition: z3py.py:2666
Z3_mk_sign_ext
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...
z3py.Concat
def Concat(*args)
Definition: z3py.py:3836
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:6934
z3py.describe_probes
def describe_probes()
Definition: z3py.py:8119
Z3_mk_pble
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
z3py.Not
def Not(a, ctx=None)
Definition: z3py.py:1669
Z3_substitute
Z3_ast Z3_API Z3_substitute(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const from[], Z3_ast const to[])
Substitute every occurrence of from[i] in a with to[i], for i smaller than num_exprs....
Z3_mk_simple_solver
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
z3py.K
def K(dom, v)
Definition: z3py.py:4524
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:4176
z3py.is_fp_sort
def is_fp_sort(s)
Definition: z3py.py:8796
z3py.is_var
def is_var(a)
Definition: z3py.py:1200
Z3_open_log
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.
z3py.BVSNegNoOverflow
def BVSNegNoOverflow(a)
Definition: z3py.py:4219
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:3055
z3py.is_bv_sort
def is_bv_sort(s)
Definition: z3py.py:3245
z3py.Full
def Full(s)
Definition: z3py.py:10160
Z3_mk_fpa_sort_half
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
Z3_mk_not
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
z3py.is_is_int
def is_is_int(a)
Definition: z3py.py:2732
z3py.AndThen
def AndThen(*ts, **ks)
Definition: z3py.py:7770
z3py.IntSort
def IntSort(ctx=None)
Definition: z3py.py:2928
z3py.fpIsZero
def fpIsZero(a, ctx=None)
Definition: z3py.py:9625
z3py.is_rational_value
def is_rational_value(a)
Definition: z3py.py:2583
z3py.PartialOrder
def PartialOrder(a, index)
Definition: z3py.py:10454
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:3959
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:3976
z3py.BV2Int
def BV2Int(a, is_signed=False)
Definition: z3py.py:3733
z3py.is_func_decl
def is_func_decl(a)
Definition: z3py.py:787
z3py.RoundTowardZero
def RoundTowardZero(ctx=None)
Definition: z3py.py:9035
z3py.WithParams
def WithParams(t, p)
Definition: z3py.py:7870
z3py.RecFunction
def RecFunction(name, *sig)
Definition: z3py.py:843
z3py.Xor
def Xor(a, b, ctx=None)
Definition: z3py.py:1654
Z3_mk_fpa_sort_16
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
z3py.is_algebraic_value
def is_algebraic_value(a)
Definition: z3py.py:2604
z3py.BVMulNoUnderflow
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4232
z3py.is_to_int
def is_to_int(a)
Definition: z3py.py:2757
Z3_mk_fpa_abs
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
Z3_mk_is_int
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
Z3_mk_fpa_nan
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
Z3_global_param_set
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.
z3py.prove
def prove(claim, **keywords)
Definition: z3py.py:8481
z3py.is_bv
def is_bv(a)
Definition: z3py.py:3706
z3py.fpMin
def fpMin(a, b, ctx=None)
Definition: z3py.py:9561
Z3_mk_bvsdiv_no_overflow
Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed division of t1 and t2 does not overflow.
Z3_mk_bvuge
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_mk_array_sort_n
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const *domain, Z3_sort range)
Create an array type with N arguments.
z3py.is_expr
def is_expr(a)
Definition: z3py.py:1135
z3py.Sqrt
def Sqrt(a, ctx=None)
Definition: z3py.py:3183
z3py.SetComplement
def SetComplement(s)
Definition: z3py.py:4655
z3py.is_app_of
def is_app_of(a, k)
Definition: z3py.py:1256
z3py.BVMulNoOverflow
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4225
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:7883
z3py.fpToReal
def fpToReal(x, ctx=None)
Definition: z3py.py:9923
z3py.Update
def Update(a, i, v)
Definition: z3py.py:4439
z3py.describe_tactics
def describe_tactics()
Definition: z3py.py:7928
z3py.is_bool
def is_bool(a)
Definition: z3py.py:1442
z3py.get_full_version
def get_full_version()
Definition: z3py.py:89
Z3_mk_atmost
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
z3py.is_lt
def is_lt(a)
Definition: z3py.py:2699
Z3_mk_bvsrem
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
Z3_mk_uninterpreted_sort
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
z3py.FloatHalf
def FloatHalf(ctx=None)
Definition: z3py.py:8757
z3py.fpIsSubnormal
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9635
z3py.SetAdd
def SetAdd(s, e)
Definition: z3py.py:4635
z3py.Ext
def Ext(a, b)
Definition: z3py.py:4545
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:9640
z3py.fpFPToFP
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9802
z3py.fpNEQ
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9709
z3py.SeqSort
def SeqSort(s)
Definition: z3py.py:10003
z3py.Map
def Map(f, *args)
Definition: z3py.py:4502
z3py.BVSubNoUnderflow
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4207
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:7839
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:5093
Z3_mk_pbge
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
z3py.is_false
def is_false(a)
Definition: z3py.py:1476
z3py.Store
def Store(a, i, v)
Definition: z3py.py:4471
z3py.FloatSingle
def FloatSingle(ctx=None)
Definition: z3py.py:8767
z3py.ULE
def ULE(a, b)
Definition: z3py.py:3908
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:8152
Z3_mk_fpa_sort_single
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
Z3_mk_re_empty
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
z3py.BoolSort
def BoolSort(ctx=None)
Definition: z3py.py:1553
z3py.get_param
def get_param(name)
Definition: z3py.py:273
z3py.fpRealToFP
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9821
z3py.Complement
def Complement(re)
Definition: z3py.py:10412
z3py.RealVector
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3106
z3py.Empty
def Empty(s)
Definition: z3py.py:10141
z3py.Option
def Option(re)
Definition: z3py.py:10400
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:9645
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:10320
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:9039
z3py.is_sub
def is_sub(a)
Definition: z3py.py:2639
Z3_mk_seq_extract
Z3_ast Z3_API Z3_mk_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.
z3py.set_option
def set_option(*args, **kws)
Definition: z3py.py:268
z3py.SubString
def SubString(s, offset, length)
Definition: z3py.py:10126
z3py.When
def When(p, t, ctx=None)
Definition: z3py.py:8171
z3py.is_seq
def is_seq(a)
Definition: z3py.py:10080
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:9942
z3py.Q
def Q(a, b, ctx=None)
Definition: z3py.py:3019
z3py.String
def String(name, ctx=None)
Definition: z3py.py:10111
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.