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  CharRef
 
class  CharSortRef
 
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
 
class  FPRef
 
class  FPRMRef
 
class  FPRMSortRef
 
class  FPSortRef
 
class  FuncDeclRef
 Function Declarations. More...
 
class  FuncEntry
 
class  FuncInterp
 
class  Goal
 
class  IntNumRef
 
class  ModelRef
 
class  OnClause
 
class  Optimize
 
class  OptimizeObjective
 Optimize. More...
 
class  ParamDescrsRef
 
class  ParamsRef
 Parameter Sets. More...
 
class  ParserContext
 
class  PatternRef
 Patterns. More...
 
class  Probe
 
class  PropClosures
 
class  QuantifierRef
 Quantifiers. More...
 
class  RatNumRef
 
class  ReRef
 
class  ReSortRef
 
class  ScopedConstructor
 
class  ScopedConstructorList
 
class  SeqRef
 
class  SeqSortRef
 Strings, Sequences and Regular expressions. More...
 
class  Simplifier
 
class  Solver
 
class  SortRef
 
class  Statistics
 Statistics. More...
 
class  Tactic
 
class  UserPropagateBase
 
class  Z3PPObject
 ASTs base class. More...
 

Functions

def z3_debug ()
 
def enable_trace (msg)
 
def disable_trace (msg)
 
def get_version_string ()
 
def get_version ()
 
def get_full_version ()
 
def open_log (fname)
 
def append_log (s)
 
def to_symbol
 
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
 
def is_func_decl (a)
 
def Function (name, sig)
 
def FreshFunction (sig)
 
def RecFunction (name, sig)
 
def RecAddDefinition (f, args, body)
 
def deserialize (st)
 
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
 
def Distinct (args)
 
def Const (name, sort)
 
def Consts (names, sort)
 
def FreshConst
 
def Var (idx, s)
 
def RealVar
 
def RealVarVector
 
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
 
def BoolVal
 
def Bool
 
def Bools
 
def BoolVector
 
def FreshBool
 
def Implies
 
def Xor
 
def Not
 
def mk_not (a)
 
def And (args)
 
def Or (args)
 
def is_pattern (a)
 
def MultiPattern (args)
 
def is_quantifier (a)
 
def ForAll
 
def Exists
 
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
 
def RealSort
 
def IntVal
 
def RealVal
 
def RatVal
 
def Q
 
def Int
 
def Ints
 
def IntVector
 
def FreshInt
 
def Real
 
def Reals
 
def RealVector
 
def FreshReal
 
def ToReal (a)
 
def ToInt (a)
 
def IsInt (a)
 
def Sqrt
 
def Cbrt
 
def is_bv_sort (s)
 
def is_bv (a)
 
def is_bv_value (a)
 
def BV2Int
 
def Int2BV (a, num_bits)
 
def BitVecSort
 
def BitVecVal
 
def BitVec
 
def BitVecs
 
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, sorts)
 
def Update (a, args)
 
def Default (a)
 
def Store (a, args)
 
def Select (a, args)
 
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 DatatypeSort
 
def TupleSort
 
def DisjointSum
 
def EnumSort
 
def args2params
 
def Model
 
def is_as_array (n)
 
def get_as_array_func (n)
 
def SolverFor
 
def SimpleSolver
 
def FiniteDomainSort
 
def is_finite_domain_sort (s)
 
def is_finite_domain (a)
 
def FiniteDomainVal
 
def is_finite_domain_value (a)
 
def AndThen (ts, ks)
 
def Then (ts, ks)
 
def OrElse (ts, ks)
 
def ParOr (ts, ks)
 
def ParThen
 
def ParAndThen
 
def With (t, args, keys)
 
def WithParams (t, p)
 
def Repeat
 
def TryFor
 
def tactics
 
def tactic_description
 
def describe_tactics ()
 
def is_probe (p)
 
def probes
 
def probe_description
 
def describe_probes ()
 
def FailIf
 
def When
 
def Cond
 
def simplify (a, arguments, keywords)
 Utils. More...
 
def help_simplify ()
 
def simplify_param_descrs ()
 
def substitute (t, m)
 
def substitute_vars (t, m)
 
def substitute_funs (t, m)
 
def Sum (args)
 
def Product (args)
 
def Abs (arg)
 
def AtMost (args)
 
def AtLeast (args)
 
def PbLe (args, k)
 
def PbGe (args, k)
 
def PbEq
 
def solve (args, keywords)
 
def solve_using (s, args, keywords)
 
def prove (claim, show=False, keywords)
 
def parse_smt2_string
 
def parse_smt2_file
 
def get_default_rounding_mode
 
def set_default_rounding_mode
 
def get_default_fp_sort
 
def set_default_fp_sort
 
def Float16
 
def FloatHalf
 
def Float32
 
def FloatSingle
 
def Float64
 
def FloatDouble
 
def Float128
 
def FloatQuadruple
 
def is_fp_sort (s)
 
def is_fprm_sort (s)
 
def RoundNearestTiesToEven
 
def RNE
 
def RoundNearestTiesToAway
 
def RNA
 
def RoundTowardPositive
 
def RTP
 
def RoundTowardNegative
 
def RTN
 
def RoundTowardZero
 
def RTZ
 
def is_fprm (a)
 
def is_fprm_value (a)
 
def is_fp (a)
 
def is_fp_value (a)
 
def FPSort
 
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
 
def FP
 
def FPs
 
def fpAbs
 
def fpNeg
 
def fpAdd
 
def fpSub
 
def fpMul
 
def fpDiv
 
def fpRem
 
def fpMin
 
def fpMax
 
def fpFMA
 
def fpSqrt
 
def fpRoundToIntegral
 
def fpIsNaN
 
def fpIsInf
 
def fpIsZero
 
def fpIsNormal
 
def fpIsSubnormal
 
def fpIsNegative
 
def fpIsPositive
 
def fpLT
 
def fpLEQ
 
def fpGT
 
def fpGEQ
 
def fpEQ
 
def fpNEQ
 
def fpFP
 
def fpToFP
 
def fpBVToFP
 
def fpFPToFP
 
def fpRealToFP
 
def fpSignedToFP
 
def fpUnsignedToFP
 
def fpToFPUnsigned
 
def fpToSBV
 
def fpToUBV
 
def fpToReal
 
def fpToIEEEBV
 
def StringSort
 
def CharSort
 
def SeqSort (s)
 
def CharVal
 
def CharFromBv
 
def CharToBv
 
def CharToInt
 
def CharIsDigit
 
def is_seq (a)
 
def is_string (a)
 
def is_string_value (a)
 
def StringVal
 
def String
 
def Strings
 
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
 
def LastIndexOf (s, substr)
 
def Length (s)
 
def StrToInt (s)
 
def IntToStr (s)
 
def StrToCode (s)
 
def StrFromCode (c)
 
def Re
 
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
 
def Range
 
def Diff
 
def AllChar
 
def PartialOrder (a, index)
 
def LinearOrder (a, index)
 
def TreeOrder (a, index)
 
def PiecewiseLinearOrder (a, index)
 
def TransitiveClosure (f)
 
def to_Ast (ptr)
 
def to_ContextObj (ptr)
 
def to_AstVectorObj (ptr)
 
def on_clause_eh (ctx, p, clause)
 
def ensure_prop_closures ()
 
def user_prop_push (ctx, cb)
 
def user_prop_pop (ctx, cb, num_scopes)
 
def user_prop_fresh (ctx, _new_ctx)
 
def user_prop_fixed (ctx, cb, id, value)
 
def user_prop_created (ctx, cb, id)
 
def user_prop_final (ctx, cb)
 
def user_prop_eq (ctx, cb, x, y)
 
def user_prop_diseq (ctx, cb, x, y)
 
def user_prop_decide (ctx, cb, t_ref, idx_ref, phase_ref)
 
def PropagateFunction (name, sig)
 

Variables

 Z3_DEBUG = __debug__
 
 _main_ctx = None
 
tuple sat = CheckSatResult(Z3_L_TRUE)
 
tuple unsat = CheckSatResult(Z3_L_FALSE)
 
tuple unknown = CheckSatResult(Z3_L_UNDEF)
 
dictionary _on_models = {}
 
tuple _on_model_eh = on_model_eh_type(_global_on_model)
 
 _dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN
 Floating-Point Arithmetic. More...
 
int _dflt_fpsort_ebits = 11
 
int _dflt_fpsort_sbits = 53
 
tuple _ROUNDING_MODES
 
 _my_hacky_class = None
 
tuple _on_clause_eh = Z3_on_clause_eh(on_clause_eh)
 
 _prop_closures = None
 
tuple _user_prop_push = Z3_push_eh(user_prop_push)
 
tuple _user_prop_pop = Z3_pop_eh(user_prop_pop)
 
tuple _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)
 
tuple _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)
 
tuple _user_prop_created = Z3_created_eh(user_prop_created)
 
tuple _user_prop_final = Z3_final_eh(user_prop_final)
 
tuple _user_prop_eq = Z3_eq_eh(user_prop_eq)
 
tuple _user_prop_diseq = Z3_eq_eh(user_prop_diseq)
 
tuple _user_prop_decide = Z3_decide_eh(user_prop_decide)
 

Function Documentation

def z3py.Abs (   arg)
Create the absolute value of an arithmetic expression

Definition at line 8980 of file z3py.py.

8980 def Abs(arg):
8981  """Create the absolute value of an arithmetic expression"""
8982  return If(arg > 0, arg, -arg)
8983 
8984 
def If
Definition: z3py.py:1377
def Abs(arg)
Definition: z3py.py:8980
def z3py.AllChar (   regex_sort,
  ctx = None 
)
Create a regular expression that accepts all single character strings

Definition at line 11346 of file z3py.py.

11346 def AllChar(regex_sort, ctx=None):
11347  """Create a regular expression that accepts all single character strings
11348  """
11349  return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11350 
11351 # Special Relations
11352 
11353 
Z3_ast Z3_API Z3_mk_re_allchar(Z3_context c, Z3_sort regex_sort)
Create a regular expression that accepts all singleton sequences of the regular expression sort...
def AllChar
Definition: z3py.py:11346
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 1845 of file z3py.py.

Referenced by Fixedpoint.add_rule(), Goal.as_expr(), Bool(), Bools(), BoolVector(), Lambda(), Fixedpoint.query(), Fixedpoint.query_from_lvl(), and Fixedpoint.update_rule().

1845 def And(*args):
1846  """Create a Z3 and-expression or and-probe.
1847 
1848  >>> p, q, r = Bools('p q r')
1849  >>> And(p, q, r)
1850  And(p, q, r)
1851  >>> P = BoolVector('p', 5)
1852  >>> And(P)
1853  And(p__0, p__1, p__2, p__3, p__4)
1854  """
1855  last_arg = None
1856  if len(args) > 0:
1857  last_arg = args[len(args) - 1]
1858  if isinstance(last_arg, Context):
1859  ctx = args[len(args) - 1]
1860  args = args[:len(args) - 1]
1861  elif len(args) == 1 and isinstance(args[0], AstVector):
1862  ctx = args[0].ctx
1863  args = [a for a in args[0]]
1864  else:
1865  ctx = None
1866  args = _get_args(args)
1867  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1868  if z3_debug():
1869  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1870  if _has_probe(args):
1871  return _probe_and(args, ctx)
1872  else:
1873  args = _coerce_expr_list(args, ctx)
1874  _args, sz = _to_ast_array(args)
1875  return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1876 
1877 
def And(args)
Definition: z3py.py:1845
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].
def z3_debug()
Definition: z3py.py:62
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 8345 of file z3py.py.

Referenced by Then().

8345 def AndThen(*ts, **ks):
8346  """Return a tactic that applies the tactics in `*ts` in sequence.
8347 
8348  >>> x, y = Ints('x y')
8349  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8350  >>> t(And(x == 0, y > x + 1))
8351  [[Not(y <= 1)]]
8352  >>> t(And(x == 0, y > x + 1)).as_expr()
8353  Not(y <= 1)
8354  """
8355  if z3_debug():
8356  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8357  ctx = ks.get("ctx", None)
8358  num = len(ts)
8359  r = ts[0]
8360  for i in range(num - 1):
8361  r = _and_then(r, ts[i + 1], ctx)
8362  return r
8363 
8364 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def AndThen(ts, ks)
Definition: z3py.py:8345
def z3_debug()
Definition: z3py.py:62
def z3py.append_log (   s)
Append user-defined string to interaction log. 

Definition at line 119 of file z3py.py.

119 def append_log(s):
120  """Append user-defined string to interaction log. """
121  Z3_append_log(s)
122 
123 
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.
def append_log(s)
Definition: z3py.py:119
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 5458 of file z3py.py.

Referenced by Tactic.apply(), Fixedpoint.set(), Optimize.set(), simplify(), Simplifier.using_params(), and With().

5458 def args2params(arguments, keywords, ctx=None):
5459  """Convert python arguments into a Z3_params object.
5460  A ':' is added to the keywords, and '_' is replaced with '-'
5461 
5462  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5463  (params model true relevancy 2 elim_and true)
5464  """
5465  if z3_debug():
5466  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5467  prev = None
5468  r = ParamsRef(ctx)
5469  for a in arguments:
5470  if prev is None:
5471  prev = a
5472  else:
5473  r.set(prev, a)
5474  prev = None
5475  for k in keywords:
5476  v = keywords[k]
5477  r.set(k, v)
5478  return r
5479 
5480 
def args2params
Definition: z3py.py:5458
Parameter Sets.
Definition: z3py.py:5412
def z3_debug()
Definition: z3py.py:62
def z3py.Array (   name,
  sorts 
)
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 4725 of file z3py.py.

Referenced by ArrayRef.__getitem__(), ArraySort(), ArrayRef.domain(), get_map_func(), is_array(), is_const_array(), is_K(), is_map(), is_select(), is_store(), K(), Lambda(), Map(), ArrayRef.range(), Select(), ArrayRef.sort(), Store(), and Update().

4725 def Array(name, *sorts):
4726  """Return an array constant named `name` with the given domain and range sorts.
4727 
4728  >>> a = Array('a', IntSort(), IntSort())
4729  >>> a.sort()
4730  Array(Int, Int)
4731  >>> a[0]
4732  a[0]
4733  """
4734  s = ArraySort(sorts)
4735  ctx = s.ctx
4736  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4737 
4738 
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def ArraySort(sig)
Definition: z3py.py:4692
def Array(name, sorts)
Definition: z3py.py:4725
def to_symbol
Definition: z3py.py:124
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 4692 of file z3py.py.

Referenced by Array(), ArraySortRef.domain(), and ArraySortRef.range().

4692 def ArraySort(*sig):
4693  """Return the Z3 array sort with the given domain and range sorts.
4694 
4695  >>> A = ArraySort(IntSort(), BoolSort())
4696  >>> A
4697  Array(Int, Bool)
4698  >>> A.domain()
4699  Int
4700  >>> A.range()
4701  Bool
4702  >>> AA = ArraySort(IntSort(), A)
4703  >>> AA
4704  Array(Int, Array(Int, Bool))
4705  """
4706  sig = _get_args(sig)
4707  if z3_debug():
4708  _z3_assert(len(sig) > 1, "At least two arguments expected")
4709  arity = len(sig) - 1
4710  r = sig[arity]
4711  d = sig[0]
4712  if z3_debug():
4713  for s in sig:
4714  _z3_assert(is_sort(s), "Z3 sort expected")
4715  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4716  ctx = d.ctx
4717  if len(sig) == 2:
4718  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4719  dom = (Sort * arity)()
4720  for i in range(arity):
4721  dom[i] = sig[i].ast
4722  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4723 
4724 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def ArraySort(sig)
Definition: z3py.py:4692
Arrays.
Definition: z3py.py:4513
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
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.
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
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 9003 of file z3py.py.

9003 def AtLeast(*args):
9004  """Create an at-most Pseudo-Boolean k constraint.
9005 
9006  >>> a, b, c = Bools('a b c')
9007  >>> f = AtLeast(a, b, c, 2)
9008  """
9009  args = _get_args(args)
9010  if z3_debug():
9011  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9012  ctx = _ctx_from_ast_arg_list(args)
9013  if z3_debug():
9014  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9015  args1 = _coerce_expr_list(args[:-1], ctx)
9016  k = args[-1]
9017  _args, sz = _to_ast_array(args1)
9018  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9019 
9020 
def AtLeast(args)
Definition: z3py.py:9003
def z3_debug()
Definition: z3py.py:62
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
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 8985 of file z3py.py.

8985 def AtMost(*args):
8986  """Create an at-most Pseudo-Boolean k constraint.
8987 
8988  >>> a, b, c = Bools('a b c')
8989  >>> f = AtMost(a, b, c, 2)
8990  """
8991  args = _get_args(args)
8992  if z3_debug():
8993  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8994  ctx = _ctx_from_ast_arg_list(args)
8995  if z3_debug():
8996  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8997  args1 = _coerce_expr_list(args[:-1], ctx)
8998  k = args[-1]
8999  _args, sz = _to_ast_array(args1)
9000  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9001 
9002 
def AtMost(args)
Definition: z3py.py:8985
def z3_debug()
Definition: z3py.py:62
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
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 4029 of file z3py.py.

Referenced by BitVecRef.__add__(), BitVecRef.__and__(), BitVecRef.__div__(), BitVecRef.__invert__(), BitVecRef.__mod__(), BitVecRef.__mul__(), BitVecRef.__neg__(), BitVecRef.__or__(), BitVecRef.__pos__(), BitVecRef.__radd__(), BitVecRef.__rand__(), BitVecRef.__rdiv__(), BitVecRef.__rlshift__(), BitVecRef.__rmod__(), BitVecRef.__rmul__(), BitVecRef.__ror__(), BitVecRef.__rrshift__(), BitVecRef.__rsub__(), BitVecRef.__rxor__(), BitVecRef.__sub__(), BitVecRef.__xor__(), BitVecs(), BitVecSort(), BV2Int(), Extract(), is_bv(), is_bv_value(), RepeatBitVec(), SignExt(), BitVecRef.size(), BitVecRef.sort(), SRem(), UDiv(), URem(), and ZeroExt().

4029 def BitVec(name, bv, ctx=None):
4030  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4031  If `ctx=None`, then the global context is used.
4032 
4033  >>> x = BitVec('x', 16)
4034  >>> is_bv(x)
4035  True
4036  >>> x.size()
4037  16
4038  >>> x.sort()
4039  BitVec(16)
4040  >>> word = BitVecSort(16)
4041  >>> x2 = BitVec('x', word)
4042  >>> eq(x, x2)
4043  True
4044  """
4045  if isinstance(bv, BitVecSortRef):
4046  ctx = bv.ctx
4047  else:
4048  ctx = _get_ctx(ctx)
4049  bv = BitVecSort(bv, ctx)
4050  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4051 
4052 
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def BitVecSort
Definition: z3py.py:3997
def BitVec
Definition: z3py.py:4029
def to_symbol
Definition: z3py.py:124
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 4053 of file z3py.py.

Referenced by BitVecRef.__ge__(), BitVecRef.__gt__(), BitVecRef.__le__(), BitVecRef.__lshift__(), BitVecRef.__lt__(), BitVecRef.__rshift__(), LShR(), RotateLeft(), RotateRight(), UGE(), UGT(), ULE(), and ULT().

4053 def BitVecs(names, bv, ctx=None):
4054  """Return a tuple of bit-vector constants of size bv.
4055 
4056  >>> x, y, z = BitVecs('x y z', 16)
4057  >>> x.size()
4058  16
4059  >>> x.sort()
4060  BitVec(16)
4061  >>> Sum(x, y, z)
4062  0 + x + y + z
4063  >>> Product(x, y, z)
4064  1*x*y*z
4065  >>> simplify(Product(x, y, z))
4066  x*y*z
4067  """
4068  ctx = _get_ctx(ctx)
4069  if isinstance(names, str):
4070  names = names.split(" ")
4071  return [BitVec(name, bv, ctx) for name in names]
4072 
4073 
def BitVec
Definition: z3py.py:4029
def BitVecs
Definition: z3py.py:4053
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 3997 of file z3py.py.

Referenced by BitVec(), BitVecSortRef.cast(), fpSignedToFP(), fpToFP(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), is_bv_sort(), BitVecSortRef.size(), and BitVecRef.sort().

3997 def BitVecSort(sz, ctx=None):
3998  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3999 
4000  >>> Byte = BitVecSort(8)
4001  >>> Word = BitVecSort(16)
4002  >>> Byte
4003  BitVec(8)
4004  >>> x = Const('x', Byte)
4005  >>> eq(x, BitVec('x', 8))
4006  True
4007  """
4008  ctx = _get_ctx(ctx)
4009  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4010 
4011 
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
def BitVecSort
Definition: z3py.py:3997
Bit-Vectors.
Definition: z3py.py:3435
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 4012 of file z3py.py.

Referenced by BitVecRef.__lshift__(), BitVecRef.__rshift__(), BitVecNumRef.as_long(), BitVecNumRef.as_signed_long(), Concat(), fpBVToFP(), fpFP(), fpSignedToFP(), fpToFP(), fpUnsignedToFP(), is_bv_value(), LShR(), RepeatBitVec(), SignExt(), and ZeroExt().

4012 def BitVecVal(val, bv, ctx=None):
4013  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4014 
4015  >>> v = BitVecVal(10, 32)
4016  >>> v
4017  10
4018  >>> print("0x%.8x" % v.as_long())
4019  0x0000000a
4020  """
4021  if is_bv_sort(bv):
4022  ctx = bv.ctx
4023  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4024  else:
4025  ctx = _get_ctx(ctx)
4026  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4027 
4028 
def BitVecSort
Definition: z3py.py:3997
def BitVecVal
Definition: z3py.py:4012
def is_bv_sort(s)
Definition: z3py.py:3468
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
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 1724 of file z3py.py.

Referenced by Solver.assert_and_track(), Optimize.assert_and_track(), and Not().

1724 def Bool(name, ctx=None):
1725  """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1726 
1727  >>> p = Bool('p')
1728  >>> q = Bool('q')
1729  >>> And(p, q)
1730  And(p, q)
1731  """
1732  ctx = _get_ctx(ctx)
1733  return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1734 
1735 
def BoolSort
Definition: z3py.py:1687
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def Bool
Definition: z3py.py:1724
def to_symbol
Definition: z3py.py:124
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 1736 of file z3py.py.

Referenced by And(), Solver.consequences(), Implies(), Or(), Solver.unsat_core(), and Xor().

1736 def Bools(names, ctx=None):
1737  """Return a tuple of Boolean constants.
1738 
1739  `names` is a single string containing all names separated by blank spaces.
1740  If `ctx=None`, then the global context is used.
1741 
1742  >>> p, q, r = Bools('p q r')
1743  >>> And(p, Or(q, r))
1744  And(p, Or(q, r))
1745  """
1746  ctx = _get_ctx(ctx)
1747  if isinstance(names, str):
1748  names = names.split(" ")
1749  return [Bool(name, ctx) for name in names]
1750 
1751 
def Bools
Definition: z3py.py:1736
def Bool
Definition: z3py.py:1724
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 1687 of file z3py.py.

Referenced by ArrayRef.__getitem__(), ArraySort(), Fixedpoint.assert_exprs(), Optimize.assert_exprs(), Bool(), ArraySortRef.domain(), ArrayRef.domain(), If(), IntSort(), is_arith_sort(), ArraySortRef.range(), ArrayRef.range(), and ArrayRef.sort().

1687 def BoolSort(ctx=None):
1688  """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1689 
1690  >>> BoolSort()
1691  Bool
1692  >>> p = Const('p', BoolSort())
1693  >>> is_bool(p)
1694  True
1695  >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1696  >>> r(0, 1)
1697  r(0, 1)
1698  >>> is_bool(r(0, 1))
1699  True
1700  """
1701  ctx = _get_ctx(ctx)
1702  return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1703 
1704 
def BoolSort
Definition: z3py.py:1687
def is_bool(a)
Definition: z3py.py:1567
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 1705 of file z3py.py.

Referenced by ApplyResult.as_expr(), BoolSortRef.cast(), Re(), and Solver.to_smt2().

1705 def BoolVal(val, ctx=None):
1706  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1707 
1708  >>> BoolVal(True)
1709  True
1710  >>> is_true(BoolVal(True))
1711  True
1712  >>> is_true(True)
1713  False
1714  >>> is_false(BoolVal(False))
1715  True
1716  """
1717  ctx = _get_ctx(ctx)
1718  if val:
1719  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1720  else:
1721  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1722 
1723 
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
def BoolVal
Definition: z3py.py:1705
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 1752 of file z3py.py.

Referenced by And(), and Or().

1752 def BoolVector(prefix, sz, ctx=None):
1753  """Return a list of Boolean constants of size `sz`.
1754 
1755  The constants are named using the given prefix.
1756  If `ctx=None`, then the global context is used.
1757 
1758  >>> P = BoolVector('p', 3)
1759  >>> P
1760  [p__0, p__1, p__2]
1761  >>> And(P)
1762  And(p__0, p__1, p__2)
1763  """
1764  return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1765 
1766 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Bool
Definition: z3py.py:1724
def BoolVector
Definition: z3py.py:1752
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 3965 of file z3py.py.

3965 def BV2Int(a, is_signed=False):
3966  """Return the Z3 expression BV2Int(a).
3967 
3968  >>> b = BitVec('b', 3)
3969  >>> BV2Int(b).sort()
3970  Int
3971  >>> x = Int('x')
3972  >>> x > BV2Int(b)
3973  x > BV2Int(b)
3974  >>> x > BV2Int(b, is_signed=False)
3975  x > BV2Int(b)
3976  >>> x > BV2Int(b, is_signed=True)
3977  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3978  >>> solve(x > BV2Int(b), b == 1, x < 3)
3979  [x = 2, b = 1]
3980  """
3981  if z3_debug():
3982  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3983  ctx = a.ctx
3984  # investigate problem with bv2int
3985  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3986 
3987 
def BV2Int
Definition: z3py.py:3965
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...
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3936
def z3py.BVAddNoOverflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector addition does not overflow

Definition at line 4451 of file z3py.py.

4451 def BVAddNoOverflow(a, b, signed):
4452  """A predicate the determines that bit-vector addition does not overflow"""
4453  _check_bv_args(a, b)
4454  a, b = _coerce_exprs(a, b)
4455  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4456 
4457 
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4451
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.
def z3py.BVAddNoUnderflow (   a,
  b 
)
A predicate the determines that signed bit-vector addition does not underflow

Definition at line 4458 of file z3py.py.

4459  """A predicate the determines that signed bit-vector addition does not underflow"""
4460  _check_bv_args(a, b)
4461  a, b = _coerce_exprs(a, b)
4462  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4463 
4464 
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4458
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...
def z3py.BVMulNoOverflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector multiplication does not overflow

Definition at line 4493 of file z3py.py.

4493 def BVMulNoOverflow(a, b, signed):
4494  """A predicate the determines that bit-vector multiplication does not overflow"""
4495  _check_bv_args(a, b)
4496  a, b = _coerce_exprs(a, b)
4497  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4498 
4499 
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4493
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...
def z3py.BVMulNoUnderflow (   a,
  b 
)
A predicate the determines that bit-vector signed multiplication does not underflow

Definition at line 4500 of file z3py.py.

4501  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4502  _check_bv_args(a, b)
4503  a, b = _coerce_exprs(a, b)
4504  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4505 
4506 
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...
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4500
def z3py.BVRedAnd (   a)
Return the reduction-and expression of `a`.

Definition at line 4437 of file z3py.py.

4437 def BVRedAnd(a):
4438  """Return the reduction-and expression of `a`."""
4439  if z3_debug():
4440  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4441  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4442 
4443 
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
def BVRedAnd(a)
Definition: z3py.py:4437
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3936
def z3py.BVRedOr (   a)
Return the reduction-or expression of `a`.

Definition at line 4444 of file z3py.py.

4444 def BVRedOr(a):
4445  """Return the reduction-or expression of `a`."""
4446  if z3_debug():
4447  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4448  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4449 
4450 
def BVRedOr(a)
Definition: z3py.py:4444
def z3_debug()
Definition: z3py.py:62
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
def is_bv(a)
Definition: z3py.py:3936
def z3py.BVSDivNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector signed division does not overflow

Definition at line 4479 of file z3py.py.

4480  """A predicate the determines that bit-vector signed division does not overflow"""
4481  _check_bv_args(a, b)
4482  a, b = _coerce_exprs(a, b)
4483  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4484 
4485 
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4479
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...
def z3py.BVSNegNoOverflow (   a)
A predicate the determines that bit-vector unary negation does not overflow

Definition at line 4486 of file z3py.py.

4487  """A predicate the determines that bit-vector unary negation does not overflow"""
4488  if z3_debug():
4489  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4490  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4491 
4492 
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...
def z3_debug()
Definition: z3py.py:62
def BVSNegNoOverflow(a)
Definition: z3py.py:4486
def is_bv(a)
Definition: z3py.py:3936
def z3py.BVSubNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector subtraction does not overflow

Definition at line 4465 of file z3py.py.

4466  """A predicate the determines that bit-vector subtraction does not overflow"""
4467  _check_bv_args(a, b)
4468  a, b = _coerce_exprs(a, b)
4469  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4470 
4471 
def BVSubNoOverflow(a, b)
Definition: z3py.py:4465
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...
def z3py.BVSubNoUnderflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector subtraction does not underflow

Definition at line 4472 of file z3py.py.

4472 def BVSubNoUnderflow(a, b, signed):
4473  """A predicate the determines that bit-vector subtraction does not underflow"""
4474  _check_bv_args(a, b)
4475  a, b = _coerce_exprs(a, b)
4476  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4477 
4478 
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4472
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...
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 3416 of file z3py.py.

3416 def Cbrt(a, ctx=None):
3417  """ Return a Z3 expression which represents the cubic root of a.
3418 
3419  >>> x = Real('x')
3420  >>> Cbrt(x)
3421  x**(1/3)
3422  """
3423  if not is_expr(a):
3424  ctx = _get_ctx(ctx)
3425  a = RealVal(a, ctx)
3426  return a ** "1/3"
3427 
def Cbrt
Definition: z3py.py:3416
def RealVal
Definition: z3py.py:3192
def is_expr(a)
Definition: z3py.py:1238
def z3py.CharFromBv (   ch,
  ctx = None 
)

Definition at line 10904 of file z3py.py.

10904 def CharFromBv(ch, ctx=None):
10905  if not is_expr(ch):
10906  raise Z3Expression("Bit-vector expression needed")
10907  return _to_expr_ref(Z3_mk_char_from_bv(ch.ctx_ref(), ch.as_ast()), ch.ctx)
10908 
def CharFromBv
Definition: z3py.py:10904
Z3_ast Z3_API Z3_mk_char_from_bv(Z3_context c, Z3_ast bv)
Create a character from a bit-vector (code point).
def is_expr(a)
Definition: z3py.py:1238
def z3py.CharIsDigit (   ch,
  ctx = None 
)

Definition at line 10917 of file z3py.py.

10917 def CharIsDigit(ch, ctx=None):
10918  ch = _coerce_char(ch, ctx)
10919  return ch.is_digit()
10920 
def CharIsDigit
Definition: z3py.py:10917
def z3py.CharSort (   ctx = None)
Create a character sort
>>> ch = CharSort()
>>> print(ch)
Char

Definition at line 10803 of file z3py.py.

10803 def CharSort(ctx=None):
10804  """Create a character sort
10805  >>> ch = CharSort()
10806  >>> print(ch)
10807  Char
10808  """
10809  ctx = _get_ctx(ctx)
10810  return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
10811 
10812 
def CharSort
Definition: z3py.py:10803
Z3_sort Z3_API Z3_mk_char_sort(Z3_context c)
Create a sort for unicode characters.
def z3py.CharToBv (   ch,
  ctx = None 
)

Definition at line 10909 of file z3py.py.

10909 def CharToBv(ch, ctx=None):
10910  ch = _coerce_char(ch, ctx)
10911  return ch.to_bv()
10912 
def CharToBv
Definition: z3py.py:10909
def z3py.CharToInt (   ch,
  ctx = None 
)

Definition at line 10913 of file z3py.py.

10913 def CharToInt(ch, ctx=None):
10914  ch = _coerce_char(ch, ctx)
10915  return ch.to_int()
10916 
def CharToInt
Definition: z3py.py:10913
def z3py.CharVal (   ch,
  ctx = None 
)

Definition at line 10896 of file z3py.py.

10896 def CharVal(ch, ctx=None):
10897  ctx = _get_ctx(ctx)
10898  if isinstance(ch, str):
10899  ch = ord(ch)
10900  if not isinstance(ch, int):
10901  raise Z3Exception("character value should be an ordinal")
10902  return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
10903 
Z3_ast Z3_API Z3_mk_char(Z3_context c, unsigned ch)
Create a character literal.
def CharVal
Definition: z3py.py:10896
def z3py.Complement (   re)
Create the complement regular expression.

Definition at line 11298 of file z3py.py.

11298 def Complement(re):
11299  """Create the complement regular expression."""
11300  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11301 
11302 
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
def Complement(re)
Definition: z3py.py:11298
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 4074 of file z3py.py.

Referenced by Contains(), and BitVecRef.size().

4074 def Concat(*args):
4075  """Create a Z3 bit-vector concatenation expression.
4076 
4077  >>> v = BitVecVal(1, 4)
4078  >>> Concat(v, v+1, v)
4079  Concat(Concat(1, 1 + 1), 1)
4080  >>> simplify(Concat(v, v+1, v))
4081  289
4082  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4083  121
4084  """
4085  args = _get_args(args)
4086  sz = len(args)
4087  if z3_debug():
4088  _z3_assert(sz >= 2, "At least two arguments expected.")
4089 
4090  ctx = None
4091  for a in args:
4092  if is_expr(a):
4093  ctx = a.ctx
4094  break
4095  if is_seq(args[0]) or isinstance(args[0], str):
4096  args = [_coerce_seq(s, ctx) for s in args]
4097  if z3_debug():
4098  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4099  v = (Ast * sz)()
4100  for i in range(sz):
4101  v[i] = args[i].as_ast()
4102  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4103 
4104  if is_re(args[0]):
4105  if z3_debug():
4106  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4107  v = (Ast * sz)()
4108  for i in range(sz):
4109  v[i] = args[i].as_ast()
4110  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4111 
4112  if z3_debug():
4113  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4114  r = args[0]
4115  for i in range(sz - 1):
4116  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4117  return r
4118 
4119 
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
def is_re(s)
Definition: z3py.py:11216
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1238
def is_bv(a)
Definition: z3py.py:3936
def Concat(args)
Definition: z3py.py:4074
def is_seq(a)
Definition: z3py.py:10942
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 8802 of file z3py.py.

Referenced by If().

8802 def Cond(p, t1, t2, ctx=None):
8803  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8804 
8805  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8806  """
8807  p = _to_probe(p, ctx)
8808  t1 = _to_tactic(t1, ctx)
8809  t2 = _to_tactic(t2, ctx)
8810  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8811 
def Cond
Definition: z3py.py:8802
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...
def z3py.Const (   name,
  sort 
)
Create a constant of the given sort.

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

Definition at line 1433 of file z3py.py.

Referenced by BitVecSort(), Consts(), FPSort(), IntSort(), IsMember(), IsSubset(), RealSort(), DatatypeSortRef.recognizer(), SetAdd(), SetComplement(), SetDel(), SetDifference(), SetIntersect(), and SetUnion().

1433 def Const(name, sort):
1434  """Create a constant of the given sort.
1435 
1436  >>> Const('x', IntSort())
1437  x
1438  """
1439  if z3_debug():
1440  _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1441  ctx = sort.ctx
1442  return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1443 
1444 
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def Const(name, sort)
Definition: z3py.py:1433
def z3_debug()
Definition: z3py.py:62
def to_symbol
Definition: z3py.py:124
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 1445 of file z3py.py.

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

1445 def Consts(names, sort):
1446  """Create several constants of the given sort.
1447 
1448  `names` is a string containing the names of all constants to be created.
1449  Blank spaces separate the names of different constants.
1450 
1451  >>> x, y, z = Consts('x y z', IntSort())
1452  >>> x + y + z
1453  x + y + z
1454  """
1455  if isinstance(names, str):
1456  names = names.split(" ")
1457  return [Const(name, sort) for name in names]
1458 
1459 
def Consts(names, sort)
Definition: z3py.py:1445
def Const(name, sort)
Definition: z3py.py:1433
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 11073 of file z3py.py.

11073 def Contains(a, b):
11074  """Check if 'a' contains 'b'
11075  >>> s1 = Contains("abc", "ab")
11076  >>> simplify(s1)
11077  True
11078  >>> s2 = Contains("abc", "bc")
11079  >>> simplify(s2)
11080  True
11081  >>> x, y, z = Strings('x y z')
11082  >>> s3 = Contains(Concat(x,y,z), y)
11083  >>> simplify(s3)
11084  True
11085  """
11086  ctx = _get_ctx2(a, b)
11087  a = _coerce_seq(a, ctx)
11088  b = _coerce_seq(b, ctx)
11089  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11090 
11091 
def Contains(a, b)
Definition: z3py.py:11073
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
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 5150 of file z3py.py.

Referenced by Datatype.create().

5151  """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5152 
5153  In the following example we define a Tree-List using two mutually recursive datatypes.
5154 
5155  >>> TreeList = Datatype('TreeList')
5156  >>> Tree = Datatype('Tree')
5157  >>> # Tree has two constructors: leaf and node
5158  >>> Tree.declare('leaf', ('val', IntSort()))
5159  >>> # a node contains a list of trees
5160  >>> Tree.declare('node', ('children', TreeList))
5161  >>> TreeList.declare('nil')
5162  >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5163  >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5164  >>> Tree.val(Tree.leaf(10))
5165  val(leaf(10))
5166  >>> simplify(Tree.val(Tree.leaf(10)))
5167  10
5168  >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5169  >>> n1
5170  node(cons(leaf(10), cons(leaf(20), nil)))
5171  >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5172  >>> simplify(n2 == n1)
5173  False
5174  >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5175  True
5176  """
5177  ds = _get_args(ds)
5178  if z3_debug():
5179  _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5180  _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5181  _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5182  _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5183  ctx = ds[0].ctx
5184  num = len(ds)
5185  names = (Symbol * num)()
5186  out = (Sort * num)()
5187  clists = (ConstructorList * num)()
5188  to_delete = []
5189  for i in range(num):
5190  d = ds[i]
5191  names[i] = to_symbol(d.name, ctx)
5192  num_cs = len(d.constructors)
5193  cs = (Constructor * num_cs)()
5194  for j in range(num_cs):
5195  c = d.constructors[j]
5196  cname = to_symbol(c[0], ctx)
5197  rname = to_symbol(c[1], ctx)
5198  fs = c[2]
5199  num_fs = len(fs)
5200  fnames = (Symbol * num_fs)()
5201  sorts = (Sort * num_fs)()
5202  refs = (ctypes.c_uint * num_fs)()
5203  for k in range(num_fs):
5204  fname = fs[k][0]
5205  ftype = fs[k][1]
5206  fnames[k] = to_symbol(fname, ctx)
5207  if isinstance(ftype, Datatype):
5208  if z3_debug():
5209  _z3_assert(
5210  ds.count(ftype) == 1,
5211  "One and only one occurrence of each datatype is expected",
5212  )
5213  sorts[k] = None
5214  refs[k] = ds.index(ftype)
5215  else:
5216  if z3_debug():
5217  _z3_assert(is_sort(ftype), "Z3 sort expected")
5218  sorts[k] = ftype.ast
5219  refs[k] = 0
5220  cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5221  to_delete.append(ScopedConstructor(cs[j], ctx))
5222  clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5223  to_delete.append(ScopedConstructorList(clists[i], ctx))
5224  Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5225  result = []
5226  # Create a field for every constructor, recognizer and accessor
5227  for i in range(num):
5228  dref = DatatypeSortRef(out[i], ctx)
5229  num_cs = dref.num_constructors()
5230  for j in range(num_cs):
5231  cref = dref.constructor(j)
5232  cref_name = cref.name()
5233  cref_arity = cref.arity()
5234  if cref.arity() == 0:
5235  cref = cref()
5236  setattr(dref, cref_name, cref)
5237  rref = dref.recognizer(j)
5238  setattr(dref, "is_" + cref_name, rref)
5239  for k in range(cref_arity):
5240  aref = dref.accessor(j, k)
5241  setattr(dref, aref.name(), aref)
5242  result.append(dref)
5243  return tuple(result)
5244 
5245 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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.
def CreateDatatypes(ds)
Definition: z3py.py:5150
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
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.
def to_symbol
Definition: z3py.py:124
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
def z3py.DatatypeSort (   name,
  ctx = None 
)
Create a reference to a sort that was declared, or will be declared, as a recursive datatype

Definition at line 5350 of file z3py.py.

5350 def DatatypeSort(name, ctx = None):
5351  """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5352  ctx = _get_ctx(ctx)
5353  return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5354 
def DatatypeSort
Definition: z3py.py:5350
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name)
create a forward reference to a recursive datatype being declared. The forward reference can be used ...
def to_symbol
Definition: z3py.py:124
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 693 of file z3py.py.

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

693 def DeclareSort(name, ctx=None):
694  """Create a new uninterpreted sort named `name`.
695 
696  If `ctx=None`, then the new sort is declared in the global Z3Py context.
697 
698  >>> A = DeclareSort('A')
699  >>> a = Const('a', A)
700  >>> b = Const('b', A)
701  >>> a.sort() == A
702  True
703  >>> b.sort() == A
704  True
705  >>> a == b
706  a == b
707  """
708  ctx = _get_ctx(ctx)
709  return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
710 
def DeclareSort
Definition: z3py.py:693
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
def to_symbol
Definition: z3py.py:124
def z3py.Default (   a)
Return a default value for array expression.
>>> b = K(IntSort(), 1)
>>> prove(Default(b) == 1)
proved

Definition at line 4771 of file z3py.py.

Referenced by is_default().

4771 def Default(a):
4772  """ Return a default value for array expression.
4773  >>> b = K(IntSort(), 1)
4774  >>> prove(Default(b) == 1)
4775  proved
4776  """
4777  if z3_debug():
4778  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4779  return a.default()
4780 
4781 
def is_array_sort(a)
Definition: z3py.py:4599
def Default(a)
Definition: z3py.py:4771
def z3_debug()
Definition: z3py.py:62
def z3py.describe_probes ( )
Display a (tabular) description of all available probes in Z3.

Definition at line 8723 of file z3py.py.

8724  """Display a (tabular) description of all available probes in Z3."""
8725  if in_html_mode():
8726  even = True
8727  print('<table border="1" cellpadding="2" cellspacing="0">')
8728  for p in probes():
8729  if even:
8730  print('<tr style="background-color:#CFCFCF">')
8731  even = False
8732  else:
8733  print("<tr>")
8734  even = True
8735  print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8736  print("</table>")
8737  else:
8738  for p in probes():
8739  print("%s : %s" % (p, probe_description(p)))
8740 
8741 
def probe_description
Definition: z3py.py:8714
def probes
Definition: z3py.py:8703
def describe_probes()
Definition: z3py.py:8723
def z3py.describe_tactics ( )
Display a (tabular) description of all available tactics in Z3.

Definition at line 8517 of file z3py.py.

8518  """Display a (tabular) description of all available tactics in Z3."""
8519  if in_html_mode():
8520  even = True
8521  print('<table border="1" cellpadding="2" cellspacing="0">')
8522  for t in tactics():
8523  if even:
8524  print('<tr style="background-color:#CFCFCF">')
8525  even = False
8526  else:
8527  print("<tr>")
8528  even = True
8529  print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8530  print("</table>")
8531  else:
8532  for t in tactics():
8533  print("%s : %s" % (t, tactic_description(t)))
8534 
8535 
def describe_tactics()
Definition: z3py.py:8517
def tactic_description
Definition: z3py.py:8508
def tactics
Definition: z3py.py:8497
def z3py.deserialize (   st)
inverse function to the serialize method on ExprRef.
It is made available to make it easier for users to serialize expressions back and forth between
strings. Solvers can be serialized using the 'sexpr()' method.

Definition at line 1115 of file z3py.py.

1115 def deserialize(st):
1116  """inverse function to the serialize method on ExprRef.
1117  It is made available to make it easier for users to serialize expressions back and forth between
1118  strings. Solvers can be serialized using the 'sexpr()' method.
1119  """
1120  s = Solver()
1121  s.from_string(st)
1122  if len(s.assertions()) != 1:
1123  raise Z3Exception("single assertion expected")
1124  fml = s.assertions()[0]
1125  if fml.num_args() != 1:
1126  raise Z3Exception("dummy function 'F' expected")
1127  return fml.arg(0)
1128 
def deserialize(st)
Definition: z3py.py:1115
def z3py.Diff (   a,
  b,
  ctx = None 
)
Create the difference regular expression

Definition at line 11341 of file z3py.py.

11341 def Diff(a, b, ctx=None):
11342  """Create the difference regular expression
11343  """
11344  return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11345 
def Diff
Definition: z3py.py:11341
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.
def z3py.disable_trace (   msg)

Definition at line 79 of file z3py.py.

79 def disable_trace(msg):
80  Z3_disable_trace(msg)
81 
82 
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...
def disable_trace(msg)
Definition: z3py.py:79
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 5367 of file z3py.py.

5367 def DisjointSum(name, sorts, ctx=None):
5368  """Create a named tagged union sort base on a set of underlying sorts
5369  Example:
5370  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5371  """
5372  sum = Datatype(name, ctx)
5373  for i in range(len(sorts)):
5374  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5375  sum = sum.create()
5376  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5377 
5378 
def DisjointSum
Definition: z3py.py:5367
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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 1400 of file z3py.py.

1400 def Distinct(*args):
1401  """Create a Z3 distinct expression.
1402 
1403  >>> x = Int('x')
1404  >>> y = Int('y')
1405  >>> Distinct(x, y)
1406  x != y
1407  >>> z = Int('z')
1408  >>> Distinct(x, y, z)
1409  Distinct(x, y, z)
1410  >>> simplify(Distinct(x, y, z))
1411  Distinct(x, y, z)
1412  >>> simplify(Distinct(x, y, z), blast_distinct=True)
1413  And(Not(x == y), Not(x == z), Not(y == z))
1414  """
1415  args = _get_args(args)
1416  ctx = _ctx_from_ast_arg_list(args)
1417  if z3_debug():
1418  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1419  args = _coerce_expr_list(args, ctx)
1420  _args, sz = _to_ast_array(args)
1421  return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1422 
1423 
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]).
def z3_debug()
Definition: z3py.py:62
def Distinct(args)
Definition: z3py.py:1400
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 11003 of file z3py.py.

11003 def Empty(s):
11004  """Create the empty sequence of the given sort
11005  >>> e = Empty(StringSort())
11006  >>> e2 = StringVal("")
11007  >>> print(e.eq(e2))
11008  True
11009  >>> e3 = Empty(SeqSort(IntSort()))
11010  >>> print(e3)
11011  Empty(Seq(Int))
11012  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11013  >>> print(e4)
11014  Empty(ReSort(Seq(Int)))
11015  """
11016  if isinstance(s, SeqSortRef):
11017  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11018  if isinstance(s, ReSortRef):
11019  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11020  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11021 
11022 
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
def Empty(s)
Definition: z3py.py:11003
def z3py.EmptySet (   s)
Create the empty set
>>> EmptySet(IntSort())
K(Int, False)

Definition at line 4914 of file z3py.py.

4914 def EmptySet(s):
4915  """Create the empty set
4916  >>> EmptySet(IntSort())
4917  K(Int, False)
4918  """
4919  ctx = s.ctx
4920  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4921 
4922 
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
def EmptySet(s)
Definition: z3py.py:4914
def z3py.enable_trace (   msg)

Definition at line 75 of file z3py.py.

75 def enable_trace(msg):
76  Z3_enable_trace(msg)
77 
78 
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...
def enable_trace(msg)
Definition: z3py.py:75
def z3py.ensure_prop_closures ( )

Definition at line 11456 of file z3py.py.

11457  global _prop_closures
11458  if _prop_closures is None:
11459  _prop_closures = PropClosures()
11460 
11461 
def ensure_prop_closures()
Definition: z3py.py:11456
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 5379 of file z3py.py.

5379 def EnumSort(name, values, ctx=None):
5380  """Return a new enumeration sort named `name` containing the given values.
5381 
5382  The result is a pair (sort, list of constants).
5383  Example:
5384  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5385  """
5386  if z3_debug():
5387  _z3_assert(isinstance(name, str), "Name must be a string")
5388  _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5389  _z3_assert(len(values) > 0, "At least one value expected")
5390  ctx = _get_ctx(ctx)
5391  num = len(values)
5392  _val_names = (Symbol * num)()
5393  for i in range(num):
5394  _val_names[i] = to_symbol(values[i])
5395  _values = (FuncDecl * num)()
5396  _testers = (FuncDecl * num)()
5397  name = to_symbol(name)
5398  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5399  V = []
5400  for i in range(num):
5401  V.append(FuncDeclRef(_values[i], ctx))
5402  V = [a() for a in V]
5403  return S, V
5404 
Function Declarations.
Definition: z3py.py:718
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def EnumSort
Definition: z3py.py:5379
def z3_debug()
Definition: z3py.py:62
def to_symbol
Definition: z3py.py:124
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.
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 472 of file z3py.py.

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

472 def eq(a, b):
473  """Return `True` if `a` and `b` are structurally identical AST nodes.
474 
475  >>> x = Int('x')
476  >>> y = Int('y')
477  >>> eq(x, y)
478  False
479  >>> eq(x + 1, x + 1)
480  True
481  >>> eq(x + 1, 1 + x)
482  False
483  >>> eq(simplify(x + 1), simplify(1 + x))
484  True
485  """
486  if z3_debug():
487  _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
488  return a.eq(b)
489 
490 
def eq(a, b)
Definition: z3py.py:472
def z3_debug()
Definition: z3py.py:62
def is_ast(a)
Definition: z3py.py:451
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 2236 of file z3py.py.

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

2236 def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2237  """Create a Z3 exists formula.
2238 
2239  The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2240 
2241 
2242  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2243  >>> x = Int('x')
2244  >>> y = Int('y')
2245  >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2246  >>> q
2247  Exists([x, y], f(x, y) >= x)
2248  >>> is_quantifier(q)
2249  True
2250  >>> r = Tactic('nnf')(q).as_expr()
2251  >>> is_quantifier(r)
2252  False
2253  """
2254  return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2255 
2256 
def Exists
Definition: z3py.py:2236
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 4860 of file z3py.py.

4860 def Ext(a, b):
4861  """Return extensionality index for one-dimensional arrays.
4862  >> a, b = Consts('a b', SetSort(IntSort()))
4863  >> Ext(a, b)
4864  Ext(a, b)
4865  """
4866  ctx = a.ctx
4867  if z3_debug():
4868  _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4869  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4870 
4871 
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...
def is_array_sort(a)
Definition: z3py.py:4599
def is_array(a)
Definition: z3py.py:4603
def z3_debug()
Definition: z3py.py:62
def Ext(a, b)
Definition: z3py.py:4860
def z3py.Extract (   high,
  low,
  a 
)
Create a Z3 bit-vector extraction expression.
Extract is overloaded to also work on sequence extraction.
The functions SubString and SubSeq are redirected to Extract.
For this case, the arguments are reinterpreted as:
    high - is a sequence (string)
    low  - is an offset
    a    - is the length to be extracted

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

4120 def Extract(high, low, a):
4121  """Create a Z3 bit-vector extraction expression.
4122  Extract is overloaded to also work on sequence extraction.
4123  The functions SubString and SubSeq are redirected to Extract.
4124  For this case, the arguments are reinterpreted as:
4125  high - is a sequence (string)
4126  low - is an offset
4127  a - is the length to be extracted
4128 
4129  >>> x = BitVec('x', 8)
4130  >>> Extract(6, 2, x)
4131  Extract(6, 2, x)
4132  >>> Extract(6, 2, x).sort()
4133  BitVec(5)
4134  >>> simplify(Extract(StringVal("abcd"),2,1))
4135  "c"
4136  """
4137  if isinstance(high, str):
4138  high = StringVal(high)
4139  if is_seq(high):
4140  s = high
4141  offset, length = _coerce_exprs(low, a, s.ctx)
4142  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4143  if z3_debug():
4144  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4145  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4146  "First and second arguments must be non negative integers")
4147  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4148  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4149 
4150 
def StringVal
Definition: z3py.py:10969
def Extract(high, low, a)
Definition: z3py.py:4120
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.
def z3_debug()
Definition: z3py.py:62
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...
def is_bv(a)
Definition: z3py.py:3936
def is_seq(a)
Definition: z3py.py:10942
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 8760 of file z3py.py.

8760 def FailIf(p, ctx=None):
8761  """Return a tactic that fails if the probe `p` evaluates to true.
8762  Otherwise, it returns the input goal unmodified.
8763 
8764  In the following example, the tactic applies 'simplify' if and only if there are
8765  more than 2 constraints in the goal.
8766 
8767  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8768  >>> x, y = Ints('x y')
8769  >>> g = Goal()
8770  >>> g.add(x > 0)
8771  >>> g.add(y > 0)
8772  >>> t(g)
8773  [[x > 0, y > 0]]
8774  >>> g.add(x == y + 1)
8775  >>> t(g)
8776  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8777  """
8778  p = _to_probe(p, ctx)
8779  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8780 
8781 
def FailIf
Definition: z3py.py:8760
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.
def z3py.FiniteDomainSort (   name,
  sz,
  ctx = None 
)
Create a named finite domain sort of a given size sz

Definition at line 7708 of file z3py.py.

7708 def FiniteDomainSort(name, sz, ctx=None):
7709  """Create a named finite domain sort of a given size sz"""
7710  if not isinstance(name, Symbol):
7711  name = to_symbol(name)
7712  ctx = _get_ctx(ctx)
7713  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7714 
7715 
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.
def FiniteDomainSort
Definition: z3py.py:7708
def to_symbol
Definition: z3py.py:124
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 7778 of file z3py.py.

7778 def FiniteDomainVal(val, sort, ctx=None):
7779  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7780 
7781  >>> s = FiniteDomainSort('S', 256)
7782  >>> FiniteDomainVal(255, s)
7783  255
7784  >>> FiniteDomainVal('100', s)
7785  100
7786  """
7787  if z3_debug():
7788  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7789  ctx = sort.ctx
7790  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7791 
7792 
def FiniteDomainVal
Definition: z3py.py:7778
def is_finite_domain_sort(s)
Definition: z3py.py:7716
def z3_debug()
Definition: z3py.py:62
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
def z3py.Float128 (   ctx = None)
Floating-point 128-bit (quadruple) sort.

Definition at line 9488 of file z3py.py.

9488 def Float128(ctx=None):
9489  """Floating-point 128-bit (quadruple) sort."""
9490  ctx = _get_ctx(ctx)
9491  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9492 
9493 
def Float128
Definition: z3py.py:9488
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
def z3py.Float16 (   ctx = None)
Floating-point 16-bit (half) sort.

Definition at line 9452 of file z3py.py.

9452 def Float16(ctx=None):
9453  """Floating-point 16-bit (half) sort."""
9454  ctx = _get_ctx(ctx)
9455  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9456 
9457 
def Float16
Definition: z3py.py:9452
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
def z3py.Float32 (   ctx = None)
Floating-point 32-bit (single) sort.

Definition at line 9464 of file z3py.py.

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

9464 def Float32(ctx=None):
9465  """Floating-point 32-bit (single) sort."""
9466  ctx = _get_ctx(ctx)
9467  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9468 
9469 
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
def Float32
Definition: z3py.py:9464
def z3py.Float64 (   ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 9476 of file z3py.py.

Referenced by fpFPToFP(), and fpToFP().

9476 def Float64(ctx=None):
9477  """Floating-point 64-bit (double) sort."""
9478  ctx = _get_ctx(ctx)
9479  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9480 
9481 
def Float64
Definition: z3py.py:9476
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
def z3py.FloatDouble (   ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 9482 of file z3py.py.

9482 def FloatDouble(ctx=None):
9483  """Floating-point 64-bit (double) sort."""
9484  ctx = _get_ctx(ctx)
9485  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9486 
9487 
def FloatDouble
Definition: z3py.py:9482
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
def z3py.FloatHalf (   ctx = None)
Floating-point 16-bit (half) sort.

Definition at line 9458 of file z3py.py.

9458 def FloatHalf(ctx=None):
9459  """Floating-point 16-bit (half) sort."""
9460  ctx = _get_ctx(ctx)
9461  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9462 
9463 
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
def FloatHalf
Definition: z3py.py:9458
def z3py.FloatQuadruple (   ctx = None)
Floating-point 128-bit (quadruple) sort.

Definition at line 9494 of file z3py.py.

9494 def FloatQuadruple(ctx=None):
9495  """Floating-point 128-bit (quadruple) sort."""
9496  ctx = _get_ctx(ctx)
9497  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9498 
9499 
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
def FloatQuadruple
Definition: z3py.py:9494
def z3py.FloatSingle (   ctx = None)
Floating-point 32-bit (single) sort.

Definition at line 9470 of file z3py.py.

9470 def FloatSingle(ctx=None):
9471  """Floating-point 32-bit (single) sort."""
9472  ctx = _get_ctx(ctx)
9473  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9474 
9475 
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
def FloatSingle
Definition: z3py.py:9470
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 2218 of file z3py.py.

Referenced by Fixedpoint.abstract(), QuantifierRef.body(), QuantifierRef.children(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), is_pattern(), is_quantifier(), MultiPattern(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), QuantifierRef.pattern(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

2218 def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2219  """Create a Z3 forall formula.
2220 
2221  The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2222 
2223  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2224  >>> x = Int('x')
2225  >>> y = Int('y')
2226  >>> ForAll([x, y], f(x, y) >= x)
2227  ForAll([x, y], f(x, y) >= x)
2228  >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2229  ForAll([x, y], f(x, y) >= x)
2230  >>> ForAll([x, y], f(x, y) >= x, weight=10)
2231  ForAll([x, y], f(x, y) >= x)
2232  """
2233  return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2234 
2235 
def ForAll
Definition: z3py.py:2218
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 10120 of file z3py.py.

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__neg__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), FPRef.__sub__(), fpAdd(), fpDiv(), fpIsInf(), fpIsNaN(), fpMax(), fpMin(), fpMul(), fpNeg(), fpRem(), FPSort(), fpSub(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), is_fp(), is_fp_value(), and FPRef.sort().

10120 def FP(name, fpsort, ctx=None):
10121  """Return a floating-point constant named `name`.
10122  `fpsort` is the floating-point sort.
10123  If `ctx=None`, then the global context is used.
10124 
10125  >>> x = FP('x', FPSort(8, 24))
10126  >>> is_fp(x)
10127  True
10128  >>> x.ebits()
10129  8
10130  >>> x.sort()
10131  FPSort(8, 24)
10132  >>> word = FPSort(8, 24)
10133  >>> x2 = FP('x', word)
10134  >>> eq(x, x2)
10135  True
10136  """
10137  if isinstance(fpsort, FPSortRef) and ctx is None:
10138  ctx = fpsort.ctx
10139  else:
10140  ctx = _get_ctx(ctx)
10141  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10142 
10143 
def FP
Definition: z3py.py:10120
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def to_symbol
Definition: z3py.py:124
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 10163 of file z3py.py.

10163 def fpAbs(a, ctx=None):
10164  """Create a Z3 floating-point absolute value expression.
10165 
10166  >>> s = FPSort(8, 24)
10167  >>> rm = RNE()
10168  >>> x = FPVal(1.0, s)
10169  >>> fpAbs(x)
10170  fpAbs(1)
10171  >>> y = FPVal(-20.0, s)
10172  >>> y
10173  -1.25*(2**4)
10174  >>> fpAbs(y)
10175  fpAbs(-1.25*(2**4))
10176  >>> fpAbs(-1.25*(2**4))
10177  fpAbs(-1.25*(2**4))
10178  >>> fpAbs(x).sort()
10179  FPSort(8, 24)
10180  """
10181  ctx = _get_ctx(ctx)
10182  [a] = _coerce_fp_expr_list([a], ctx)
10183  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10184 
10185 
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
def fpAbs
Definition: z3py.py:10163
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)
x + y
>>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
fpAdd(RTZ(), x, y)
>>> fpAdd(rm, x, y).sort()
FPSort(8, 24)

Definition at line 10254 of file z3py.py.

Referenced by FPs().

10254 def fpAdd(rm, a, b, ctx=None):
10255  """Create a Z3 floating-point addition expression.
10256 
10257  >>> s = FPSort(8, 24)
10258  >>> rm = RNE()
10259  >>> x = FP('x', s)
10260  >>> y = FP('y', s)
10261  >>> fpAdd(rm, x, y)
10262  x + y
10263  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10264  fpAdd(RTZ(), x, y)
10265  >>> fpAdd(rm, x, y).sort()
10266  FPSort(8, 24)
10267  """
10268  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10269 
10270 
def fpAdd
Definition: z3py.py:10254
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 10576 of file z3py.py.

10576 def fpBVToFP(v, sort, ctx=None):
10577  """Create a Z3 floating-point conversion expression that represents the
10578  conversion from a bit-vector term to a floating-point term.
10579 
10580  >>> x_bv = BitVecVal(0x3F800000, 32)
10581  >>> x_fp = fpBVToFP(x_bv, Float32())
10582  >>> x_fp
10583  fpToFP(1065353216)
10584  >>> simplify(x_fp)
10585  1
10586  """
10587  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10588  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10589  ctx = _get_ctx(ctx)
10590  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10591 
10592 
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.
def fpBVToFP
Definition: z3py.py:10576
def is_fp_sort(s)
Definition: z3py.py:9504
def is_bv(a)
Definition: z3py.py:3936
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)
x / y
>>> fpDiv(rm, x, y).sort()
FPSort(8, 24)

Definition at line 10301 of file z3py.py.

10301 def fpDiv(rm, a, b, ctx=None):
10302  """Create a Z3 floating-point division expression.
10303 
10304  >>> s = FPSort(8, 24)
10305  >>> rm = RNE()
10306  >>> x = FP('x', s)
10307  >>> y = FP('y', s)
10308  >>> fpDiv(rm, x, y)
10309  x / y
10310  >>> fpDiv(rm, x, y).sort()
10311  FPSort(8, 24)
10312  """
10313  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10314 
10315 
def fpDiv
Definition: z3py.py:10301
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 10484 of file z3py.py.

Referenced by fpFP(), and fpNEQ().

10484 def fpEQ(a, b, ctx=None):
10485  """Create the Z3 floating-point expression `fpEQ(other, self)`.
10486 
10487  >>> x, y = FPs('x y', FPSort(8, 24))
10488  >>> fpEQ(x, y)
10489  fpEQ(x, y)
10490  >>> fpEQ(x, y).sexpr()
10491  '(fp.eq x y)'
10492  """
10493  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10494 
10495 
def fpEQ
Definition: z3py.py:10484
def z3py.fpFMA (   rm,
  a,
  b,
  c,
  ctx = None 
)
Create a Z3 floating-point fused multiply-add expression.

Definition at line 10360 of file z3py.py.

10360 def fpFMA(rm, a, b, c, ctx=None):
10361  """Create a Z3 floating-point fused multiply-add expression.
10362  """
10363  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10364 
10365 
def fpFMA
Definition: z3py.py:10360
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 10508 of file z3py.py.

10508 def fpFP(sgn, exp, sig, ctx=None):
10509  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10510 
10511  >>> s = FPSort(8, 24)
10512  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10513  >>> print(x)
10514  fpFP(1, 127, 4194304)
10515  >>> xv = FPVal(-1.5, s)
10516  >>> print(xv)
10517  -1.5
10518  >>> slvr = Solver()
10519  >>> slvr.add(fpEQ(x, xv))
10520  >>> slvr.check()
10521  sat
10522  >>> xv = FPVal(+1.5, s)
10523  >>> print(xv)
10524  1.5
10525  >>> slvr = Solver()
10526  >>> slvr.add(fpEQ(x, xv))
10527  >>> slvr.check()
10528  unsat
10529  """
10530  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10531  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10532  ctx = _get_ctx(ctx)
10533  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10534  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10535 
10536 
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.
def fpFP
Definition: z3py.py:10508
def is_bv(a)
Definition: z3py.py:3936
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 10593 of file z3py.py.

10593 def fpFPToFP(rm, v, sort, ctx=None):
10594  """Create a Z3 floating-point conversion expression that represents the
10595  conversion from a floating-point term to a floating-point term of different precision.
10596 
10597  >>> x_sgl = FPVal(1.0, Float32())
10598  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10599  >>> x_dbl
10600  fpToFP(RNE(), 1)
10601  >>> simplify(x_dbl)
10602  1
10603  >>> x_dbl.sort()
10604  FPSort(11, 53)
10605  """
10606  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10607  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10608  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10609  ctx = _get_ctx(ctx)
10610  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10611 
10612 
def fpFPToFP
Definition: z3py.py:10593
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.
def is_fp_sort(s)
Definition: z3py.py:9504
def is_fprm(a)
Definition: z3py.py:9764
def is_fp(a)
Definition: z3py.py:9920
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 10472 of file z3py.py.

10472 def fpGEQ(a, b, ctx=None):
10473  """Create the Z3 floating-point expression `other >= self`.
10474 
10475  >>> x, y = FPs('x y', FPSort(8, 24))
10476  >>> fpGEQ(x, y)
10477  x >= y
10478  >>> (x >= y).sexpr()
10479  '(fp.geq x y)'
10480  """
10481  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10482 
10483 
def fpGEQ
Definition: z3py.py:10472
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 10460 of file z3py.py.

10460 def fpGT(a, b, ctx=None):
10461  """Create the Z3 floating-point expression `other > self`.
10462 
10463  >>> x, y = FPs('x y', FPSort(8, 24))
10464  >>> fpGT(x, y)
10465  x > y
10466  >>> (x > y).sexpr()
10467  '(fp.gt x y)'
10468  """
10469  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10470 
10471 
def fpGT
Definition: z3py.py:10460
def z3py.fpInfinity (   s,
  negative 
)
Create a Z3 floating-point +oo or -oo term.

Definition at line 10048 of file z3py.py.

10048 def fpInfinity(s, negative):
10049  """Create a Z3 floating-point +oo or -oo term."""
10050  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10051  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10052  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10053 
10054 
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
def fpInfinity(s, negative)
Definition: z3py.py:10048
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 10390 of file z3py.py.

10390 def fpIsInf(a, ctx=None):
10391  """Create a Z3 floating-point isInfinite expression.
10392 
10393  >>> s = FPSort(8, 24)
10394  >>> x = FP('x', s)
10395  >>> fpIsInf(x)
10396  fpIsInf(x)
10397  """
10398  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10399 
10400 
def fpIsInf
Definition: z3py.py:10390
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 10378 of file z3py.py.

10378 def fpIsNaN(a, ctx=None):
10379  """Create a Z3 floating-point isNaN expression.
10380 
10381  >>> s = FPSort(8, 24)
10382  >>> x = FP('x', s)
10383  >>> y = FP('y', s)
10384  >>> fpIsNaN(x)
10385  fpIsNaN(x)
10386  """
10387  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10388 
10389 
def fpIsNaN
Definition: z3py.py:10378
def z3py.fpIsNegative (   a,
  ctx = None 
)
Create a Z3 floating-point isNegative expression.

Definition at line 10419 of file z3py.py.

10419 def fpIsNegative(a, ctx=None):
10420  """Create a Z3 floating-point isNegative expression.
10421  """
10422  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10423 
10424 
def fpIsNegative
Definition: z3py.py:10419
def z3py.fpIsNormal (   a,
  ctx = None 
)
Create a Z3 floating-point isNormal expression.

Definition at line 10407 of file z3py.py.

10407 def fpIsNormal(a, ctx=None):
10408  """Create a Z3 floating-point isNormal expression.
10409  """
10410  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10411 
10412 
def fpIsNormal
Definition: z3py.py:10407
def z3py.fpIsPositive (   a,
  ctx = None 
)
Create a Z3 floating-point isPositive expression.

Definition at line 10425 of file z3py.py.

10425 def fpIsPositive(a, ctx=None):
10426  """Create a Z3 floating-point isPositive expression.
10427  """
10428  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10429 
10430 
def fpIsPositive
Definition: z3py.py:10425
def z3py.fpIsSubnormal (   a,
  ctx = None 
)
Create a Z3 floating-point isSubnormal expression.

Definition at line 10413 of file z3py.py.

10413 def fpIsSubnormal(a, ctx=None):
10414  """Create a Z3 floating-point isSubnormal expression.
10415  """
10416  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10417 
10418 
def fpIsSubnormal
Definition: z3py.py:10413
def z3py.fpIsZero (   a,
  ctx = None 
)
Create a Z3 floating-point isZero expression.

Definition at line 10401 of file z3py.py.

10401 def fpIsZero(a, ctx=None):
10402  """Create a Z3 floating-point isZero expression.
10403  """
10404  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10405 
10406 
def fpIsZero
Definition: z3py.py:10401
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 10448 of file z3py.py.

10448 def fpLEQ(a, b, ctx=None):
10449  """Create the Z3 floating-point expression `other <= self`.
10450 
10451  >>> x, y = FPs('x y', FPSort(8, 24))
10452  >>> fpLEQ(x, y)
10453  x <= y
10454  >>> (x <= y).sexpr()
10455  '(fp.leq x y)'
10456  """
10457  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10458 
10459 
def fpLEQ
Definition: z3py.py:10448
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 10436 of file z3py.py.

10436 def fpLT(a, b, ctx=None):
10437  """Create the Z3 floating-point expression `other < self`.
10438 
10439  >>> x, y = FPs('x y', FPSort(8, 24))
10440  >>> fpLT(x, y)
10441  x < y
10442  >>> (x < y).sexpr()
10443  '(fp.lt x y)'
10444  """
10445  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10446 
10447 
def fpLT
Definition: z3py.py:10436
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 10345 of file z3py.py.

10345 def fpMax(a, b, ctx=None):
10346  """Create a Z3 floating-point maximum expression.
10347 
10348  >>> s = FPSort(8, 24)
10349  >>> rm = RNE()
10350  >>> x = FP('x', s)
10351  >>> y = FP('y', s)
10352  >>> fpMax(x, y)
10353  fpMax(x, y)
10354  >>> fpMax(x, y).sort()
10355  FPSort(8, 24)
10356  """
10357  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10358 
10359 
def fpMax
Definition: z3py.py:10345
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 10330 of file z3py.py.

10330 def fpMin(a, b, ctx=None):
10331  """Create a Z3 floating-point minimum expression.
10332 
10333  >>> s = FPSort(8, 24)
10334  >>> rm = RNE()
10335  >>> x = FP('x', s)
10336  >>> y = FP('y', s)
10337  >>> fpMin(x, y)
10338  fpMin(x, y)
10339  >>> fpMin(x, y).sort()
10340  FPSort(8, 24)
10341  """
10342  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10343 
10344 
def fpMin
Definition: z3py.py:10330
def z3py.fpMinusInfinity (   s)
Create a Z3 floating-point -oo term.

Definition at line 10042 of file z3py.py.

10043  """Create a Z3 floating-point -oo term."""
10044  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10045  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10046 
10047 
def fpMinusInfinity(s)
Definition: z3py.py:10042
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
def z3py.fpMinusZero (   s)
Create a Z3 floating-point -0.0 term.

Definition at line 10061 of file z3py.py.

10062  """Create a Z3 floating-point -0.0 term."""
10063  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10064  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10065 
10066 
def fpMinusZero(s)
Definition: z3py.py:10061
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
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)
x * y
>>> fpMul(rm, x, y).sort()
FPSort(8, 24)

Definition at line 10286 of file z3py.py.

Referenced by FPs().

10286 def fpMul(rm, a, b, ctx=None):
10287  """Create a Z3 floating-point multiplication expression.
10288 
10289  >>> s = FPSort(8, 24)
10290  >>> rm = RNE()
10291  >>> x = FP('x', s)
10292  >>> y = FP('y', s)
10293  >>> fpMul(rm, x, y)
10294  x * y
10295  >>> fpMul(rm, x, y).sort()
10296  FPSort(8, 24)
10297  """
10298  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10299 
10300 
def fpMul
Definition: z3py.py:10286
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 10008 of file z3py.py.

10008 def fpNaN(s):
10009  """Create a Z3 floating-point NaN term.
10010 
10011  >>> s = FPSort(8, 24)
10012  >>> set_fpa_pretty(True)
10013  >>> fpNaN(s)
10014  NaN
10015  >>> pb = get_fpa_pretty()
10016  >>> set_fpa_pretty(False)
10017  >>> fpNaN(s)
10018  fpNaN(FPSort(8, 24))
10019  >>> set_fpa_pretty(pb)
10020  """
10021  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10022  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10023 
10024 
def fpNaN(s)
Definition: z3py.py:10008
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
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 10186 of file z3py.py.

10186 def fpNeg(a, ctx=None):
10187  """Create a Z3 floating-point addition expression.
10188 
10189  >>> s = FPSort(8, 24)
10190  >>> rm = RNE()
10191  >>> x = FP('x', s)
10192  >>> fpNeg(x)
10193  -x
10194  >>> fpNeg(x).sort()
10195  FPSort(8, 24)
10196  """
10197  ctx = _get_ctx(ctx)
10198  [a] = _coerce_fp_expr_list([a], ctx)
10199  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10200 
10201 
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
def fpNeg
Definition: z3py.py:10186
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 10496 of file z3py.py.

10496 def fpNEQ(a, b, ctx=None):
10497  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10498 
10499  >>> x, y = FPs('x y', FPSort(8, 24))
10500  >>> fpNEQ(x, y)
10501  Not(fpEQ(x, y))
10502  >>> (x != y).sexpr()
10503  '(distinct x y)'
10504  """
10505  return Not(fpEQ(a, b, ctx))
10506 
10507 
def Not
Definition: z3py.py:1811
def fpEQ
Definition: z3py.py:10484
def fpNEQ
Definition: z3py.py:10496
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 10025 of file z3py.py.

10026  """Create a Z3 floating-point +oo term.
10027 
10028  >>> s = FPSort(8, 24)
10029  >>> pb = get_fpa_pretty()
10030  >>> set_fpa_pretty(True)
10031  >>> fpPlusInfinity(s)
10032  +oo
10033  >>> set_fpa_pretty(False)
10034  >>> fpPlusInfinity(s)
10035  fpPlusInfinity(FPSort(8, 24))
10036  >>> set_fpa_pretty(pb)
10037  """
10038  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10039  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10040 
10041 
def fpPlusInfinity(s)
Definition: z3py.py:10025
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
def z3py.fpPlusZero (   s)
Create a Z3 floating-point +0.0 term.

Definition at line 10055 of file z3py.py.

10055 def fpPlusZero(s):
10056  """Create a Z3 floating-point +0.0 term."""
10057  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10058  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10059 
10060 
def fpPlusZero(s)
Definition: z3py.py:10055
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
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 10613 of file z3py.py.

10613 def fpRealToFP(rm, v, sort, ctx=None):
10614  """Create a Z3 floating-point conversion expression that represents the
10615  conversion from a real term to a floating-point term.
10616 
10617  >>> x_r = RealVal(1.5)
10618  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10619  >>> x_fp
10620  fpToFP(RNE(), 3/2)
10621  >>> simplify(x_fp)
10622  1.5
10623  """
10624  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10625  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10626  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10627  ctx = _get_ctx(ctx)
10628  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10629 
10630 
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.
def is_real(a)
Definition: z3py.py:2701
def fpRealToFP
Definition: z3py.py:10613
def is_fp_sort(s)
Definition: z3py.py:9504
def is_fprm(a)
Definition: z3py.py:9764
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 10316 of file z3py.py.

10316 def fpRem(a, b, ctx=None):
10317  """Create a Z3 floating-point remainder expression.
10318 
10319  >>> s = FPSort(8, 24)
10320  >>> x = FP('x', s)
10321  >>> y = FP('y', s)
10322  >>> fpRem(x, y)
10323  fpRem(x, y)
10324  >>> fpRem(x, y).sort()
10325  FPSort(8, 24)
10326  """
10327  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10328 
10329 
def fpRem
Definition: z3py.py:10316
def z3py.fpRoundToIntegral (   rm,
  a,
  ctx = None 
)
Create a Z3 floating-point roundToIntegral expression.

Definition at line 10372 of file z3py.py.

10372 def fpRoundToIntegral(rm, a, ctx=None):
10373  """Create a Z3 floating-point roundToIntegral expression.
10374  """
10375  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10376 
10377 
def fpRoundToIntegral
Definition: z3py.py:10372
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)
x + y * z

Definition at line 10144 of file z3py.py.

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

10144 def FPs(names, fpsort, ctx=None):
10145  """Return an array of floating-point constants.
10146 
10147  >>> x, y, z = FPs('x y z', FPSort(8, 24))
10148  >>> x.sort()
10149  FPSort(8, 24)
10150  >>> x.sbits()
10151  24
10152  >>> x.ebits()
10153  8
10154  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10155  x + y * z
10156  """
10157  ctx = _get_ctx(ctx)
10158  if isinstance(names, str):
10159  names = names.split(" ")
10160  return [FP(name, fpsort, ctx) for name in names]
10161 
10162 
def FP
Definition: z3py.py:10120
def FPs
Definition: z3py.py:10144
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 10631 of file z3py.py.

10631 def fpSignedToFP(rm, v, sort, ctx=None):
10632  """Create a Z3 floating-point conversion expression that represents the
10633  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10634 
10635  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10636  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10637  >>> x_fp
10638  fpToFP(RNE(), 4294967291)
10639  >>> simplify(x_fp)
10640  -1.25*(2**2)
10641  """
10642  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10643  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10644  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10645  ctx = _get_ctx(ctx)
10646  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10647 
10648 
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...
def fpSignedToFP
Definition: z3py.py:10631
def is_fp_sort(s)
Definition: z3py.py:9504
def is_bv(a)
Definition: z3py.py:3936
def is_fprm(a)
Definition: z3py.py:9764
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 9949 of file z3py.py.

Referenced by FPRef.__add__(), FPRef.__div__(), FPRef.__mul__(), FPRef.__radd__(), FPRef.__rdiv__(), FPRef.__rmul__(), FPRef.__rsub__(), FPRef.__sub__(), FPSortRef.cast(), FPSortRef.ebits(), FPRef.ebits(), FPNumRef.exponent(), FP(), fpAbs(), fpAdd(), fpDiv(), fpEQ(), fpFP(), fpFPToFP(), fpGEQ(), fpGT(), fpIsInf(), fpIsNaN(), fpLEQ(), fpLT(), fpMax(), fpMin(), fpMul(), fpNaN(), fpNeg(), fpNEQ(), fpPlusInfinity(), fpRem(), FPs(), fpSub(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), fpToUBV(), FPVal(), is_fp(), is_fp_sort(), is_fp_value(), is_fprm_sort(), FPNumRef.isNegative(), FPSortRef.sbits(), FPRef.sbits(), FPNumRef.sign_as_bv(), FPNumRef.significand(), FPNumRef.significand_as_bv(), and FPRef.sort().

9949 def FPSort(ebits, sbits, ctx=None):
9950  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9951 
9952  >>> Single = FPSort(8, 24)
9953  >>> Double = FPSort(11, 53)
9954  >>> Single
9955  FPSort(8, 24)
9956  >>> x = Const('x', Single)
9957  >>> eq(x, FP('x', FPSort(8, 24)))
9958  True
9959  """
9960  ctx = _get_ctx(ctx)
9961  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9962 
9963 
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
def FPSort
Definition: z3py.py:9949
def z3py.fpSqrt (   rm,
  a,
  ctx = None 
)
Create a Z3 floating-point square root expression.

Definition at line 10366 of file z3py.py.

10366 def fpSqrt(rm, a, ctx=None):
10367  """Create a Z3 floating-point square root expression.
10368  """
10369  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10370 
10371 
def fpSqrt
Definition: z3py.py:10366
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)
x - y
>>> fpSub(rm, x, y).sort()
FPSort(8, 24)

Definition at line 10271 of file z3py.py.

10271 def fpSub(rm, a, b, ctx=None):
10272  """Create a Z3 floating-point subtraction expression.
10273 
10274  >>> s = FPSort(8, 24)
10275  >>> rm = RNE()
10276  >>> x = FP('x', s)
10277  >>> y = FP('y', s)
10278  >>> fpSub(rm, x, y)
10279  x - y
10280  >>> fpSub(rm, x, y).sort()
10281  FPSort(8, 24)
10282  """
10283  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10284 
10285 
def fpSub
Definition: z3py.py:10271
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 10537 of file z3py.py.

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

10537 def fpToFP(a1, a2=None, a3=None, ctx=None):
10538  """Create a Z3 floating-point conversion expression from other term sorts
10539  to floating-point.
10540 
10541  From a bit-vector term in IEEE 754-2008 format:
10542  >>> x = FPVal(1.0, Float32())
10543  >>> x_bv = fpToIEEEBV(x)
10544  >>> simplify(fpToFP(x_bv, Float32()))
10545  1
10546 
10547  From a floating-point term with different precision:
10548  >>> x = FPVal(1.0, Float32())
10549  >>> x_db = fpToFP(RNE(), x, Float64())
10550  >>> x_db.sort()
10551  FPSort(11, 53)
10552 
10553  From a real term:
10554  >>> x_r = RealVal(1.5)
10555  >>> simplify(fpToFP(RNE(), x_r, Float32()))
10556  1.5
10557 
10558  From a signed bit-vector term:
10559  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10560  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10561  -1.25*(2**2)
10562  """
10563  ctx = _get_ctx(ctx)
10564  if is_bv(a1) and is_fp_sort(a2):
10565  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10566  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10567  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10568  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10569  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10570  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10571  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10572  else:
10573  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10574 
10575 
def fpToFP
Definition: z3py.py:10537
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.
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.
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...
def is_real(a)
Definition: z3py.py:2701
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.
def is_fp_sort(s)
Definition: z3py.py:9504
def is_bv(a)
Definition: z3py.py:3936
def is_fprm(a)
Definition: z3py.py:9764
def is_fp(a)
Definition: z3py.py:9920
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 10667 of file z3py.py.

Referenced by fpUnsignedToFP().

10667 def fpToFPUnsigned(rm, x, s, ctx=None):
10668  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10669  if z3_debug():
10670  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10671  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10672  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10673  ctx = _get_ctx(ctx)
10674  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10675 
10676 
def fpToFPUnsigned
Definition: z3py.py:10667
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...
def z3_debug()
Definition: z3py.py:62
def is_fp_sort(s)
Definition: z3py.py:9504
def is_bv(a)
Definition: z3py.py:3936
def is_fprm(a)
Definition: z3py.py:9764
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 10741 of file z3py.py.

Referenced by fpToFP().

10741 def fpToIEEEBV(x, ctx=None):
10742  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10743 
10744  The size of the resulting bit-vector is automatically determined.
10745 
10746  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10747  knows only one NaN and it will always produce the same bit-vector representation of
10748  that NaN.
10749 
10750  >>> x = FP('x', FPSort(8, 24))
10751  >>> y = fpToIEEEBV(x)
10752  >>> print(is_fp(x))
10753  True
10754  >>> print(is_bv(y))
10755  True
10756  >>> print(is_fp(y))
10757  False
10758  >>> print(is_bv(x))
10759  False
10760  """
10761  if z3_debug():
10762  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10763  ctx = _get_ctx(ctx)
10764  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10765 
10766 
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.
def z3_debug()
Definition: z3py.py:62
def fpToIEEEBV
Definition: z3py.py:10741
def is_fp(a)
Definition: z3py.py:9920
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 10721 of file z3py.py.

10721 def fpToReal(x, ctx=None):
10722  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10723 
10724  >>> x = FP('x', FPSort(8, 24))
10725  >>> y = fpToReal(x)
10726  >>> print(is_fp(x))
10727  True
10728  >>> print(is_real(y))
10729  True
10730  >>> print(is_fp(y))
10731  False
10732  >>> print(is_real(x))
10733  False
10734  """
10735  if z3_debug():
10736  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10737  ctx = _get_ctx(ctx)
10738  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10739 
10740 
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.
def z3_debug()
Definition: z3py.py:62
def fpToReal
Definition: z3py.py:10721
def is_fp(a)
Definition: z3py.py:9920
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 10677 of file z3py.py.

10677 def fpToSBV(rm, x, s, ctx=None):
10678  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10679 
10680  >>> x = FP('x', FPSort(8, 24))
10681  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10682  >>> print(is_fp(x))
10683  True
10684  >>> print(is_bv(y))
10685  True
10686  >>> print(is_fp(y))
10687  False
10688  >>> print(is_bv(x))
10689  False
10690  """
10691  if z3_debug():
10692  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10693  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10694  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10695  ctx = _get_ctx(ctx)
10696  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10697 
10698 
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.
def fpToSBV
Definition: z3py.py:10677
def z3_debug()
Definition: z3py.py:62
def is_bv_sort(s)
Definition: z3py.py:3468
def is_fprm(a)
Definition: z3py.py:9764
def is_fp(a)
Definition: z3py.py:9920
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 10699 of file z3py.py.

10699 def fpToUBV(rm, x, s, ctx=None):
10700  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10701 
10702  >>> x = FP('x', FPSort(8, 24))
10703  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10704  >>> print(is_fp(x))
10705  True
10706  >>> print(is_bv(y))
10707  True
10708  >>> print(is_fp(y))
10709  False
10710  >>> print(is_bv(x))
10711  False
10712  """
10713  if z3_debug():
10714  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10715  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10716  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10717  ctx = _get_ctx(ctx)
10718  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10719 
10720 
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.
def z3_debug()
Definition: z3py.py:62
def is_bv_sort(s)
Definition: z3py.py:3468
def fpToUBV
Definition: z3py.py:10699
def is_fprm(a)
Definition: z3py.py:9764
def is_fp(a)
Definition: z3py.py:9920
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 10649 of file z3py.py.

10649 def fpUnsignedToFP(rm, v, sort, ctx=None):
10650  """Create a Z3 floating-point conversion expression that represents the
10651  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10652 
10653  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10654  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10655  >>> x_fp
10656  fpToFPUnsigned(RNE(), 4294967291)
10657  >>> simplify(x_fp)
10658  1*(2**32)
10659  """
10660  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10661  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10662  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10663  ctx = _get_ctx(ctx)
10664  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10665 
10666 
def fpUnsignedToFP
Definition: z3py.py:10649
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...
def is_fp_sort(s)
Definition: z3py.py:9504
def is_bv(a)
Definition: z3py.py:3936
def is_fprm(a)
Definition: z3py.py:9764
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 10074 of file z3py.py.

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

10074 def FPVal(sig, exp=None, fps=None, ctx=None):
10075  """Return a floating-point value of value `val` and sort `fps`.
10076  If `ctx=None`, then the global context is used.
10077 
10078  >>> v = FPVal(20.0, FPSort(8, 24))
10079  >>> v
10080  1.25*(2**4)
10081  >>> print("0x%.8x" % v.exponent_as_long(False))
10082  0x00000004
10083  >>> v = FPVal(2.25, FPSort(8, 24))
10084  >>> v
10085  1.125*(2**1)
10086  >>> v = FPVal(-2.25, FPSort(8, 24))
10087  >>> v
10088  -1.125*(2**1)
10089  >>> FPVal(-0.0, FPSort(8, 24))
10090  -0.0
10091  >>> FPVal(0.0, FPSort(8, 24))
10092  +0.0
10093  >>> FPVal(+0.0, FPSort(8, 24))
10094  +0.0
10095  """
10096  ctx = _get_ctx(ctx)
10097  if is_fp_sort(exp):
10098  fps = exp
10099  exp = None
10100  elif fps is None:
10101  fps = _dflt_fps(ctx)
10102  _z3_assert(is_fp_sort(fps), "sort mismatch")
10103  if exp is None:
10104  exp = 0
10105  val = _to_float_str(sig)
10106  if val == "NaN" or val == "nan":
10107  return fpNaN(fps)
10108  elif val == "-0.0":
10109  return fpMinusZero(fps)
10110  elif val == "0.0" or val == "+0.0":
10111  return fpPlusZero(fps)
10112  elif val == "+oo" or val == "+inf" or val == "+Inf":
10113  return fpPlusInfinity(fps)
10114  elif val == "-oo" or val == "-inf" or val == "-Inf":
10115  return fpMinusInfinity(fps)
10116  else:
10117  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10118 
10119 
def fpMinusInfinity(s)
Definition: z3py.py:10042
def FPVal
Definition: z3py.py:10074
def fpMinusZero(s)
Definition: z3py.py:10061
def fpPlusZero(s)
Definition: z3py.py:10055
def fpPlusInfinity(s)
Definition: z3py.py:10025
def fpNaN(s)
Definition: z3py.py:10008
def is_fp_sort(s)
Definition: z3py.py:9504
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
def z3py.fpZero (   s,
  negative 
)
Create a Z3 floating-point +0.0 or -0.0 term.

Definition at line 10067 of file z3py.py.

10067 def fpZero(s, negative):
10068  """Create a Z3 floating-point +0.0 or -0.0 term."""
10069  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10070  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10071  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10072 
10073 
def fpZero(s, negative)
Definition: z3py.py:10067
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
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 1767 of file z3py.py.

1767 def FreshBool(prefix="b", ctx=None):
1768  """Return a fresh Boolean constant in the given context using the given prefix.
1769 
1770  If `ctx=None`, then the global context is used.
1771 
1772  >>> b1 = FreshBool()
1773  >>> b2 = FreshBool()
1774  >>> eq(b1, b2)
1775  False
1776  """
1777  ctx = _get_ctx(ctx)
1778  return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1779 
1780 
def BoolSort
Definition: z3py.py:1687
def FreshBool
Definition: z3py.py:1767
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
def z3py.FreshConst (   sort,
  prefix = "c" 
)
Create a fresh constant of a specified sort

Definition at line 1460 of file z3py.py.

1460 def FreshConst(sort, prefix="c"):
1461  """Create a fresh constant of a specified sort"""
1462  ctx = _get_ctx(sort.ctx)
1463  return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1464 
1465 
def FreshConst
Definition: z3py.py:1460
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
def z3py.FreshFunction (   sig)
Create a new fresh Z3 uninterpreted function with the given sorts.

Definition at line 882 of file z3py.py.

882 def FreshFunction(*sig):
883  """Create a new fresh Z3 uninterpreted function with the given sorts.
884  """
885  sig = _get_args(sig)
886  if z3_debug():
887  _z3_assert(len(sig) > 0, "At least two arguments expected")
888  arity = len(sig) - 1
889  rng = sig[arity]
890  if z3_debug():
891  _z3_assert(is_sort(rng), "Z3 sort expected")
892  dom = (z3.Sort * arity)()
893  for i in range(arity):
894  if z3_debug():
895  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
896  dom[i] = sig[i].ast
897  ctx = rng.ctx
898  return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), "f", arity, dom, rng.ast), ctx)
899 
900 
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.
Function Declarations.
Definition: z3py.py:718
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
def FreshFunction(sig)
Definition: z3py.py:882
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 3279 of file z3py.py.

3279 def FreshInt(prefix="x", ctx=None):
3280  """Return a fresh integer constant in the given context using the given prefix.
3281 
3282  >>> x = FreshInt()
3283  >>> y = FreshInt()
3284  >>> eq(x, y)
3285  False
3286  >>> x.sort()
3287  Int
3288  """
3289  ctx = _get_ctx(ctx)
3290  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3291 
3292 
def IntSort
Definition: z3py.py:3134
def FreshInt
Definition: z3py.py:3279
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
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 3336 of file z3py.py.

3336 def FreshReal(prefix="b", ctx=None):
3337  """Return a fresh real constant in the given context using the given prefix.
3338 
3339  >>> x = FreshReal()
3340  >>> y = FreshReal()
3341  >>> eq(x, y)
3342  False
3343  >>> x.sort()
3344  Real
3345  """
3346  ctx = _get_ctx(ctx)
3347  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3348 
3349 
def RealSort
Definition: z3py.py:3151
def FreshReal
Definition: z3py.py:3336
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
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 11023 of file z3py.py.

11023 def Full(s):
11024  """Create the regular expression that accepts the universal language
11025  >>> e = Full(ReSort(SeqSort(IntSort())))
11026  >>> print(e)
11027  Full(ReSort(Seq(Int)))
11028  >>> e1 = Full(ReSort(StringSort()))
11029  >>> print(e1)
11030  Full(ReSort(String))
11031  """
11032  if isinstance(s, ReSortRef):
11033  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11034  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11035 
11036 
11037 
def Full(s)
Definition: z3py.py:11023
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
def z3py.FullSet (   s)
Create the full set
>>> FullSet(IntSort())
K(Int, True)

Definition at line 4923 of file z3py.py.

4923 def FullSet(s):
4924  """Create the full set
4925  >>> FullSet(IntSort())
4926  K(Int, True)
4927  """
4928  ctx = s.ctx
4929  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4930 
4931 
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
def FullSet(s)
Definition: z3py.py:4923
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 859 of file z3py.py.

Referenced by ModelRef.__getitem__(), ModelRef.__len__(), FuncEntry.arg_value(), FuncInterp.arity(), FuncEntry.as_list(), FuncInterp.as_list(), QuantifierRef.body(), QuantifierRef.children(), ModelRef.decls(), FuncInterp.else_value(), FuncInterp.entry(), Exists(), ForAll(), ModelRef.get_interp(), get_map_func(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), QuantifierRef.is_lambda(), is_map(), is_pattern(), is_quantifier(), Lambda(), Map(), MultiPattern(), FuncEntry.num_args(), FuncInterp.num_entries(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), QuantifierRef.pattern(), FuncEntry.value(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

859 def Function(name, *sig):
860  """Create a new Z3 uninterpreted function with the given sorts.
861 
862  >>> f = Function('f', IntSort(), IntSort())
863  >>> f(f(0))
864  f(f(0))
865  """
866  sig = _get_args(sig)
867  if z3_debug():
868  _z3_assert(len(sig) > 0, "At least two arguments expected")
869  arity = len(sig) - 1
870  rng = sig[arity]
871  if z3_debug():
872  _z3_assert(is_sort(rng), "Z3 sort expected")
873  dom = (Sort * arity)()
874  for i in range(arity):
875  if z3_debug():
876  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
877  dom[i] = sig[i].ast
878  ctx = rng.ctx
879  return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
880 
881 
Function Declarations.
Definition: z3py.py:718
def Function(name, sig)
Definition: z3py.py:859
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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.
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
def to_symbol
Definition: z3py.py:124
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 6691 of file z3py.py.

6692  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6693  if z3_debug():
6694  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6695  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6696 
Function Declarations.
Definition: z3py.py:718
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.
def get_as_array_func(n)
Definition: z3py.py:6691
def z3_debug()
Definition: z3py.py:62
def is_as_array(n)
Definition: z3py.py:6686
def z3py.get_ctx (   ctx)

Definition at line 267 of file z3py.py.

267 def get_ctx(ctx):
268  return _get_ctx(ctx)
269 
270 
def get_ctx(ctx)
Definition: z3py.py:267
def z3py.get_default_fp_sort (   ctx = None)

Definition at line 9371 of file z3py.py.

9371 def get_default_fp_sort(ctx=None):
9372  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9373 
9374 
def get_default_fp_sort
Definition: z3py.py:9371
def FPSort
Definition: z3py.py:9949
def z3py.get_default_rounding_mode (   ctx = None)
Retrieves the global default rounding mode.

Definition at line 9338 of file z3py.py.

9339  """Retrieves the global default rounding mode."""
9340  global _dflt_rounding_mode
9341  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9342  return RTZ(ctx)
9343  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9344  return RTN(ctx)
9345  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9346  return RTP(ctx)
9347  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9348  return RNE(ctx)
9349  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9350  return RNA(ctx)
9351 
9352 
def RNE
Definition: z3py.py:9719
def RNA
Definition: z3py.py:9729
def get_default_rounding_mode
Definition: z3py.py:9338
def RTP
Definition: z3py.py:9739
def RTZ
Definition: z3py.py:9759
def RTN
Definition: z3py.py:9749
def z3py.get_full_version ( )

Definition at line 101 of file z3py.py.

102  return Z3_get_full_version()
103 
104 
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.
def get_full_version()
Definition: z3py.py:101
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 4668 of file z3py.py.

4669  """Return the function declaration associated with a Z3 map array expression.
4670 
4671  >>> f = Function('f', IntSort(), IntSort())
4672  >>> b = Array('b', IntSort(), IntSort())
4673  >>> a = Map(f, b)
4674  >>> eq(f, get_map_func(a))
4675  True
4676  >>> get_map_func(a)
4677  f
4678  >>> get_map_func(a)(0)
4679  f(0)
4680  """
4681  if z3_debug():
4682  _z3_assert(is_map(a), "Z3 array map expression expected.")
4683  return FuncDeclRef(
4685  a.ctx_ref(),
4686  Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4687  ),
4688  ctx=a.ctx,
4689  )
4690 
4691 
Function Declarations.
Definition: z3py.py:718
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.
def is_map(a)
Definition: z3py.py:4643
def get_map_func(a)
Definition: z3py.py:4668
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.
def z3_debug()
Definition: z3py.py:62
def z3py.get_param (   name)
Return the value of a Z3 global (or module) parameter

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

Definition at line 307 of file z3py.py.

307 def get_param(name):
308  """Return the value of a Z3 global (or module) parameter
309 
310  >>> get_param('nlsat.reorder')
311  'true'
312  """
313  ptr = (ctypes.c_char_p * 1)()
314  if Z3_global_param_get(str(name), ptr):
315  r = z3core._to_pystr(ptr[0])
316  return r
317  raise Z3Exception("failed to retrieve value for '%s'" % name)
318 
bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.
def get_param(name)
Definition: z3py.py:307
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 1331 of file z3py.py.

1332  """Return the de-Bruijn index of the Z3 bounded variable `a`.
1333 
1334  >>> x = Int('x')
1335  >>> y = Int('y')
1336  >>> is_var(x)
1337  False
1338  >>> is_const(x)
1339  True
1340  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1341  >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1342  >>> q = ForAll([x, y], f(x, y) == x + y)
1343  >>> q.body()
1344  f(Var(1), Var(0)) == Var(1) + Var(0)
1345  >>> b = q.body()
1346  >>> b.arg(0)
1347  f(Var(1), Var(0))
1348  >>> v1 = b.arg(0).arg(0)
1349  >>> v2 = b.arg(0).arg(1)
1350  >>> v1
1351  Var(1)
1352  >>> v2
1353  Var(0)
1354  >>> get_var_index(v1)
1355  1
1356  >>> get_var_index(v2)
1357  0
1358  """
1359  if z3_debug():
1360  _z3_assert(is_var(a), "Z3 bound variable expected")
1361  return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1362 
1363 
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.
def z3_debug()
Definition: z3py.py:62
def get_var_index(a)
Definition: z3py.py:1331
def is_var(a)
Definition: z3py.py:1306
def z3py.get_version ( )

Definition at line 92 of file z3py.py.

93  major = ctypes.c_uint(0)
94  minor = ctypes.c_uint(0)
95  build = ctypes.c_uint(0)
96  rev = ctypes.c_uint(0)
97  Z3_get_version(major, minor, build, rev)
98  return (major.value, minor.value, build.value, rev.value)
99 
100 
def get_version()
Definition: z3py.py:92
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
def z3py.get_version_string ( )

Definition at line 83 of file z3py.py.

84  major = ctypes.c_uint(0)
85  minor = ctypes.c_uint(0)
86  build = ctypes.c_uint(0)
87  rev = ctypes.c_uint(0)
88  Z3_get_version(major, minor, build, rev)
89  return "%s.%s.%s" % (major.value, minor.value, build.value)
90 
91 
def get_version_string()
Definition: z3py.py:83
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
def z3py.help_simplify ( )
Return a string describing all options available for Z3 `simplify` procedure.

Definition at line 8844 of file z3py.py.

8845  """Return a string describing all options available for Z3 `simplify` procedure."""
8846  print(Z3_simplify_get_help(main_ctx().ref()))
8847 
8848 
def main_ctx()
Definition: z3py.py:239
def help_simplify()
Definition: z3py.py:8844
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.
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 1377 of file z3py.py.

Referenced by BoolRef.__mul__(), Abs(), BV2Int(), and Lambda().

1377 def If(a, b, c, ctx=None):
1378  """Create a Z3 if-then-else expression.
1379 
1380  >>> x = Int('x')
1381  >>> y = Int('y')
1382  >>> max = If(x > y, x, y)
1383  >>> max
1384  If(x > y, x, y)
1385  >>> simplify(max)
1386  If(x <= y, y, x)
1387  """
1388  if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1389  return Cond(a, b, c, ctx)
1390  else:
1391  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1392  s = BoolSort(ctx)
1393  a = s.cast(a)
1394  b, c = _coerce_exprs(b, c, ctx)
1395  if z3_debug():
1396  _z3_assert(a.ctx == b.ctx, "Context mismatch")
1397  return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1398 
1399 
def BoolSort
Definition: z3py.py:1687
def If
Definition: z3py.py:1377
def Cond
Definition: z3py.py:8802
def z3_debug()
Definition: z3py.py:62
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).
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 1781 of file z3py.py.

Referenced by Fixedpoint.add_rule(), Solver.consequences(), Store(), Solver.unsat_core(), Update(), and Fixedpoint.update_rule().

1781 def Implies(a, b, ctx=None):
1782  """Create a Z3 implies expression.
1783 
1784  >>> p, q = Bools('p q')
1785  >>> Implies(p, q)
1786  Implies(p, q)
1787  """
1788  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1789  s = BoolSort(ctx)
1790  a = s.cast(a)
1791  b = s.cast(b)
1792  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1793 
1794 
def BoolSort
Definition: z3py.py:1687
def Implies
Definition: z3py.py:1781
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
def z3py.IndexOf (   s,
  substr,
  offset = None 
)
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 11107 of file z3py.py.

11107 def IndexOf(s, substr, offset=None):
11108  """Retrieve the index of substring within a string starting at a specified offset.
11109  >>> simplify(IndexOf("abcabc", "bc", 0))
11110  1
11111  >>> simplify(IndexOf("abcabc", "bc", 2))
11112  4
11113  """
11114  if offset is None:
11115  offset = IntVal(0)
11116  ctx = None
11117  if is_expr(offset):
11118  ctx = offset.ctx
11119  ctx = _get_ctx2(s, substr, ctx)
11120  s = _coerce_seq(s, ctx)
11121  substr = _coerce_seq(substr, ctx)
11122  if _is_int(offset):
11123  offset = IntVal(offset, ctx)
11124  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11125 
11126 
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of the first occurrence of substr in s starting from offset offset. If s does not contai...
def is_expr(a)
Definition: z3py.py:1238
def IndexOf
Definition: z3py.py:11107
def IntVal
Definition: z3py.py:3180
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 11220 of file z3py.py.

Referenced by Loop(), Option(), Plus(), Range(), Star(), and Union().

11220 def InRe(s, re):
11221  """Create regular expression membership test
11222  >>> re = Union(Re("a"),Re("b"))
11223  >>> print (simplify(InRe("a", re)))
11224  True
11225  >>> print (simplify(InRe("b", re)))
11226  True
11227  >>> print (simplify(InRe("c", re)))
11228  False
11229  """
11230  s = _coerce_seq(s, re.ctx)
11231  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11232 
11233 
def InRe(s, re)
Definition: z3py.py:11220
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.
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 3240 of file z3py.py.

Referenced by ArithRef.__add__(), AstVector.__contains__(), AstMap.__contains__(), ArithRef.__div__(), Statistics.__getattr__(), ArrayRef.__getitem__(), AstVector.__getitem__(), AstMap.__getitem__(), ModelRef.__getitem__(), Statistics.__getitem__(), AstVector.__len__(), AstMap.__len__(), ModelRef.__len__(), Statistics.__len__(), ArithRef.__mod__(), ArithRef.__neg__(), ArithRef.__pos__(), ArithRef.__radd__(), ArithRef.__rdiv__(), ArithRef.__rmod__(), ArithRef.__rsub__(), AstVector.__setitem__(), AstMap.__setitem__(), ArithRef.__sub__(), Goal.add(), Solver.add(), Goal.append(), Solver.append(), Goal.as_expr(), Solver.assert_and_track(), Goal.assert_exprs(), Solver.assert_exprs(), Solver.assertions(), QuantifierRef.body(), BV2Int(), Solver.check(), QuantifierRef.children(), ModelRef.decls(), AstMap.erase(), ModelRef.eval(), ModelRef.evaluate(), Exists(), ForAll(), ModelRef.get_interp(), Statistics.get_key_value(), Goal.insert(), Solver.insert(), is_arith(), is_arith_sort(), is_bv(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), is_fp(), ArithSortRef.is_int(), ArithRef.is_int(), is_int(), is_int_value(), QuantifierRef.is_lambda(), is_pattern(), is_quantifier(), ArithSortRef.is_real(), is_real(), is_select(), is_to_real(), K(), AstMap.keys(), Statistics.keys(), Solver.model(), MultiPattern(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), QuantifierRef.pattern(), Solver.pop(), AstVector.push(), Solver.push(), Solver.reason_unknown(), AstMap.reset(), Solver.reset(), AstVector.resize(), Select(), Solver.sexpr(), Goal.simplify(), ArithRef.sort(), Solver.statistics(), Store(), ToReal(), Goal.translate(), AstVector.translate(), Update(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

3240 def Int(name, ctx=None):
3241  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3242 
3243  >>> x = Int('x')
3244  >>> is_int(x)
3245  True
3246  >>> is_int(x + 1)
3247  True
3248  """
3249  ctx = _get_ctx(ctx)
3250  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3251 
3252 
def IntSort
Definition: z3py.py:3134
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def Int
Definition: z3py.py:3240
def to_symbol
Definition: z3py.py:124
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 3988 of file z3py.py.

3988 def Int2BV(a, num_bits):
3989  """Return the z3 expression Int2BV(a, num_bits).
3990  It is a bit-vector of width num_bits and represents the
3991  modulo of a by 2^num_bits
3992  """
3993  ctx = a.ctx
3994  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3995 
3996 
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.
def Int2BV(a, num_bits)
Definition: z3py.py:3988
def z3py.Intersect (   args)
Create intersection of regular expressions.
>>> re = Intersect(Re("a"), Re("b"), Re("c"))

Definition at line 11254 of file z3py.py.

11254 def Intersect(*args):
11255  """Create intersection of regular expressions.
11256  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11257  """
11258  args = _get_args(args)
11259  sz = len(args)
11260  if z3_debug():
11261  _z3_assert(sz > 0, "At least one argument expected.")
11262  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11263  if sz == 1:
11264  return args[0]
11265  ctx = args[0].ctx
11266  v = (Ast * sz)()
11267  for i in range(sz):
11268  v[i] = args[i].as_ast()
11269  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11270 
11271 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Intersect(args)
Definition: z3py.py:11254
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
def is_re(s)
Definition: z3py.py:11216
def z3_debug()
Definition: z3py.py:62
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 3253 of file z3py.py.

Referenced by ArithRef.__ge__(), Goal.__getitem__(), ArithRef.__gt__(), ArithRef.__le__(), Goal.__len__(), ArithRef.__lt__(), Goal.convert_model(), Goal.depth(), Goal.get(), Goal.inconsistent(), is_add(), is_div(), is_ge(), is_gt(), is_idiv(), is_le(), is_lt(), is_mod(), is_mul(), is_sub(), Lambda(), Goal.prec(), Goal.size(), Store(), Solver.unsat_core(), and Update().

3253 def Ints(names, ctx=None):
3254  """Return a tuple of Integer constants.
3255 
3256  >>> x, y, z = Ints('x y z')
3257  >>> Sum(x, y, z)
3258  x + y + z
3259  """
3260  ctx = _get_ctx(ctx)
3261  if isinstance(names, str):
3262  names = names.split(" ")
3263  return [Int(name, ctx) for name in names]
3264 
3265 
def Ints
Definition: z3py.py:3253
def Int
Definition: z3py.py:3240
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 3134 of file z3py.py.

Referenced by ArrayRef.__getitem__(), ModelRef.__getitem__(), ModelRef.__len__(), DatatypeSortRef.accessor(), FuncEntry.arg_value(), FuncInterp.arity(), Array(), ArraySort(), FuncEntry.as_list(), FuncInterp.as_list(), QuantifierRef.body(), ArithSortRef.cast(), QuantifierRef.children(), DatatypeSortRef.constructor(), Datatype.create(), CreateDatatypes(), Datatype.declare(), ModelRef.decls(), Default(), DisjointSum(), ArraySortRef.domain(), ArrayRef.domain(), FuncInterp.else_value(), Empty(), EmptySet(), FuncInterp.entry(), Exists(), Ext(), ForAll(), FreshInt(), Full(), FullSet(), ModelRef.get_interp(), get_map_func(), Int(), is_arith_sort(), is_array(), is_bv_sort(), is_const_array(), is_default(), QuantifierRef.is_exists(), QuantifierRef.is_forall(), is_fp_sort(), is_K(), QuantifierRef.is_lambda(), is_map(), is_pattern(), is_quantifier(), is_select(), is_store(), SeqSortRef.is_string(), IsMember(), IsSubset(), K(), Lambda(), Map(), MultiPattern(), FuncEntry.num_args(), DatatypeSortRef.num_constructors(), FuncInterp.num_entries(), QuantifierRef.num_patterns(), QuantifierRef.num_vars(), QuantifierRef.pattern(), ArraySortRef.range(), ArrayRef.range(), DatatypeSortRef.recognizer(), Select(), SeqSort(), SetAdd(), SetComplement(), SetDel(), SetDifference(), SetIntersect(), SetUnion(), ArrayRef.sort(), Store(), TupleSort(), Update(), FuncEntry.value(), QuantifierRef.var_name(), QuantifierRef.var_sort(), and QuantifierRef.weight().

3134 def IntSort(ctx=None):
3135  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3136 
3137  >>> IntSort()
3138  Int
3139  >>> x = Const('x', IntSort())
3140  >>> is_int(x)
3141  True
3142  >>> x.sort() == IntSort()
3143  True
3144  >>> x.sort() == BoolSort()
3145  False
3146  """
3147  ctx = _get_ctx(ctx)
3148  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3149 
3150 
def IntSort
Definition: z3py.py:3134
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Arithmetic.
Definition: z3py.py:2284
def z3py.IntToStr (   s)
Convert integer expression to string

Definition at line 11162 of file z3py.py.

Referenced by StrToInt().

11162 def IntToStr(s):
11163  """Convert integer expression to string"""
11164  if not is_expr(s):
11165  s = _py2expr(s)
11166  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11167 
11168 
def IntToStr(s)
Definition: z3py.py:11162
def is_expr(a)
Definition: z3py.py:1238
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
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 3180 of file z3py.py.

Referenced by AstMap.__len__(), ArithRef.__mod__(), BoolRef.__mul__(), ArithRef.__pow__(), ArithRef.__rpow__(), AstMap.__setitem__(), IntNumRef.as_binary_string(), IntNumRef.as_long(), IntNumRef.as_string(), IndexOf(), is_arith(), is_int(), is_int_value(), is_rational_value(), is_seq(), AstMap.keys(), AstMap.reset(), and SeqSort().

3180 def IntVal(val, ctx=None):
3181  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3182 
3183  >>> IntVal(1)
3184  1
3185  >>> IntVal("100")
3186  100
3187  """
3188  ctx = _get_ctx(ctx)
3189  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3190 
3191 
def IntSort
Definition: z3py.py:3134
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
def IntVal
Definition: z3py.py:3180
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 3266 of file z3py.py.

3266 def IntVector(prefix, sz, ctx=None):
3267  """Return a list of integer constants of size `sz`.
3268 
3269  >>> X = IntVector('x', 3)
3270  >>> X
3271  [x__0, x__1, x__2]
3272  >>> Sum(X)
3273  x__0 + x__1 + x__2
3274  """
3275  ctx = _get_ctx(ctx)
3276  return [Int("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3277 
3278 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Int
Definition: z3py.py:3240
def IntVector
Definition: z3py.py:3266
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 2788 of file z3py.py.

2788 def is_add(a):
2789  """Return `True` if `a` is an expression of the form b + c.
2790 
2791  >>> x, y = Ints('x y')
2792  >>> is_add(x + y)
2793  True
2794  >>> is_add(x - y)
2795  False
2796  """
2797  return is_app_of(a, Z3_OP_ADD)
2798 
2799 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_add(a)
Definition: z3py.py:2788
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 2774 of file z3py.py.

2775  """Return `True` if `a` is an algebraic value of sort Real.
2776 
2777  >>> is_algebraic_value(RealVal("3/5"))
2778  False
2779  >>> n = simplify(Sqrt(2))
2780  >>> n
2781  1.4142135623?
2782  >>> is_algebraic_value(n)
2783  True
2784  """
2785  return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2786 
2787 
def is_arith(a)
Definition: z3py.py:2661
def is_algebraic_value(a)
Definition: z3py.py:2774
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 1617 of file z3py.py.

1617 def is_and(a):
1618  """Return `True` if `a` is a Z3 and expression.
1619 
1620  >>> p, q = Bools('p q')
1621  >>> is_and(And(p, q))
1622  True
1623  >>> is_and(Or(p, q))
1624  False
1625  """
1626  return is_app_of(a, Z3_OP_AND)
1627 
1628 
def is_and(a)
Definition: z3py.py:1617
def is_app_of(a, k)
Definition: z3py.py:1364
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 1261 of file z3py.py.

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

1261 def is_app(a):
1262  """Return `True` if `a` is a Z3 function application.
1263 
1264  Note that, constants are function applications with 0 arguments.
1265 
1266  >>> a = Int('a')
1267  >>> is_app(a)
1268  True
1269  >>> is_app(a + 1)
1270  True
1271  >>> is_app(IntSort())
1272  False
1273  >>> is_app(1)
1274  False
1275  >>> is_app(IntVal(1))
1276  True
1277  >>> x = Int('x')
1278  >>> is_app(ForAll(x, x >= 0))
1279  False
1280  """
1281  if not isinstance(a, ExprRef):
1282  return False
1283  k = _ast_kind(a.ctx, a)
1284  return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1285 
1286 
def is_app(a)
Definition: z3py.py:1261
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 1364 of file z3py.py.

Referenced by is_add(), is_and(), is_distinct(), is_eq(), is_false(), is_implies(), is_not(), is_or(), and is_true().

1364 def is_app_of(a, k):
1365  """Return `True` if `a` is an application of the given kind `k`.
1366 
1367  >>> x = Int('x')
1368  >>> n = x + 1
1369  >>> is_app_of(n, Z3_OP_ADD)
1370  True
1371  >>> is_app_of(n, Z3_OP_MUL)
1372  False
1373  """
1374  return is_app(a) and a.decl().kind() == k
1375 
1376 
def is_app(a)
Definition: z3py.py:1261
def is_app_of(a, k)
Definition: z3py.py:1364
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 2661 of file z3py.py.

Referenced by is_algebraic_value().

2661 def is_arith(a):
2662  """Return `True` if `a` is an arithmetical expression.
2663 
2664  >>> x = Int('x')
2665  >>> is_arith(x)
2666  True
2667  >>> is_arith(x + 1)
2668  True
2669  >>> is_arith(1)
2670  False
2671  >>> is_arith(IntVal(1))
2672  True
2673  >>> y = Real('y')
2674  >>> is_arith(y)
2675  True
2676  >>> is_arith(y + 1)
2677  True
2678  """
2679  return isinstance(a, ArithRef)
2680 
2681 
def is_arith(a)
Definition: z3py.py:2661
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 2360 of file z3py.py.

2361  """Return `True` if s is an arithmetical sort (type).
2362 
2363  >>> is_arith_sort(IntSort())
2364  True
2365  >>> is_arith_sort(RealSort())
2366  True
2367  >>> is_arith_sort(BoolSort())
2368  False
2369  >>> n = Int('x') + 1
2370  >>> is_arith_sort(n.sort())
2371  True
2372  """
2373  return isinstance(s, ArithSortRef)
2374 
2375 
def is_arith_sort(s)
Definition: z3py.py:2360
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 4603 of file z3py.py.

Referenced by Ext().

4603 def is_array(a):
4604  """Return `True` if `a` is a Z3 array expression.
4605 
4606  >>> a = Array('a', IntSort(), IntSort())
4607  >>> is_array(a)
4608  True
4609  >>> is_array(Store(a, 0, 1))
4610  True
4611  >>> is_array(a[0])
4612  False
4613  """
4614  return isinstance(a, ArrayRef)
4615 
4616 
def is_array(a)
Definition: z3py.py:4603
def z3py.is_array_sort (   a)

Definition at line 4599 of file z3py.py.

Referenced by Default(), and Ext().

4600  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4601 
4602 
def is_array_sort(a)
Definition: z3py.py:4599
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
def z3py.is_as_array (   n)
Return true if n is a Z3 expression of the form (_ as-array f).

Definition at line 6686 of file z3py.py.

Referenced by get_as_array_func().

6687  """Return true if n is a Z3 expression of the form (_ as-array f)."""
6688  return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6689 
6690 
def is_as_array(n)
Definition: z3py.py:6686
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...
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 451 of file z3py.py.

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

451 def is_ast(a):
452  """Return `True` if `a` is an AST node.
453 
454  >>> is_ast(10)
455  False
456  >>> is_ast(IntVal(10))
457  True
458  >>> is_ast(Int('x'))
459  True
460  >>> is_ast(BoolSort())
461  True
462  >>> is_ast(Function('f', IntSort(), IntSort()))
463  True
464  >>> is_ast("x")
465  False
466  >>> is_ast(Solver())
467  False
468  """
469  return isinstance(a, AstRef)
470 
471 
def is_ast(a)
Definition: z3py.py:451
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 1567 of file z3py.py.

Referenced by BoolSort(), and prove().

1567 def is_bool(a):
1568  """Return `True` if `a` is a Z3 Boolean expression.
1569 
1570  >>> p = Bool('p')
1571  >>> is_bool(p)
1572  True
1573  >>> q = Bool('q')
1574  >>> is_bool(And(p, q))
1575  True
1576  >>> x = Real('x')
1577  >>> is_bool(x)
1578  False
1579  >>> is_bool(x == 0)
1580  True
1581  """
1582  return isinstance(a, BoolRef)
1583 
1584 
def is_bool(a)
Definition: z3py.py:1567
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 3936 of file z3py.py.

Referenced by BitVec(), BV2Int(), BVRedAnd(), BVRedOr(), BVSNegNoOverflow(), Concat(), Extract(), fpBVToFP(), fpFP(), fpSignedToFP(), fpToFP(), fpToFPUnsigned(), fpToIEEEBV(), fpToSBV(), fpToUBV(), fpUnsignedToFP(), Product(), and Sum().

3936 def is_bv(a):
3937  """Return `True` if `a` is a Z3 bit-vector expression.
3938 
3939  >>> b = BitVec('b', 32)
3940  >>> is_bv(b)
3941  True
3942  >>> is_bv(b + 10)
3943  True
3944  >>> is_bv(Int('x'))
3945  False
3946  """
3947  return isinstance(a, BitVecRef)
3948 
3949 
def is_bv(a)
Definition: z3py.py:3936
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 3468 of file z3py.py.

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

3468 def is_bv_sort(s):
3469  """Return True if `s` is a Z3 bit-vector sort.
3470 
3471  >>> is_bv_sort(BitVecSort(32))
3472  True
3473  >>> is_bv_sort(IntSort())
3474  False
3475  """
3476  return isinstance(s, BitVecSortRef)
3477 
3478 
def is_bv_sort(s)
Definition: z3py.py:3468
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 3950 of file z3py.py.

3951  """Return `True` if `a` is a Z3 bit-vector numeral value.
3952 
3953  >>> b = BitVec('b', 32)
3954  >>> is_bv_value(b)
3955  False
3956  >>> b = BitVecVal(10, 32)
3957  >>> b
3958  10
3959  >>> is_bv_value(b)
3960  True
3961  """
3962  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3963 
3964 
def is_bv_value(a)
Definition: z3py.py:3950
def is_bv(a)
Definition: z3py.py:3936
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 1287 of file z3py.py.

Referenced by Optimize.assert_and_track(), and prove().

1287 def is_const(a):
1288  """Return `True` if `a` is Z3 constant/variable expression.
1289 
1290  >>> a = Int('a')
1291  >>> is_const(a)
1292  True
1293  >>> is_const(a + 1)
1294  False
1295  >>> is_const(1)
1296  False
1297  >>> is_const(IntVal(1))
1298  True
1299  >>> x = Int('x')
1300  >>> is_const(ForAll(x, x >= 0))
1301  False
1302  """
1303  return is_app(a) and a.num_args() == 0
1304 
1305 
def is_app(a)
Definition: z3py.py:1261
def is_const(a)
Definition: z3py.py:1287
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 4617 of file z3py.py.

4618  """Return `True` if `a` is a Z3 constant array.
4619 
4620  >>> a = K(IntSort(), 10)
4621  >>> is_const_array(a)
4622  True
4623  >>> a = Array('a', IntSort(), IntSort())
4624  >>> is_const_array(a)
4625  False
4626  """
4627  return is_app_of(a, Z3_OP_CONST_ARRAY)
4628 
4629 
def is_const_array(a)
Definition: z3py.py:4617
def is_app_of(a, k)
Definition: z3py.py:1364
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 4659 of file z3py.py.

4659 def is_default(a):
4660  """Return `True` if `a` is a Z3 default array expression.
4661  >>> d = Default(K(IntSort(), 10))
4662  >>> is_default(d)
4663  True
4664  """
4665  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4666 
4667 
def is_default(a)
Definition: z3py.py:4659
def is_app_of(a, k)
Definition: z3py.py:1364
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 1675 of file z3py.py.

1676  """Return `True` if `a` is a Z3 distinct expression.
1677 
1678  >>> x, y, z = Ints('x y z')
1679  >>> is_distinct(x == y)
1680  False
1681  >>> is_distinct(Distinct(x, y, z))
1682  True
1683  """
1684  return is_app_of(a, Z3_OP_DISTINCT)
1685 
1686 
def is_distinct(a)
Definition: z3py.py:1675
def is_app_of(a, k)
Definition: z3py.py:1364
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 2824 of file z3py.py.

2824 def is_div(a):
2825  """Return `True` if `a` is an expression of the form b / c.
2826 
2827  >>> x, y = Reals('x y')
2828  >>> is_div(x / y)
2829  True
2830  >>> is_div(x + y)
2831  False
2832  >>> x, y = Ints('x y')
2833  >>> is_div(x / y)
2834  False
2835  >>> is_idiv(x / y)
2836  True
2837  """
2838  return is_app_of(a, Z3_OP_DIV)
2839 
2840 
def is_div(a)
Definition: z3py.py:2824
def is_app_of(a, k)
Definition: z3py.py:1364
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 1665 of file z3py.py.

Referenced by AstRef.__bool__().

1665 def is_eq(a):
1666  """Return `True` if `a` is a Z3 equality expression.
1667 
1668  >>> x, y = Ints('x y')
1669  >>> is_eq(x == y)
1670  True
1671  """
1672  return is_app_of(a, Z3_OP_EQ)
1673 
1674 
def is_eq(a)
Definition: z3py.py:1665
def is_app_of(a, k)
Definition: z3py.py:1364
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 1238 of file z3py.py.

Referenced by SortRef.cast(), BoolSortRef.cast(), Cbrt(), CharFromBv(), Concat(), deserialize(), IndexOf(), IntToStr(), is_var(), simplify(), substitute(), substitute_funs(), and substitute_vars().

1238 def is_expr(a):
1239  """Return `True` if `a` is a Z3 expression.
1240 
1241  >>> a = Int('a')
1242  >>> is_expr(a)
1243  True
1244  >>> is_expr(a + 1)
1245  True
1246  >>> is_expr(IntSort())
1247  False
1248  >>> is_expr(1)
1249  False
1250  >>> is_expr(IntVal(1))
1251  True
1252  >>> x = Int('x')
1253  >>> is_expr(ForAll(x, x >= 0))
1254  True
1255  >>> is_expr(FPVal(1.0))
1256  True
1257  """
1258  return isinstance(a, ExprRef)
1259 
1260 
def is_expr(a)
Definition: z3py.py:1238
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 1603 of file z3py.py.

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

1603 def is_false(a):
1604  """Return `True` if `a` is the Z3 false expression.
1605 
1606  >>> p = Bool('p')
1607  >>> is_false(p)
1608  False
1609  >>> is_false(False)
1610  False
1611  >>> is_false(BoolVal(False))
1612  True
1613  """
1614  return is_app_of(a, Z3_OP_FALSE)
1615 
1616 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_false(a)
Definition: z3py.py:1603
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 7739 of file z3py.py.

Referenced by is_finite_domain_value().

7740  """Return `True` if `a` is a Z3 finite-domain expression.
7741 
7742  >>> s = FiniteDomainSort('S', 100)
7743  >>> b = Const('b', s)
7744  >>> is_finite_domain(b)
7745  True
7746  >>> is_finite_domain(Int('x'))
7747  False
7748  """
7749  return isinstance(a, FiniteDomainRef)
7750 
7751 
def is_finite_domain(a)
Definition: z3py.py:7739
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 7716 of file z3py.py.

Referenced by FiniteDomainVal().

7717  """Return True if `s` is a Z3 finite-domain sort.
7718 
7719  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7720  True
7721  >>> is_finite_domain_sort(IntSort())
7722  False
7723  """
7724  return isinstance(s, FiniteDomainSortRef)
7725 
7726 
def is_finite_domain_sort(s)
Definition: z3py.py:7716
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 7793 of file z3py.py.

7794  """Return `True` if `a` is a Z3 finite-domain value.
7795 
7796  >>> s = FiniteDomainSort('S', 100)
7797  >>> b = Const('b', s)
7798  >>> is_finite_domain_value(b)
7799  False
7800  >>> b = FiniteDomainVal(10, s)
7801  >>> b
7802  10
7803  >>> is_finite_domain_value(b)
7804  True
7805  """
7806  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7807 
7808 
def is_finite_domain_value(a)
Definition: z3py.py:7793
def is_finite_domain(a)
Definition: z3py.py:7739
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 9920 of file z3py.py.

Referenced by FP(), fpFPToFP(), fpToFP(), fpToIEEEBV(), fpToReal(), fpToSBV(), and fpToUBV().

9920 def is_fp(a):
9921  """Return `True` if `a` is a Z3 floating-point expression.
9922 
9923  >>> b = FP('b', FPSort(8, 24))
9924  >>> is_fp(b)
9925  True
9926  >>> is_fp(b + 1.0)
9927  True
9928  >>> is_fp(Int('x'))
9929  False
9930  """
9931  return isinstance(a, FPRef)
9932 
9933 
def is_fp(a)
Definition: z3py.py:9920
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 9504 of file z3py.py.

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

9504 def is_fp_sort(s):
9505  """Return True if `s` is a Z3 floating-point sort.
9506 
9507  >>> is_fp_sort(FPSort(8, 24))
9508  True
9509  >>> is_fp_sort(IntSort())
9510  False
9511  """
9512  return isinstance(s, FPSortRef)
9513 
9514 
def is_fp_sort(s)
Definition: z3py.py:9504
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 9934 of file z3py.py.

9935  """Return `True` if `a` is a Z3 floating-point numeral value.
9936 
9937  >>> b = FP('b', FPSort(8, 24))
9938  >>> is_fp_value(b)
9939  False
9940  >>> b = FPVal(1.0, FPSort(8, 24))
9941  >>> b
9942  1
9943  >>> is_fp_value(b)
9944  True
9945  """
9946  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9947 
9948 
def is_fp_value(a)
Definition: z3py.py:9934
def is_fp(a)
Definition: z3py.py:9920
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 9764 of file z3py.py.

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

9764 def is_fprm(a):
9765  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9766 
9767  >>> rm = RNE()
9768  >>> is_fprm(rm)
9769  True
9770  >>> rm = 1.0
9771  >>> is_fprm(rm)
9772  False
9773  """
9774  return isinstance(a, FPRMRef)
9775 
9776 
def is_fprm(a)
Definition: z3py.py:9764
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 9515 of file z3py.py.

9516  """Return True if `s` is a Z3 floating-point rounding mode sort.
9517 
9518  >>> is_fprm_sort(FPSort(8, 24))
9519  False
9520  >>> is_fprm_sort(RNE().sort())
9521  True
9522  """
9523  return isinstance(s, FPRMSortRef)
9524 
9525 # FP Expressions
9526 
9527 
def is_fprm_sort(s)
Definition: z3py.py:9515
def z3py.is_fprm_value (   a)
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.

Definition at line 9777 of file z3py.py.

9778  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9779  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9780 
9781 # FP Numerals
9782 
9783 
def is_fprm_value(a)
Definition: z3py.py:9777
def is_fprm(a)
Definition: z3py.py:9764
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 846 of file z3py.py.

Referenced by prove(), and substitute_funs().

847  """Return `True` if `a` is a Z3 function declaration.
848 
849  >>> f = Function('f', IntSort(), IntSort())
850  >>> is_func_decl(f)
851  True
852  >>> x = Real('x')
853  >>> is_func_decl(x)
854  False
855  """
856  return isinstance(a, FuncDeclRef)
857 
858 
def is_func_decl(a)
Definition: z3py.py:846
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 2889 of file z3py.py.

2889 def is_ge(a):
2890  """Return `True` if `a` is an expression of the form b >= c.
2891 
2892  >>> x, y = Ints('x y')
2893  >>> is_ge(x >= y)
2894  True
2895  >>> is_ge(x == y)
2896  False
2897  """
2898  return is_app_of(a, Z3_OP_GE)
2899 
2900 
def is_ge(a)
Definition: z3py.py:2889
def is_app_of(a, k)
Definition: z3py.py:1364
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 2901 of file z3py.py.

2901 def is_gt(a):
2902  """Return `True` if `a` is an expression of the form b > c.
2903 
2904  >>> x, y = Ints('x y')
2905  >>> is_gt(x > y)
2906  True
2907  >>> is_gt(x == y)
2908  False
2909  """
2910  return is_app_of(a, Z3_OP_GT)
2911 
2912 
def is_gt(a)
Definition: z3py.py:2901
def is_app_of(a, k)
Definition: z3py.py:1364
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 2841 of file z3py.py.

Referenced by is_div().

2841 def is_idiv(a):
2842  """Return `True` if `a` is an expression of the form b div c.
2843 
2844  >>> x, y = Ints('x y')
2845  >>> is_idiv(x / y)
2846  True
2847  >>> is_idiv(x + y)
2848  False
2849  """
2850  return is_app_of(a, Z3_OP_IDIV)
2851 
2852 
def is_idiv(a)
Definition: z3py.py:2841
def is_app_of(a, k)
Definition: z3py.py:1364
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 1641 of file z3py.py.

1641 def is_implies(a):
1642  """Return `True` if `a` is a Z3 implication expression.
1643 
1644  >>> p, q = Bools('p q')
1645  >>> is_implies(Implies(p, q))
1646  True
1647  >>> is_implies(And(p, q))
1648  False
1649  """
1650  return is_app_of(a, Z3_OP_IMPLIES)
1651 
1652 
def is_implies(a)
Definition: z3py.py:1641
def is_app_of(a, k)
Definition: z3py.py:1364
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 2682 of file z3py.py.

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

2682 def is_int(a):
2683  """Return `True` if `a` is an integer expression.
2684 
2685  >>> x = Int('x')
2686  >>> is_int(x + 1)
2687  True
2688  >>> is_int(1)
2689  False
2690  >>> is_int(IntVal(1))
2691  True
2692  >>> y = Real('y')
2693  >>> is_int(y)
2694  False
2695  >>> is_int(y + 1)
2696  False
2697  """
2698  return is_arith(a) and a.is_int()
2699 
2700 
def is_arith(a)
Definition: z3py.py:2661
def is_int(a)
Definition: z3py.py:2682
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 2728 of file z3py.py.

2729  """Return `True` if `a` is an integer value of sort Int.
2730 
2731  >>> is_int_value(IntVal(1))
2732  True
2733  >>> is_int_value(1)
2734  False
2735  >>> is_int_value(Int('x'))
2736  False
2737  >>> n = Int('x') + 1
2738  >>> n
2739  x + 1
2740  >>> n.arg(1)
2741  1
2742  >>> is_int_value(n.arg(1))
2743  True
2744  >>> is_int_value(RealVal("1/3"))
2745  False
2746  >>> is_int_value(RealVal(1))
2747  False
2748  """
2749  return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2750 
2751 
def is_int_value(a)
Definition: z3py.py:2728
def is_arith(a)
Definition: z3py.py:2661
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 2913 of file z3py.py.

2913 def is_is_int(a):
2914  """Return `True` if `a` is an expression of the form IsInt(b).
2915 
2916  >>> x = Real('x')
2917  >>> is_is_int(IsInt(x))
2918  True
2919  >>> is_is_int(x)
2920  False
2921  """
2922  return is_app_of(a, Z3_OP_IS_INT)
2923 
2924 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_is_int(a)
Definition: z3py.py:2913
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 4630 of file z3py.py.

4630 def is_K(a):
4631  """Return `True` if `a` is a Z3 constant array.
4632 
4633  >>> a = K(IntSort(), 10)
4634  >>> is_K(a)
4635  True
4636  >>> a = Array('a', IntSort(), IntSort())
4637  >>> is_K(a)
4638  False
4639  """
4640  return is_app_of(a, Z3_OP_CONST_ARRAY)
4641 
4642 
def is_K(a)
Definition: z3py.py:4630
def is_app_of(a, k)
Definition: z3py.py:1364
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 2865 of file z3py.py.

2865 def is_le(a):
2866  """Return `True` if `a` is an expression of the form b <= c.
2867 
2868  >>> x, y = Ints('x y')
2869  >>> is_le(x <= y)
2870  True
2871  >>> is_le(x < y)
2872  False
2873  """
2874  return is_app_of(a, Z3_OP_LE)
2875 
2876 
def is_le(a)
Definition: z3py.py:2865
def is_app_of(a, k)
Definition: z3py.py:1364
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 2877 of file z3py.py.

2877 def is_lt(a):
2878  """Return `True` if `a` is an expression of the form b < c.
2879 
2880  >>> x, y = Ints('x y')
2881  >>> is_lt(x < y)
2882  True
2883  >>> is_lt(x == y)
2884  False
2885  """
2886  return is_app_of(a, Z3_OP_LT)
2887 
2888 
def is_lt(a)
Definition: z3py.py:2877
def is_app_of(a, k)
Definition: z3py.py:1364
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 4643 of file z3py.py.

Referenced by get_map_func().

4643 def is_map(a):
4644  """Return `True` if `a` is a Z3 map array expression.
4645 
4646  >>> f = Function('f', IntSort(), IntSort())
4647  >>> b = Array('b', IntSort(), IntSort())
4648  >>> a = Map(f, b)
4649  >>> a
4650  Map(f, b)
4651  >>> is_map(a)
4652  True
4653  >>> is_map(b)
4654  False
4655  """
4656  return is_app_of(a, Z3_OP_ARRAY_MAP)
4657 
4658 
def is_map(a)
Definition: z3py.py:4643
def is_app_of(a, k)
Definition: z3py.py:1364
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 2853 of file z3py.py.

2853 def is_mod(a):
2854  """Return `True` if `a` is an expression of the form b % c.
2855 
2856  >>> x, y = Ints('x y')
2857  >>> is_mod(x % y)
2858  True
2859  >>> is_mod(x + y)
2860  False
2861  """
2862  return is_app_of(a, Z3_OP_MOD)
2863 
2864 
def is_mod(a)
Definition: z3py.py:2853
def is_app_of(a, k)
Definition: z3py.py:1364
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 2800 of file z3py.py.

2800 def is_mul(a):
2801  """Return `True` if `a` is an expression of the form b * c.
2802 
2803  >>> x, y = Ints('x y')
2804  >>> is_mul(x * y)
2805  True
2806  >>> is_mul(x - y)
2807  False
2808  """
2809  return is_app_of(a, Z3_OP_MUL)
2810 
2811 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_mul(a)
Definition: z3py.py:2800
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 1653 of file z3py.py.

1653 def is_not(a):
1654  """Return `True` if `a` is a Z3 not expression.
1655 
1656  >>> p = Bool('p')
1657  >>> is_not(p)
1658  False
1659  >>> is_not(Not(p))
1660  True
1661  """
1662  return is_app_of(a, Z3_OP_NOT)
1663 
1664 
def is_not(a)
Definition: z3py.py:1653
def is_app_of(a, k)
Definition: z3py.py:1364
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 1629 of file z3py.py.

1629 def is_or(a):
1630  """Return `True` if `a` is a Z3 or expression.
1631 
1632  >>> p, q = Bools('p q')
1633  >>> is_or(Or(p, q))
1634  True
1635  >>> is_or(And(p, q))
1636  False
1637  """
1638  return is_app_of(a, Z3_OP_OR)
1639 
1640 
def is_or(a)
Definition: z3py.py:1629
def is_app_of(a, k)
Definition: z3py.py:1364
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 1929 of file z3py.py.

Referenced by MultiPattern().

1929 def is_pattern(a):
1930  """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1931 
1932  >>> f = Function('f', IntSort(), IntSort())
1933  >>> x = Int('x')
1934  >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1935  >>> q
1936  ForAll(x, f(x) == 0)
1937  >>> q.num_patterns()
1938  1
1939  >>> is_pattern(q.pattern(0))
1940  True
1941  >>> q.pattern(0)
1942  f(Var(0))
1943  """
1944  return isinstance(a, PatternRef)
1945 
1946 
def is_pattern(a)
Definition: z3py.py:1929
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 8685 of file z3py.py.

Referenced by eq().

8685 def is_probe(p):
8686  """Return `True` if `p` is a Z3 probe.
8687 
8688  >>> is_probe(Int('x'))
8689  False
8690  >>> is_probe(Probe('memory'))
8691  True
8692  """
8693  return isinstance(p, Probe)
8694 
8695 
def is_probe(p)
Definition: z3py.py:8685
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 2169 of file z3py.py.

Referenced by Exists().

2170  """Return `True` if `a` is a Z3 quantifier.
2171 
2172  >>> f = Function('f', IntSort(), IntSort())
2173  >>> x = Int('x')
2174  >>> q = ForAll(x, f(x) == 0)
2175  >>> is_quantifier(q)
2176  True
2177  >>> is_quantifier(f(x))
2178  False
2179  """
2180  return isinstance(a, QuantifierRef)
2181 
2182 
def is_quantifier(a)
Definition: z3py.py:2169
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 2752 of file z3py.py.

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

2753  """Return `True` if `a` is rational value of sort Real.
2754 
2755  >>> is_rational_value(RealVal(1))
2756  True
2757  >>> is_rational_value(RealVal("3/5"))
2758  True
2759  >>> is_rational_value(IntVal(1))
2760  False
2761  >>> is_rational_value(1)
2762  False
2763  >>> n = Real('x') + 1
2764  >>> n.arg(1)
2765  1
2766  >>> is_rational_value(n.arg(1))
2767  True
2768  >>> is_rational_value(Real('x'))
2769  False
2770  """
2771  return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2772 
2773 
def is_arith(a)
Definition: z3py.py:2661
def is_rational_value(a)
Definition: z3py.py:2752
def z3py.is_re (   s)

Definition at line 11216 of file z3py.py.

Referenced by Concat(), and Intersect().

11216 def is_re(s):
11217  return isinstance(s, ReRef)
11218 
11219 
def is_re(s)
Definition: z3py.py:11216
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 2701 of file z3py.py.

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

2701 def is_real(a):
2702  """Return `True` if `a` is a real expression.
2703 
2704  >>> x = Int('x')
2705  >>> is_real(x + 1)
2706  False
2707  >>> y = Real('y')
2708  >>> is_real(y)
2709  True
2710  >>> is_real(y + 1)
2711  True
2712  >>> is_real(1)
2713  False
2714  >>> is_real(RealVal(1))
2715  True
2716  """
2717  return is_arith(a) and a.is_real()
2718 
2719 
def is_real(a)
Definition: z3py.py:2701
def is_arith(a)
Definition: z3py.py:2661
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 4878 of file z3py.py.

4878 def is_select(a):
4879  """Return `True` if `a` is a Z3 array select application.
4880 
4881  >>> a = Array('a', IntSort(), IntSort())
4882  >>> is_select(a)
4883  False
4884  >>> i = Int('i')
4885  >>> is_select(a[i])
4886  True
4887  """
4888  return is_app_of(a, Z3_OP_SELECT)
4889 
4890 
def is_select(a)
Definition: z3py.py:4878
def is_app_of(a, k)
Definition: z3py.py:1364
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 10942 of file z3py.py.

Referenced by Concat(), and Extract().

10942 def is_seq(a):
10943  """Return `True` if `a` is a Z3 sequence expression.
10944  >>> print (is_seq(Unit(IntVal(0))))
10945  True
10946  >>> print (is_seq(StringVal("abc")))
10947  True
10948  """
10949  return isinstance(a, SeqRef)
10950 
10951 
def is_seq(a)
Definition: z3py.py:10942
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 647 of file z3py.py.

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

647 def is_sort(s):
648  """Return `True` if `s` is a Z3 sort.
649 
650  >>> is_sort(IntSort())
651  True
652  >>> is_sort(Int('x'))
653  False
654  >>> is_expr(Int('x'))
655  True
656  """
657  return isinstance(s, SortRef)
658 
659 
def is_sort(s)
Definition: z3py.py:647
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 4891 of file z3py.py.

4891 def is_store(a):
4892  """Return `True` if `a` is a Z3 array store application.
4893 
4894  >>> a = Array('a', IntSort(), IntSort())
4895  >>> is_store(a)
4896  False
4897  >>> is_store(Store(a, 0, 1))
4898  True
4899  """
4900  return is_app_of(a, Z3_OP_STORE)
4901 
def is_store(a)
Definition: z3py.py:4891
def is_app_of(a, k)
Definition: z3py.py:1364
def z3py.is_string (   a)
Return `True` if `a` is a Z3 string expression.
>>> print (is_string(StringVal("ab")))
True

Definition at line 10952 of file z3py.py.

10952 def is_string(a):
10953  """Return `True` if `a` is a Z3 string expression.
10954  >>> print (is_string(StringVal("ab")))
10955  True
10956  """
10957  return isinstance(a, SeqRef) and a.is_string()
10958 
10959 
def is_string(a)
Definition: z3py.py:10952
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 10960 of file z3py.py.

10961  """return 'True' if 'a' is a Z3 string constant expression.
10962  >>> print (is_string_value(StringVal("a")))
10963  True
10964  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10965  False
10966  """
10967  return isinstance(a, SeqRef) and a.is_string_value()
10968 
def is_string_value(a)
Definition: z3py.py:10960
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 2812 of file z3py.py.

2812 def is_sub(a):
2813  """Return `True` if `a` is an expression of the form b - c.
2814 
2815  >>> x, y = Ints('x y')
2816  >>> is_sub(x - y)
2817  True
2818  >>> is_sub(x + y)
2819  False
2820  """
2821  return is_app_of(a, Z3_OP_SUB)
2822 
2823 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_sub(a)
Definition: z3py.py:2812
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 2940 of file z3py.py.

2940 def is_to_int(a):
2941  """Return `True` if `a` is an expression of the form ToInt(b).
2942 
2943  >>> x = Real('x')
2944  >>> n = ToInt(x)
2945  >>> n
2946  ToInt(x)
2947  >>> is_to_int(n)
2948  True
2949  >>> is_to_int(x)
2950  False
2951  """
2952  return is_app_of(a, Z3_OP_TO_INT)
2953 
2954 
def is_app_of(a, k)
Definition: z3py.py:1364
def is_to_int(a)
Definition: z3py.py:2940
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 2925 of file z3py.py.

2925 def is_to_real(a):
2926  """Return `True` if `a` is an expression of the form ToReal(b).
2927 
2928  >>> x = Int('x')
2929  >>> n = ToReal(x)
2930  >>> n
2931  ToReal(x)
2932  >>> is_to_real(n)
2933  True
2934  >>> is_to_real(x)
2935  False
2936  """
2937  return is_app_of(a, Z3_OP_TO_REAL)
2938 
2939 
def is_to_real(a)
Definition: z3py.py:2925
def is_app_of(a, k)
Definition: z3py.py:1364
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 1585 of file z3py.py.

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

1585 def is_true(a):
1586  """Return `True` if `a` is the Z3 true expression.
1587 
1588  >>> p = Bool('p')
1589  >>> is_true(p)
1590  False
1591  >>> is_true(simplify(p == p))
1592  True
1593  >>> x = Real('x')
1594  >>> is_true(x == 0)
1595  False
1596  >>> # True is a Python Boolean expression
1597  >>> is_true(True)
1598  False
1599  """
1600  return is_app_of(a, Z3_OP_TRUE)
1601 
1602 
def is_true(a)
Definition: z3py.py:1585
def is_app_of(a, k)
Definition: z3py.py:1364
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 1306 of file z3py.py.

Referenced by get_var_index().

1306 def is_var(a):
1307  """Return `True` if `a` is variable.
1308 
1309  Z3 uses de-Bruijn indices for representing bound variables in
1310  quantifiers.
1311 
1312  >>> x = Int('x')
1313  >>> is_var(x)
1314  False
1315  >>> is_const(x)
1316  True
1317  >>> f = Function('f', IntSort(), IntSort())
1318  >>> # Z3 replaces x with bound variables when ForAll is executed.
1319  >>> q = ForAll(x, f(x) == x)
1320  >>> b = q.body()
1321  >>> b
1322  f(Var(0)) == Var(0)
1323  >>> b.arg(1)
1324  Var(0)
1325  >>> is_var(b.arg(1))
1326  True
1327  """
1328  return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1329 
1330 
def is_expr(a)
Definition: z3py.py:1238
def is_var(a)
Definition: z3py.py:1306
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 3386 of file z3py.py.

Referenced by is_is_int().

3386 def IsInt(a):
3387  """ Return the Z3 predicate IsInt(a).
3388 
3389  >>> x = Real('x')
3390  >>> IsInt(x + "1/2")
3391  IsInt(x + 1/2)
3392  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3393  [x = 1/2]
3394  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3395  no solution
3396  """
3397  if z3_debug():
3398  _z3_assert(a.is_real(), "Z3 real expression expected.")
3399  ctx = a.ctx
3400  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3401 
3402 
def IsInt(a)
Definition: z3py.py:3386
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
def z3_debug()
Definition: z3py.py:62
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 5001 of file z3py.py.

5001 def IsMember(e, s):
5002  """ Check if e is a member of set s
5003  >>> a = Const('a', SetSort(IntSort()))
5004  >>> IsMember(1, a)
5005  a[1]
5006  """
5007  ctx = _ctx_from_ast_arg_list([s, e])
5008  e = _py2expr(e, ctx)
5009  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5010 
5011 
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
def IsMember(e, s)
Definition: z3py.py:5001
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 5012 of file z3py.py.

5012 def IsSubset(a, b):
5013  """ Check if a is a subset of b
5014  >>> a = Const('a', SetSort(IntSort()))
5015  >>> b = Const('b', SetSort(IntSort()))
5016  >>> IsSubset(a, b)
5017  subset(a, b)
5018  """
5019  ctx = _ctx_from_ast_arg_list([a, b])
5020  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5021 
5022 
def IsSubset(a, b)
Definition: z3py.py:5012
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
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 4838 of file z3py.py.

Referenced by Default(), EmptySet(), FullSet(), is_const_array(), is_default(), and is_K().

4838 def K(dom, v):
4839  """Return a Z3 constant array expression.
4840 
4841  >>> a = K(IntSort(), 10)
4842  >>> a
4843  K(Int, 10)
4844  >>> a.sort()
4845  Array(Int, Int)
4846  >>> i = Int('i')
4847  >>> a[i]
4848  K(Int, 10)[i]
4849  >>> simplify(a[i])
4850  10
4851  """
4852  if z3_debug():
4853  _z3_assert(is_sort(dom), "Z3 sort expected")
4854  ctx = dom.ctx
4855  if not is_expr(v):
4856  v = _py2expr(v, ctx)
4857  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4858 
4859 
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
def K(dom, v)
Definition: z3py.py:4838
def is_expr(a)
Definition: z3py.py:1238
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 2257 of file z3py.py.

Referenced by QuantifierRef.is_lambda().

2257 def Lambda(vs, body):
2258  """Create a Z3 lambda expression.
2259 
2260  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2261  >>> mem0 = Array('mem0', IntSort(), IntSort())
2262  >>> lo, hi, e, i = Ints('lo hi e i')
2263  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2264  >>> mem1
2265  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2266  """
2267  ctx = body.ctx
2268  if is_app(vs):
2269  vs = [vs]
2270  num_vars = len(vs)
2271  _vs = (Ast * num_vars)()
2272  for i in range(num_vars):
2273  # TODO: Check if is constant
2274  _vs[i] = vs[i].as_ast()
2275  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2276 
Quantifiers.
Definition: z3py.py:1984
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def is_app(a)
Definition: z3py.py:1261
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.
def Lambda(vs, body)
Definition: z3py.py:2257
def z3py.LastIndexOf (   s,
  substr 
)
Retrieve the last index of substring within a string

Definition at line 11127 of file z3py.py.

11127 def LastIndexOf(s, substr):
11128  """Retrieve the last index of substring within a string"""
11129  ctx = None
11130  ctx = _get_ctx2(s, substr, ctx)
11131  s = _coerce_seq(s, ctx)
11132  substr = _coerce_seq(substr, ctx)
11133  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11134 
11135 
def LastIndexOf(s, substr)
Definition: z3py.py:11127
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast s, Z3_ast substr)
Return index of the last occurrence of substr in s. If s does not contain substr, then the value is -...
def z3py.Length (   s)
Obtain the length of a sequence 's'
>>> l = Length(StringVal("abc"))
>>> simplify(l)
3

Definition at line 11136 of file z3py.py.

11136 def Length(s):
11137  """Obtain the length of a sequence 's'
11138  >>> l = Length(StringVal("abc"))
11139  >>> simplify(l)
11140  3
11141  """
11142  s = _coerce_seq(s)
11143  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11144 
11145 
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
def Length(s)
Definition: z3py.py:11136
def z3py.LinearOrder (   a,
  index 
)

Definition at line 11358 of file z3py.py.

11358 def LinearOrder(a, index):
11359  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11360 
11361 
Function Declarations.
Definition: z3py.py:718
def LinearOrder(a, index)
Definition: z3py.py:11358
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...
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 11316 of file z3py.py.

11316 def Loop(re, lo, hi=0):
11317  """Create the regular expression accepting between a lower and upper bound repetitions
11318  >>> re = Loop(Re("a"), 1, 3)
11319  >>> print(simplify(InRe("aa", re)))
11320  True
11321  >>> print(simplify(InRe("aaaa", re)))
11322  False
11323  >>> print(simplify(InRe("", re)))
11324  False
11325  """
11326  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11327 
11328 
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...
def Loop
Definition: z3py.py:11316
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 4291 of file z3py.py.

Referenced by BitVecRef.__rlshift__(), BitVecRef.__rrshift__(), and BitVecRef.__rshift__().

4291 def LShR(a, b):
4292  """Create the Z3 expression logical right shift.
4293 
4294  Use the operator >> for the arithmetical right shift.
4295 
4296  >>> x, y = BitVecs('x y', 32)
4297  >>> LShR(x, y)
4298  LShR(x, y)
4299  >>> (x >> y).sexpr()
4300  '(bvashr x y)'
4301  >>> LShR(x, y).sexpr()
4302  '(bvlshr x y)'
4303  >>> BitVecVal(4, 3)
4304  4
4305  >>> BitVecVal(4, 3).as_signed_long()
4306  -4
4307  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4308  -2
4309  >>> simplify(BitVecVal(4, 3) >> 1)
4310  6
4311  >>> simplify(LShR(BitVecVal(4, 3), 1))
4312  2
4313  >>> simplify(BitVecVal(2, 3) >> 1)
4314  1
4315  >>> simplify(LShR(BitVecVal(2, 3), 1))
4316  1
4317  """
4318  _check_bv_args(a, b)
4319  a, b = _coerce_exprs(a, b)
4320  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4321 
4322 
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
def LShR(a, b)
Definition: z3py.py:4291
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 239 of file z3py.py.

Referenced by help_simplify(), simplify_param_descrs(), and Goal.translate().

239 def main_ctx():
240  """Return a reference to the global Z3 context.
241 
242  >>> x = Real('x')
243  >>> x.ctx == main_ctx()
244  True
245  >>> c = Context()
246  >>> c == main_ctx()
247  False
248  >>> x2 = Real('x', c)
249  >>> x2.ctx == c
250  True
251  >>> eq(x, x2)
252  False
253  """
254  global _main_ctx
255  if _main_ctx is None:
256  _main_ctx = Context()
257  return _main_ctx
258 
259 
def main_ctx()
Definition: z3py.py:239
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 4815 of file z3py.py.

Referenced by get_map_func(), and is_map().

4815 def Map(f, *args):
4816  """Return a Z3 map array expression.
4817 
4818  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4819  >>> a1 = Array('a1', IntSort(), IntSort())
4820  >>> a2 = Array('a2', IntSort(), IntSort())
4821  >>> b = Map(f, a1, a2)
4822  >>> b
4823  Map(f, a1, a2)
4824  >>> prove(b[0] == f(a1[0], a2[0]))
4825  proved
4826  """
4827  args = _get_args(args)
4828  if z3_debug():
4829  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4830  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4831  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4832  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4833  _args, sz = _to_ast_array(args)
4834  ctx = f.ctx
4835  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4836 
4837 
def is_array(a)
Definition: z3py.py:4603
def z3_debug()
Definition: z3py.py:62
def Map(f, args)
Definition: z3py.py:4815
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.
def is_func_decl(a)
Definition: z3py.py:846
def z3py.mk_not (   a)

Definition at line 1830 of file z3py.py.

1830 def mk_not(a):
1831  if is_not(a):
1832  return a.arg(0)
1833  else:
1834  return Not(a)
1835 
1836 
def Not
Definition: z3py.py:1811
def mk_not(a)
Definition: z3py.py:1830
def is_not(a)
Definition: z3py.py:1653
def z3py.Model (   ctx = None)

Definition at line 6681 of file z3py.py.

Referenced by Optimize.set_on_model().

6681 def Model(ctx=None):
6682  ctx = _get_ctx(ctx)
6683  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6684 
6685 
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
def Model
Definition: z3py.py:6681
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 1947 of file z3py.py.

1947 def MultiPattern(*args):
1948  """Create a Z3 multi-pattern using the given expressions `*args`
1949 
1950  >>> f = Function('f', IntSort(), IntSort())
1951  >>> g = Function('g', IntSort(), IntSort())
1952  >>> x = Int('x')
1953  >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1954  >>> q
1955  ForAll(x, f(x) != g(x))
1956  >>> q.num_patterns()
1957  1
1958  >>> is_pattern(q.pattern(0))
1959  True
1960  >>> q.pattern(0)
1961  MultiPattern(f(Var(0)), g(Var(0)))
1962  """
1963  if z3_debug():
1964  _z3_assert(len(args) > 0, "At least one argument expected")
1965  _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
1966  ctx = args[0].ctx
1967  args, sz = _to_ast_array(args)
1968  return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
1969 
1970 
Patterns.
Definition: z3py.py:1917
def z3_debug()
Definition: z3py.py:62
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.
def MultiPattern(args)
Definition: z3py.py:1947
def is_expr(a)
Definition: z3py.py:1238
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 1811 of file z3py.py.

Referenced by Solver.consequences(), Goal.convert_model(), fpNEQ(), mk_not(), prove(), and Xor().

1811 def Not(a, ctx=None):
1812  """Create a Z3 not expression or probe.
1813 
1814  >>> p = Bool('p')
1815  >>> Not(Not(p))
1816  Not(Not(p))
1817  >>> simplify(Not(Not(p)))
1818  p
1819  """
1820  ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1821  if is_probe(a):
1822  # Not is also used to build probes
1823  return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1824  else:
1825  s = BoolSort(ctx)
1826  a = s.cast(a)
1827  return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1828 
1829 
def Not
Definition: z3py.py:1811
def BoolSort
Definition: z3py.py:1687
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
def is_probe(p)
Definition: z3py.py:8685
def z3py.on_clause_eh (   ctx,
  p,
  clause 
)

Definition at line 11398 of file z3py.py.

Referenced by on_clause.on_clause().

11398 def on_clause_eh(ctx, p, clause):
11399  onc = _my_hacky_class
11400  p = _to_expr_ref(to_Ast(p), onc.ctx)
11401  clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11402  onc.on_clause(p, clause)
11403 
def to_AstVectorObj(ptr)
Definition: z3py.py:11387
def to_Ast(ptr)
Definition: z3py.py:11377
def on_clause_eh(ctx, p, clause)
Definition: z3py.py:11398
def z3py.open_log (   fname)
Log interaction to a file. This function must be invoked immediately after init(). 

Definition at line 114 of file z3py.py.

114 def open_log(fname):
115  """Log interaction to a file. This function must be invoked immediately after init(). """
116  Z3_open_log(fname)
117 
118 
def open_log(fname)
Definition: z3py.py:114
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.
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 11285 of file z3py.py.

11285 def Option(re):
11286  """Create the regular expression that optionally accepts the argument.
11287  >>> re = Option(Re("a"))
11288  >>> print(simplify(InRe("a", re)))
11289  True
11290  >>> print(simplify(InRe("", re)))
11291  True
11292  >>> print(simplify(InRe("aa", re)))
11293  False
11294  """
11295  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11296 
11297 
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
def Option(re)
Definition: z3py.py:11285
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 1878 of file z3py.py.

Referenced by ApplyResult.as_expr(), Bools(), and Goal.convert_model().

1878 def Or(*args):
1879  """Create a Z3 or-expression or or-probe.
1880 
1881  >>> p, q, r = Bools('p q r')
1882  >>> Or(p, q, r)
1883  Or(p, q, r)
1884  >>> P = BoolVector('p', 5)
1885  >>> Or(P)
1886  Or(p__0, p__1, p__2, p__3, p__4)
1887  """
1888  last_arg = None
1889  if len(args) > 0:
1890  last_arg = args[len(args) - 1]
1891  if isinstance(last_arg, Context):
1892  ctx = args[len(args) - 1]
1893  args = args[:len(args) - 1]
1894  elif len(args) == 1 and isinstance(args[0], AstVector):
1895  ctx = args[0].ctx
1896  args = [a for a in args[0]]
1897  else:
1898  ctx = None
1899  args = _get_args(args)
1900  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1901  if z3_debug():
1902  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1903  if _has_probe(args):
1904  return _probe_or(args, ctx)
1905  else:
1906  args = _coerce_expr_list(args, ctx)
1907  _args, sz = _to_ast_array(args)
1908  return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1909 
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].
def Or(args)
Definition: z3py.py:1878
def z3_debug()
Definition: z3py.py:62
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 8378 of file z3py.py.

8378 def OrElse(*ts, **ks):
8379  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8380 
8381  >>> x = Int('x')
8382  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8383  >>> # Tactic split-clause fails if there is no clause in the given goal.
8384  >>> t(x == 0)
8385  [[x == 0]]
8386  >>> t(Or(x == 0, x == 1))
8387  [[x == 0], [x == 1]]
8388  """
8389  if z3_debug():
8390  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8391  ctx = ks.get("ctx", None)
8392  num = len(ts)
8393  r = ts[0]
8394  for i in range(num - 1):
8395  r = _or_else(r, ts[i + 1], ctx)
8396  return r
8397 
8398 
def OrElse(ts, ks)
Definition: z3py.py:8378
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def z3_debug()
Definition: z3py.py:62
def z3py.ParAndThen (   t1,
  t2,
  ctx = None 
)
Alias for ParThen(t1, t2, ctx).

Definition at line 8434 of file z3py.py.

8434 def ParAndThen(t1, t2, ctx=None):
8435  """Alias for ParThen(t1, t2, ctx)."""
8436  return ParThen(t1, t2, ctx)
8437 
8438 
def ParThen
Definition: z3py.py:8418
def ParAndThen
Definition: z3py.py:8434
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 8399 of file z3py.py.

8399 def ParOr(*ts, **ks):
8400  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8401 
8402  >>> x = Int('x')
8403  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8404  >>> t(x + 1 == 2)
8405  [[x == 1]]
8406  """
8407  if z3_debug():
8408  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8409  ctx = _get_ctx(ks.get("ctx", None))
8410  ts = [_to_tactic(t, ctx) for t in ts]
8411  sz = len(ts)
8412  _args = (TacticObj * sz)()
8413  for i in range(sz):
8414  _args[i] = ts[i].tactic
8415  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8416 
8417 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def z3_debug()
Definition: z3py.py:62
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.
def ParOr(ts, ks)
Definition: z3py.py:8399
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 9314 of file z3py.py.

9314 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9315  """Parse a file in SMT 2.0 format using the given sorts and decls.
9316 
9317  This function is similar to parse_smt2_string().
9318  """
9319  ctx = _get_ctx(ctx)
9320  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9321  dsz, dnames, ddecls = _dict2darray(decls, ctx)
9322  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9323 
9324 
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.
def parse_smt2_file
Definition: z3py.py:9314
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 9293 of file z3py.py.

Referenced by parse_smt2_file().

9293 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9294  """Parse a string in SMT 2.0 format using the given sorts and decls.
9295 
9296  The arguments sorts and decls are Python dictionaries used to initialize
9297  the symbol table used for the SMT 2.0 parser.
9298 
9299  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9300  [x > 0, x < 10]
9301  >>> x, y = Ints('x y')
9302  >>> f = Function('f', IntSort(), IntSort())
9303  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9304  [x + f(y) > 0]
9305  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9306  [a > 0]
9307  """
9308  ctx = _get_ctx(ctx)
9309  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9310  dsz, dnames, ddecls = _dict2darray(decls, ctx)
9311  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9312 
9313 
def parse_smt2_string
Definition: z3py.py:9293
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 8418 of file z3py.py.

Referenced by ParAndThen().

8418 def ParThen(t1, t2, ctx=None):
8419  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8420  The subgoals are processed in parallel.
8421 
8422  >>> x, y = Ints('x y')
8423  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8424  >>> t(And(Or(x == 1, x == 2), y == x + 1))
8425  [[x == 1, y == 2], [x == 2, y == 3]]
8426  """
8427  t1 = _to_tactic(t1, ctx)
8428  t2 = _to_tactic(t2, ctx)
8429  if z3_debug():
8430  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8431  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8432 
8433 
def ParThen
Definition: z3py.py:8418
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...
def z3_debug()
Definition: z3py.py:62
def z3py.PartialOrder (   a,
  index 
)

Definition at line 11354 of file z3py.py.

11354 def PartialOrder(a, index):
11355  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11356 
11357 
Function Declarations.
Definition: z3py.py:718
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.
def PartialOrder(a, index)
Definition: z3py.py:11354
def z3py.PbEq (   args,
  k,
  ctx = None 
)
Create a Pseudo-Boolean equality k constraint.

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

Definition at line 9070 of file z3py.py.

9070 def PbEq(args, k, ctx=None):
9071  """Create a Pseudo-Boolean equality k constraint.
9072 
9073  >>> a, b, c = Bools('a b c')
9074  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9075  """
9076  _z3_check_cint_overflow(k, "k")
9077  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9078  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9079 
9080 
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.
def PbEq
Definition: z3py.py:9070
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 9059 of file z3py.py.

9059 def PbGe(args, k):
9060  """Create a Pseudo-Boolean inequality k constraint.
9061 
9062  >>> a, b, c = Bools('a b c')
9063  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9064  """
9065  _z3_check_cint_overflow(k, "k")
9066  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9067  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9068 
9069 
def PbGe(args, k)
Definition: z3py.py:9059
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.
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 9048 of file z3py.py.

9048 def PbLe(args, k):
9049  """Create a Pseudo-Boolean inequality k constraint.
9050 
9051  >>> a, b, c = Bools('a b c')
9052  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9053  """
9054  _z3_check_cint_overflow(k, "k")
9055  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9056  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9057 
9058 
def PbLe(args, k)
Definition: z3py.py:9048
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.
def z3py.PiecewiseLinearOrder (   a,
  index 
)

Definition at line 11366 of file z3py.py.

11366 def PiecewiseLinearOrder(a, index):
11367  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11368 
11369 
Function Declarations.
Definition: z3py.py:718
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.
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:11366
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 11272 of file z3py.py.

11272 def Plus(re):
11273  """Create the regular expression accepting one or more repetitions of argument.
11274  >>> re = Plus(Re("a"))
11275  >>> print(simplify(InRe("aa", re)))
11276  True
11277  >>> print(simplify(InRe("ab", re)))
11278  False
11279  >>> print(simplify(InRe("", re)))
11280  False
11281  """
11282  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11283 
11284 
def Plus(re)
Definition: z3py.py:11272
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
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 11043 of file z3py.py.

11043 def PrefixOf(a, b):
11044  """Check if 'a' is a prefix of 'b'
11045  >>> s1 = PrefixOf("ab", "abc")
11046  >>> simplify(s1)
11047  True
11048  >>> s2 = PrefixOf("bc", "abc")
11049  >>> simplify(s2)
11050  False
11051  """
11052  ctx = _get_ctx2(a, b)
11053  a = _coerce_seq(a, ctx)
11054  b = _coerce_seq(b, ctx)
11055  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11056 
11057 
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.
def PrefixOf(a, b)
Definition: z3py.py:11043
def z3py.probe_description (   name,
  ctx = None 
)
Return a short description for the probe named `name`.

>>> d = probe_description('memory')

Definition at line 8714 of file z3py.py.

Referenced by describe_probes().

8714 def probe_description(name, ctx=None):
8715  """Return a short description for the probe named `name`.
8716 
8717  >>> d = probe_description('memory')
8718  """
8719  ctx = _get_ctx(ctx)
8720  return Z3_probe_get_descr(ctx.ref(), name)
8721 
8722 
def probe_description
Definition: z3py.py:8714
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.
def z3py.probes (   ctx = None)
Return a list of all available probes in Z3.

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

Definition at line 8703 of file z3py.py.

Referenced by describe_probes().

8703 def probes(ctx=None):
8704  """Return a list of all available probes in Z3.
8705 
8706  >>> l = probes()
8707  >>> l.count('memory') == 1
8708  True
8709  """
8710  ctx = _get_ctx(ctx)
8711  return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8712 
8713 
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def probes
Definition: z3py.py:8703
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
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 8955 of file z3py.py.

Referenced by BitVecs().

8955 def Product(*args):
8956  """Create the product of the Z3 expressions.
8957 
8958  >>> a, b, c = Ints('a b c')
8959  >>> Product(a, b, c)
8960  a*b*c
8961  >>> Product([a, b, c])
8962  a*b*c
8963  >>> A = IntVector('a', 5)
8964  >>> Product(A)
8965  a__0*a__1*a__2*a__3*a__4
8966  """
8967  args = _get_args(args)
8968  if len(args) == 0:
8969  return 1
8970  ctx = _ctx_from_ast_arg_list(args)
8971  if ctx is None:
8972  return _reduce(lambda a, b: a * b, args, 1)
8973  args = _coerce_expr_list(args, ctx)
8974  if is_bv(args[0]):
8975  return _reduce(lambda a, b: a * b, args, 1)
8976  else:
8977  _args, sz = _to_ast_array(args)
8978  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8979 
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].
def Product(args)
Definition: z3py.py:8955
def is_bv(a)
Definition: z3py.py:3936
def z3py.PropagateFunction (   name,
  sig 
)
Create a function that gets tracked by user propagator.
   Every term headed by this function symbol is tracked.
   If a term is fixed and the fixed callback is registered a
   callback is invoked that the term headed by this function is fixed.

Definition at line 11549 of file z3py.py.

11549 def PropagateFunction(name, *sig):
11550  """Create a function that gets tracked by user propagator.
11551  Every term headed by this function symbol is tracked.
11552  If a term is fixed and the fixed callback is registered a
11553  callback is invoked that the term headed by this function is fixed.
11554  """
11555  sig = _get_args(sig)
11556  if z3_debug():
11557  _z3_assert(len(sig) > 0, "At least two arguments expected")
11558  arity = len(sig) - 1
11559  rng = sig[arity]
11560  if z3_debug():
11561  _z3_assert(is_sort(rng), "Z3 sort expected")
11562  dom = (Sort * arity)()
11563  for i in range(arity):
11564  if z3_debug():
11565  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11566  dom[i] = sig[i].ast
11567  ctx = rng.ctx
11568  return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11569 
11570 
11571 
Function Declarations.
Definition: z3py.py:718
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def PropagateFunction(name, sig)
Definition: z3py.py:11549
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
def to_symbol
Definition: z3py.py:124
Z3_func_decl Z3_API Z3_solver_propagate_declare(Z3_context c, Z3_symbol name, unsigned n, Z3_sort *domain, Z3_sort range)
def z3py.prove (   claim,
  show = False,
  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 9142 of file z3py.py.

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

9142 def prove(claim, show=False, **keywords):
9143  """Try to prove the given claim.
9144 
9145  This is a simple function for creating demonstrations. It tries to prove
9146  `claim` by showing the negation is unsatisfiable.
9147 
9148  >>> p, q = Bools('p q')
9149  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9150  proved
9151  """
9152  if z3_debug():
9153  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9154  s = Solver()
9155  s.set(**keywords)
9156  s.add(Not(claim))
9157  if show:
9158  print(s)
9159  r = s.check()
9160  if r == unsat:
9161  print("proved")
9162  elif r == unknown:
9163  print("failed to prove")
9164  print(s.model())
9165  else:
9166  print("counterexample")
9167  print(s.model())
9168 
9169 
def Not
Definition: z3py.py:1811
def prove(claim, show=False, keywords)
Definition: z3py.py:9142
def z3_debug()
Definition: z3py.py:62
def is_bool(a)
Definition: z3py.py:1567
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 3227 of file z3py.py.

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

3227 def Q(a, b, ctx=None):
3228  """Return a Z3 rational a/b.
3229 
3230  If `ctx=None`, then the global context is used.
3231 
3232  >>> Q(3,5)
3233  3/5
3234  >>> Q(3,5).sort()
3235  Real
3236  """
3237  return simplify(RatVal(a, b, ctx=ctx))
3238 
3239 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8819
def Q
Definition: z3py.py:3227
def RatVal
Definition: z3py.py:3211
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 11329 of file z3py.py.

11329 def Range(lo, hi, ctx=None):
11330  """Create the range regular expression over two sequences of length 1
11331  >>> range = Range("a","z")
11332  >>> print(simplify(InRe("b", range)))
11333  True
11334  >>> print(simplify(InRe("bb", range)))
11335  False
11336  """
11337  lo = _coerce_seq(lo, ctx)
11338  hi = _coerce_seq(hi, ctx)
11339  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11340 
def Range
Definition: z3py.py:11329
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.
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 3211 of file z3py.py.

Referenced by Q().

3211 def RatVal(a, b, ctx=None):
3212  """Return a Z3 rational a/b.
3213 
3214  If `ctx=None`, then the global context is used.
3215 
3216  >>> RatVal(3,5)
3217  3/5
3218  >>> RatVal(3,5).sort()
3219  Real
3220  """
3221  if z3_debug():
3222  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3223  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3224  return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3225 
3226 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8819
def z3_debug()
Definition: z3py.py:62
def RealVal
Definition: z3py.py:3192
def RatVal
Definition: z3py.py:3211
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 11181 of file z3py.py.

Referenced by InRe(), Intersect(), Loop(), Option(), Plus(), Star(), and Union().

11181 def Re(s, ctx=None):
11182  """The regular expression that accepts sequence 's'
11183  >>> s1 = Re("ab")
11184  >>> s2 = Re(StringVal("ab"))
11185  >>> s3 = Re(Unit(BoolVal(True)))
11186  """
11187  s = _coerce_seq(s, ctx)
11188  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11189 
11190 
11191 # Regular expressions
11192 
def Re
Definition: z3py.py:11181
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
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 3293 of file z3py.py.

Referenced by ArithRef.__div__(), ArithRef.__ge__(), ArithRef.__gt__(), ArithRef.__le__(), ArithRef.__lt__(), ArithRef.__mul__(), ArithRef.__pow__(), ArithRef.__rdiv__(), ArithRef.__rmul__(), ArithRef.__rpow__(), Cbrt(), is_arith(), ArithSortRef.is_int(), ArithRef.is_int(), is_int(), is_is_int(), is_rational_value(), ArithSortRef.is_real(), ArithRef.is_real(), is_real(), is_to_int(), IsInt(), ArithRef.sort(), Sqrt(), ToInt(), and QuantifierRef.var_sort().

3293 def Real(name, ctx=None):
3294  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3295 
3296  >>> x = Real('x')
3297  >>> is_real(x)
3298  True
3299  >>> is_real(x + 1)
3300  True
3301  """
3302  ctx = _get_ctx(ctx)
3303  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3304 
3305 
def RealSort
Definition: z3py.py:3151
def Real
Definition: z3py.py:3293
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def to_symbol
Definition: z3py.py:124
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 3306 of file z3py.py.

Referenced by is_div().

3306 def Reals(names, ctx=None):
3307  """Return a tuple of real constants.
3308 
3309  >>> x, y, z = Reals('x y z')
3310  >>> Sum(x, y, z)
3311  x + y + z
3312  >>> Sum(x, y, z).sort()
3313  Real
3314  """
3315  ctx = _get_ctx(ctx)
3316  if isinstance(names, str):
3317  names = names.split(" ")
3318  return [Real(name, ctx) for name in names]
3319 
3320 
def Real
Definition: z3py.py:3293
def Reals
Definition: z3py.py:3306
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 3151 of file z3py.py.

Referenced by ArithSortRef.cast(), FreshReal(), is_arith_sort(), Real(), RealVar(), and QuantifierRef.var_sort().

3151 def RealSort(ctx=None):
3152  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3153 
3154  >>> RealSort()
3155  Real
3156  >>> x = Const('x', RealSort())
3157  >>> is_real(x)
3158  True
3159  >>> is_int(x)
3160  False
3161  >>> x.sort() == RealSort()
3162  True
3163  """
3164  ctx = _get_ctx(ctx)
3165  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3166 
3167 
def RealSort
Definition: z3py.py:3151
Arithmetic.
Definition: z3py.py:2284
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
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 3192 of file z3py.py.

Referenced by RatNumRef.as_decimal(), RatNumRef.as_fraction(), Cbrt(), RatNumRef.denominator_as_long(), deserialize(), fpRealToFP(), fpToFP(), is_algebraic_value(), is_int_value(), is_rational_value(), is_real(), RatNumRef.numerator(), RatNumRef.numerator_as_long(), and RatVal().

3192 def RealVal(val, ctx=None):
3193  """Return a Z3 real value.
3194 
3195  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3196  If `ctx=None`, then the global context is used.
3197 
3198  >>> RealVal(1)
3199  1
3200  >>> RealVal(1).sort()
3201  Real
3202  >>> RealVal("3/5")
3203  3/5
3204  >>> RealVal("1.5")
3205  3/2
3206  """
3207  ctx = _get_ctx(ctx)
3208  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3209 
3210 
def RealSort
Definition: z3py.py:3151
def RealVal
Definition: z3py.py:3192
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
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 1481 of file z3py.py.

Referenced by RealVarVector().

1481 def RealVar(idx, ctx=None):
1482  """
1483  Create a real free variable. Free variables are used to create quantified formulas.
1484  They are also used to create polynomials.
1485 
1486  >>> RealVar(0)
1487  Var(0)
1488  """
1489  return Var(idx, RealSort(ctx))
1490 
1491 
def RealSort
Definition: z3py.py:3151
def Var(idx, s)
Definition: z3py.py:1466
def RealVar
Definition: z3py.py:1481
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 1492 of file z3py.py.

1492 def RealVarVector(n, ctx=None):
1493  """
1494  Create a list of Real free variables.
1495  The variables have ids: 0, 1, ..., n-1
1496 
1497  >>> x0, x1, x2, x3 = RealVarVector(4)
1498  >>> x2
1499  Var(2)
1500  """
1501  return [RealVar(i, ctx) for i in range(n)]
1502 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def RealVarVector
Definition: z3py.py:1492
def RealVar
Definition: z3py.py:1481
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 3321 of file z3py.py.

3321 def RealVector(prefix, sz, ctx=None):
3322  """Return a list of real constants of size `sz`.
3323 
3324  >>> X = RealVector('x', 3)
3325  >>> X
3326  [x__0, x__1, x__2]
3327  >>> Sum(X)
3328  x__0 + x__1 + x__2
3329  >>> Sum(X).sort()
3330  Real
3331  """
3332  ctx = _get_ctx(ctx)
3333  return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3334 
3335 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Real
Definition: z3py.py:3293
def RealVector
Definition: z3py.py:3321
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 923 of file z3py.py.

923 def RecAddDefinition(f, args, body):
924  """Set the body of a recursive function.
925  Recursive definitions can be simplified if they are applied to ground
926  arguments.
927  >>> ctx = Context()
928  >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
929  >>> n = Int('n', ctx)
930  >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
931  >>> simplify(fac(5))
932  120
933  >>> s = Solver(ctx=ctx)
934  >>> s.add(fac(n) < 3)
935  >>> s.check()
936  sat
937  >>> s.model().eval(fac(5))
938  120
939  """
940  if is_app(args):
941  args = [args]
942  ctx = body.ctx
943  args = _get_args(args)
944  n = len(args)
945  _args = (Ast * n)()
946  for i in range(n):
947  _args[i] = args[i].ast
948  Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
949 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def is_app(a)
Definition: z3py.py:1261
def RecAddDefinition(f, args, body)
Definition: z3py.py:923
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.
def z3py.RecFunction (   name,
  sig 
)
Create a new Z3 recursive with the given sorts.

Definition at line 905 of file z3py.py.

905 def RecFunction(name, *sig):
906  """Create a new Z3 recursive with the given sorts."""
907  sig = _get_args(sig)
908  if z3_debug():
909  _z3_assert(len(sig) > 0, "At least two arguments expected")
910  arity = len(sig) - 1
911  rng = sig[arity]
912  if z3_debug():
913  _z3_assert(is_sort(rng), "Z3 sort expected")
914  dom = (Sort * arity)()
915  for i in range(arity):
916  if z3_debug():
917  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
918  dom[i] = sig[i].ast
919  ctx = rng.ctx
920  return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
921 
922 
Function Declarations.
Definition: z3py.py:718
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def RecFunction(name, sig)
Definition: z3py.py:905
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
def to_symbol
Definition: z3py.py:124
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.
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 8467 of file z3py.py.

8467 def Repeat(t, max=4294967295, ctx=None):
8468  """Return a tactic that keeps applying `t` until the goal is not modified anymore
8469  or the maximum number of iterations `max` is reached.
8470 
8471  >>> x, y = Ints('x y')
8472  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8473  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8474  >>> r = t(c)
8475  >>> for subgoal in r: print(subgoal)
8476  [x == 0, y == 0, x > y]
8477  [x == 0, y == 1, x > y]
8478  [x == 1, y == 0, x > y]
8479  [x == 1, y == 1, x > y]
8480  >>> t = Then(t, Tactic('propagate-values'))
8481  >>> t(c)
8482  [[x == 1, y == 0]]
8483  """
8484  t = _to_tactic(t, ctx)
8485  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8486 
8487 
def Repeat
Definition: z3py.py:8467
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...
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 4413 of file z3py.py.

4413 def RepeatBitVec(n, a):
4414  """Return an expression representing `n` copies of `a`.
4415 
4416  >>> x = BitVec('x', 8)
4417  >>> n = RepeatBitVec(4, x)
4418  >>> n
4419  RepeatBitVec(4, x)
4420  >>> n.size()
4421  32
4422  >>> v0 = BitVecVal(10, 4)
4423  >>> print("%.x" % v0.as_long())
4424  a
4425  >>> v = simplify(RepeatBitVec(4, v0))
4426  >>> v.size()
4427  16
4428  >>> print("%.x" % v.as_long())
4429  aaaa
4430  """
4431  if z3_debug():
4432  _z3_assert(_is_int(n), "First argument must be an integer")
4433  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4434  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4435 
4436 
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3936
def RepeatBitVec(n, a)
Definition: z3py.py:4413
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 11092 of file z3py.py.

11092 def Replace(s, src, dst):
11093  """Replace the first occurrence of 'src' by 'dst' in 's'
11094  >>> r = Replace("aaa", "a", "b")
11095  >>> simplify(r)
11096  "baa"
11097  """
11098  ctx = _get_ctx2(dst, s)
11099  if ctx is None and is_expr(src):
11100  ctx = src.ctx
11101  src = _coerce_seq(src, ctx)
11102  dst = _coerce_seq(dst, ctx)
11103  s = _coerce_seq(s, ctx)
11104  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11105 
11106 
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.
def Replace(s, src, dst)
Definition: z3py.py:11092
def is_expr(a)
Definition: z3py.py:1238
def z3py.reset_params ( )
Reset all global (or module) parameters.

Definition at line 295 of file z3py.py.

296  """Reset all global (or module) parameters.
297  """
299 
300 
def reset_params()
Definition: z3py.py:295
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...
def z3py.ReSort (   s)

Definition at line 11200 of file z3py.py.

Referenced by Empty(), and Full().

11200 def ReSort(s):
11201  if is_ast(s):
11202  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11203  if s is None or isinstance(s, Context):
11204  ctx = _get_ctx(s)
11205  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11206  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11207 
11208 
def ReSort(s)
Definition: z3py.py:11200
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.
def is_ast(a)
Definition: z3py.py:451
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
def z3py.RNA (   ctx = None)

Definition at line 9729 of file z3py.py.

Referenced by get_default_rounding_mode().

9729 def RNA(ctx=None):
9730  ctx = _get_ctx(ctx)
9731  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9732 
9733 
def RNA
Definition: z3py.py:9729
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...
def z3py.RNE (   ctx = None)

Definition at line 9719 of file z3py.py.

Referenced by fpAbs(), fpAdd(), fpDiv(), fpFPToFP(), fpMax(), fpMin(), fpMul(), fpNeg(), fpRealToFP(), FPs(), fpSignedToFP(), fpSub(), fpToFP(), fpUnsignedToFP(), get_default_rounding_mode(), is_fprm(), and is_fprm_sort().

9719 def RNE(ctx=None):
9720  ctx = _get_ctx(ctx)
9721  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9722 
9723 
def RNE
Definition: z3py.py:9719
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...
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 4323 of file z3py.py.

4323 def RotateLeft(a, b):
4324  """Return an expression representing `a` rotated to the left `b` times.
4325 
4326  >>> a, b = BitVecs('a b', 16)
4327  >>> RotateLeft(a, b)
4328  RotateLeft(a, b)
4329  >>> simplify(RotateLeft(a, 0))
4330  a
4331  >>> simplify(RotateLeft(a, 16))
4332  a
4333  """
4334  _check_bv_args(a, b)
4335  a, b = _coerce_exprs(a, b)
4336  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4337 
4338 
def RotateLeft(a, b)
Definition: z3py.py:4323
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.
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 4339 of file z3py.py.

4339 def RotateRight(a, b):
4340  """Return an expression representing `a` rotated to the right `b` times.
4341 
4342  >>> a, b = BitVecs('a b', 16)
4343  >>> RotateRight(a, b)
4344  RotateRight(a, b)
4345  >>> simplify(RotateRight(a, 0))
4346  a
4347  >>> simplify(RotateRight(a, 16))
4348  a
4349  """
4350  _check_bv_args(a, b)
4351  a, b = _coerce_exprs(a, b)
4352  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4353 
4354 
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.
def RotateRight(a, b)
Definition: z3py.py:4339
def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 9724 of file z3py.py.

9725  ctx = _get_ctx(ctx)
9726  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9727 
9728 
def RoundNearestTiesToAway
Definition: z3py.py:9724
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...
def z3py.RoundNearestTiesToEven (   ctx = None)

Definition at line 9714 of file z3py.py.

9715  ctx = _get_ctx(ctx)
9716  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9717 
9718 
def RoundNearestTiesToEven
Definition: z3py.py:9714
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...
def z3py.RoundTowardNegative (   ctx = None)

Definition at line 9744 of file z3py.py.

9744 def RoundTowardNegative(ctx=None):
9745  ctx = _get_ctx(ctx)
9746  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9747 
9748 
def RoundTowardNegative
Definition: z3py.py:9744
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...
def z3py.RoundTowardPositive (   ctx = None)

Definition at line 9734 of file z3py.py.

9734 def RoundTowardPositive(ctx=None):
9735  ctx = _get_ctx(ctx)
9736  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9737 
9738 
def RoundTowardPositive
Definition: z3py.py:9734
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...
def z3py.RoundTowardZero (   ctx = None)

Definition at line 9754 of file z3py.py.

9754 def RoundTowardZero(ctx=None):
9755  ctx = _get_ctx(ctx)
9756  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9757 
9758 
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.
def RoundTowardZero
Definition: z3py.py:9754
def z3py.RTN (   ctx = None)

Definition at line 9749 of file z3py.py.

Referenced by get_default_rounding_mode().

9749 def RTN(ctx=None):
9750  ctx = _get_ctx(ctx)
9751  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9752 
9753 
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...
def RTN
Definition: z3py.py:9749
def z3py.RTP (   ctx = None)

Definition at line 9739 of file z3py.py.

Referenced by get_default_rounding_mode().

9739 def RTP(ctx=None):
9740  ctx = _get_ctx(ctx)
9741  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9742 
9743 
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...
def RTP
Definition: z3py.py:9739
def z3py.RTZ (   ctx = None)

Definition at line 9759 of file z3py.py.

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

9759 def RTZ(ctx=None):
9760  ctx = _get_ctx(ctx)
9761  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9762 
9763 
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.
def RTZ
Definition: z3py.py:9759
def z3py.Select (   a,
  args 
)
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 4799 of file z3py.py.

4799 def Select(a, *args):
4800  """Return a Z3 select array expression.
4801 
4802  >>> a = Array('a', IntSort(), IntSort())
4803  >>> i = Int('i')
4804  >>> Select(a, i)
4805  a[i]
4806  >>> eq(Select(a, i), a[i])
4807  True
4808  """
4809  args = _get_args(args)
4810  if z3_debug():
4811  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4812  return a[args]
4813 
4814 
def is_array_sort(a)
Definition: z3py.py:4599
def Select(a, args)
Definition: z3py.py:4799
def z3_debug()
Definition: z3py.py:62
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 10813 of file z3py.py.

Referenced by Empty(), Full(), and SeqSortRef.is_string().

10813 def SeqSort(s):
10814  """Create a sequence sort over elements provided in the argument
10815  >>> s = SeqSort(IntSort())
10816  >>> s == Unit(IntVal(1)).sort()
10817  True
10818  """
10819  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10820 
10821 
def SeqSort(s)
Definition: z3py.py:10813
Strings, Sequences and Regular expressions.
Definition: z3py.py:10773
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.
def z3py.set_default_fp_sort (   ebits,
  sbits,
  ctx = None 
)

Definition at line 9375 of file z3py.py.

9375 def set_default_fp_sort(ebits, sbits, ctx=None):
9376  global _dflt_fpsort_ebits
9377  global _dflt_fpsort_sbits
9378  _dflt_fpsort_ebits = ebits
9379  _dflt_fpsort_sbits = sbits
9380 
9381 
def set_default_fp_sort
Definition: z3py.py:9375
def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 9362 of file z3py.py.

9362 def set_default_rounding_mode(rm, ctx=None):
9363  global _dflt_rounding_mode
9364  if is_fprm_value(rm):
9365  _dflt_rounding_mode = rm.decl().kind()
9366  else:
9367  _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9368  _dflt_rounding_mode = rm
9369 
9370 
def is_fprm_value(a)
Definition: z3py.py:9777
def set_default_rounding_mode
Definition: z3py.py:9362
def z3py.set_option (   args,
  kws 
)
Alias for 'set_param' for backward compatibility.

Definition at line 301 of file z3py.py.

301 def set_option(*args, **kws):
302  """Alias for 'set_param' for backward compatibility.
303  """
304  return set_param(*args, **kws)
305 
306 
def set_option(args, kws)
Definition: z3py.py:301
def set_param(args, kws)
Definition: z3py.py:271
def z3py.set_param (   args,
  kws 
)
Set Z3 global (or module) parameters.

>>> set_param(precision=10)

Definition at line 271 of file z3py.py.

Referenced by set_option().

271 def set_param(*args, **kws):
272  """Set Z3 global (or module) parameters.
273 
274  >>> set_param(precision=10)
275  """
276  if z3_debug():
277  _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
278  new_kws = {}
279  for k in kws:
280  v = kws[k]
281  if not set_pp_option(k, v):
282  new_kws[k] = v
283  for key in new_kws:
284  value = new_kws[key]
285  Z3_global_param_set(str(key).upper(), _to_param_value(value))
286  prev = None
287  for a in args:
288  if prev is None:
289  prev = a
290  else:
291  Z3_global_param_set(str(prev), _to_param_value(a))
292  prev = None
293 
294 
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.
def set_param(args, kws)
Definition: z3py.py:271
def z3_debug()
Definition: z3py.py:62
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 4958 of file z3py.py.

4958 def SetAdd(s, e):
4959  """ Add element e to set s
4960  >>> a = Const('a', SetSort(IntSort()))
4961  >>> SetAdd(a, 1)
4962  Store(a, 1, True)
4963  """
4964  ctx = _ctx_from_ast_arg_list([s, e])
4965  e = _py2expr(e, ctx)
4966  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4967 
4968 
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
def SetAdd(s, e)
Definition: z3py.py:4958
def z3py.SetComplement (   s)
The complement of set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetComplement(a)
complement(a)

Definition at line 4980 of file z3py.py.

4981  """ The complement of set s
4982  >>> a = Const('a', SetSort(IntSort()))
4983  >>> SetComplement(a)
4984  complement(a)
4985  """
4986  ctx = s.ctx
4987  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4988 
4989 
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
def SetComplement(s)
Definition: z3py.py:4980
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 4969 of file z3py.py.

4969 def SetDel(s, e):
4970  """ Remove element e to set s
4971  >>> a = Const('a', SetSort(IntSort()))
4972  >>> SetDel(a, 1)
4973  Store(a, 1, False)
4974  """
4975  ctx = _ctx_from_ast_arg_list([s, e])
4976  e = _py2expr(e, ctx)
4977  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4978 
4979 
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
def SetDel(s, e)
Definition: z3py.py:4969
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 4990 of file z3py.py.

4990 def SetDifference(a, b):
4991  """ The set difference of a and b
4992  >>> a = Const('a', SetSort(IntSort()))
4993  >>> b = Const('b', SetSort(IntSort()))
4994  >>> SetDifference(a, b)
4995  setminus(a, b)
4996  """
4997  ctx = _ctx_from_ast_arg_list([a, b])
4998  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4999 
5000 
def SetDifference(a, b)
Definition: z3py.py:4990
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
def z3py.SetHasSize (   a,
  k 
)

Definition at line 4872 of file z3py.py.

4872 def SetHasSize(a, k):
4873  ctx = a.ctx
4874  k = _py2expr(k, ctx)
4875  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4876 
4877 
def SetHasSize(a, k)
Definition: z3py.py:4872
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.
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 4945 of file z3py.py.

4945 def SetIntersect(*args):
4946  """ Take the union of sets
4947  >>> a = Const('a', SetSort(IntSort()))
4948  >>> b = Const('b', SetSort(IntSort()))
4949  >>> SetIntersect(a, b)
4950  intersection(a, b)
4951  """
4952  args = _get_args(args)
4953  ctx = _ctx_from_ast_arg_list(args)
4954  _args, sz = _to_ast_array(args)
4955  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4956 
4957 
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.
def SetIntersect(args)
Definition: z3py.py:4945
def z3py.SetSort (   s)

Sets.

Create a set sort over element sort s

Definition at line 4909 of file z3py.py.

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

4909 def SetSort(s):
4910  """ Create a set sort over element sort s"""
4911  return ArraySort(s, BoolSort())
4912 
4913 
def BoolSort
Definition: z3py.py:1687
def ArraySort(sig)
Definition: z3py.py:4692
def SetSort(s)
Sets.
Definition: z3py.py:4909
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 4932 of file z3py.py.

4932 def SetUnion(*args):
4933  """ Take the union of sets
4934  >>> a = Const('a', SetSort(IntSort()))
4935  >>> b = Const('b', SetSort(IntSort()))
4936  >>> SetUnion(a, b)
4937  union(a, b)
4938  """
4939  args = _get_args(args)
4940  ctx = _ctx_from_ast_arg_list(args)
4941  _args, sz = _to_ast_array(args)
4942  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4943 
4944 
def SetUnion(args)
Definition: z3py.py:4932
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.
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 4355 of file z3py.py.

4355 def SignExt(n, a):
4356  """Return a bit-vector expression with `n` extra sign-bits.
4357 
4358  >>> x = BitVec('x', 16)
4359  >>> n = SignExt(8, x)
4360  >>> n.size()
4361  24
4362  >>> n
4363  SignExt(8, x)
4364  >>> n.sort()
4365  BitVec(24)
4366  >>> v0 = BitVecVal(2, 2)
4367  >>> v0
4368  2
4369  >>> v0.size()
4370  2
4371  >>> v = simplify(SignExt(6, v0))
4372  >>> v
4373  254
4374  >>> v.size()
4375  8
4376  >>> print("%.x" % v.as_long())
4377  fe
4378  """
4379  if z3_debug():
4380  _z3_assert(_is_int(n), "First argument must be an integer")
4381  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4382  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4383 
4384 
def SignExt(n, a)
Definition: z3py.py:4355
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...
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3936
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 7411 of file z3py.py.

Referenced by Solver.reason_unknown(), and Solver.statistics().

7411 def SimpleSolver(ctx=None, logFile=None):
7412  """Return a simple general purpose solver with limited amount of preprocessing.
7413 
7414  >>> s = SimpleSolver()
7415  >>> x = Int('x')
7416  >>> s.add(x > 0)
7417  >>> s.check()
7418  sat
7419  """
7420  ctx = _get_ctx(ctx)
7421  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7422 
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
def SimpleSolver
Definition: z3py.py:7411
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 8819 of file z3py.py.

Referenced by BitVecRef.__invert__(), BitVecRef.__lshift__(), ArithRef.__mod__(), ArithRef.__neg__(), BitVecRef.__neg__(), ArithRef.__pow__(), ArithRef.__rpow__(), BitVecRef.__rshift__(), AlgebraicNumRef.approx(), AlgebraicNumRef.as_decimal(), BitVecs(), Concat(), Contains(), CreateDatatypes(), Extract(), fpBVToFP(), fpFPToFP(), fpRealToFP(), fpSignedToFP(), fpToFP(), fpUnsignedToFP(), IndexOf(), InRe(), is_algebraic_value(), K(), Length(), Loop(), LShR(), Not(), Option(), Plus(), PrefixOf(), Q(), Range(), RatVal(), DatatypeSortRef.recognizer(), RepeatBitVec(), Replace(), RotateLeft(), RotateRight(), SignExt(), Star(), StrToInt(), SuffixOf(), Union(), Xor(), and ZeroExt().

8819 def simplify(a, *arguments, **keywords):
8820  """Simplify the expression `a` using the given options.
8821 
8822  This function has many options. Use `help_simplify` to obtain the complete list.
8823 
8824  >>> x = Int('x')
8825  >>> y = Int('y')
8826  >>> simplify(x + 1 + y + x + 1)
8827  2 + 2*x + y
8828  >>> simplify((x + 1)*(y + 1), som=True)
8829  1 + x + y + x*y
8830  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8831  And(Not(x == y), Not(x == 1), Not(y == 1))
8832  >>> simplify(And(x == 0, y == 1), elim_and=True)
8833  Not(Or(Not(x == 0), Not(y == 1)))
8834  """
8835  if z3_debug():
8836  _z3_assert(is_expr(a), "Z3 expression expected")
8837  if len(arguments) > 0 or len(keywords) > 0:
8838  p = args2params(arguments, keywords, a.ctx)
8839  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8840  else:
8841  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8842 
8843 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8819
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
def args2params
Definition: z3py.py:5458
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1238
def z3py.simplify_param_descrs ( )
Return the set of parameter descriptions for Z3 `simplify` procedure.

Definition at line 8849 of file z3py.py.

8850  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8852 
8853 
def main_ctx()
Definition: z3py.py:239
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
def simplify_param_descrs()
Definition: z3py.py:8849
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 9081 of file z3py.py.

Referenced by BV2Int(), and IsInt().

9081 def solve(*args, **keywords):
9082  """Solve the constraints `*args`.
9083 
9084  This is a simple function for creating demonstrations. It creates a solver,
9085  configure it using the options in `keywords`, adds the constraints
9086  in `args`, and invokes check.
9087 
9088  >>> a = Int('a')
9089  >>> solve(a > 0, a < 2)
9090  [a = 1]
9091  """
9092  show = keywords.pop("show", False)
9093  s = Solver()
9094  s.set(**keywords)
9095  s.add(*args)
9096  if show:
9097  print(s)
9098  r = s.check()
9099  if r == unsat:
9100  print("no solution")
9101  elif r == unknown:
9102  print("failed to solve")
9103  try:
9104  print(s.model())
9105  except Z3Exception:
9106  return
9107  else:
9108  print(s.model())
9109 
9110 
def solve(args, keywords)
Definition: z3py.py:9081
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 9111 of file z3py.py.

9111 def solve_using(s, *args, **keywords):
9112  """Solve the constraints `*args` using solver `s`.
9113 
9114  This is a simple function for creating demonstrations. It is similar to `solve`,
9115  but it uses the given solver `s`.
9116  It configures solver `s` using the options in `keywords`, adds the constraints
9117  in `args`, and invokes check.
9118  """
9119  show = keywords.pop("show", False)
9120  if z3_debug():
9121  _z3_assert(isinstance(s, Solver), "Solver object expected")
9122  s.set(**keywords)
9123  s.add(*args)
9124  if show:
9125  print("Problem:")
9126  print(s)
9127  r = s.check()
9128  if r == unsat:
9129  print("no solution")
9130  elif r == unknown:
9131  print("failed to solve")
9132  try:
9133  print(s.model())
9134  except Z3Exception:
9135  return
9136  else:
9137  if show:
9138  print("Solution:")
9139  print(s.model())
9140 
9141 
def solve_using(s, args, keywords)
Definition: z3py.py:9111
def z3_debug()
Definition: z3py.py:62
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 7390 of file z3py.py.

7390 def SolverFor(logic, ctx=None, logFile=None):
7391  """Create a solver customized for the given logic.
7392 
7393  The parameter `logic` is a string. It should be contains
7394  the name of a SMT-LIB logic.
7395  See http://www.smtlib.org/ for the name of all available logics.
7396 
7397  >>> s = SolverFor("QF_LIA")
7398  >>> x = Int('x')
7399  >>> s.add(x > 0)
7400  >>> s.add(x < 2)
7401  >>> s.check()
7402  sat
7403  >>> s.model()
7404  [x = 1]
7405  """
7406  ctx = _get_ctx(ctx)
7407  logic = to_symbol(logic)
7408  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7409 
7410 
def SolverFor
Definition: z3py.py:7390
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...
def to_symbol
Definition: z3py.py:124
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 3403 of file z3py.py.

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

3403 def Sqrt(a, ctx=None):
3404  """ Return a Z3 expression which represents the square root of a.
3405 
3406  >>> x = Real('x')
3407  >>> Sqrt(x)
3408  x**(1/2)
3409  """
3410  if not is_expr(a):
3411  ctx = _get_ctx(ctx)
3412  a = RealVal(a, ctx)
3413  return a ** "1/2"
3414 
3415 
def RealVal
Definition: z3py.py:3192
def is_expr(a)
Definition: z3py.py:1238
def Sqrt
Definition: z3py.py:3403
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 4270 of file z3py.py.

Referenced by BitVecRef.__mod__(), BitVecRef.__rmod__(), and URem().

4270 def SRem(a, b):
4271  """Create the Z3 expression signed remainder.
4272 
4273  Use the operator % for signed modulus, and URem() for unsigned remainder.
4274 
4275  >>> x = BitVec('x', 32)
4276  >>> y = BitVec('y', 32)
4277  >>> SRem(x, y)
4278  SRem(x, y)
4279  >>> SRem(x, y).sort()
4280  BitVec(32)
4281  >>> (x % y).sexpr()
4282  '(bvsmod x y)'
4283  >>> SRem(x, y).sexpr()
4284  '(bvsrem x y)'
4285  """
4286  _check_bv_args(a, b)
4287  a, b = _coerce_exprs(a, b)
4288  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4289 
4290 
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
def SRem(a, b)
Definition: z3py.py:4270
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 11303 of file z3py.py.

11303 def Star(re):
11304  """Create the regular expression accepting zero or more repetitions of argument.
11305  >>> re = Star(Re("a"))
11306  >>> print(simplify(InRe("aa", re)))
11307  True
11308  >>> print(simplify(InRe("ab", re)))
11309  False
11310  >>> print(simplify(InRe("", re)))
11311  True
11312  """
11313  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11314 
11315 
def Star(re)
Definition: z3py.py:11303
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
def z3py.Store (   a,
  args 
)
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 4782 of file z3py.py.

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

4782 def Store(a, *args):
4783  """Return a Z3 store array expression.
4784 
4785  >>> a = Array('a', IntSort(), IntSort())
4786  >>> i, v = Ints('i v')
4787  >>> s = Store(a, i, v)
4788  >>> s.sort()
4789  Array(Int, Int)
4790  >>> prove(s[i] == v)
4791  proved
4792  >>> j = Int('j')
4793  >>> prove(Implies(i != j, s[j] == a[j]))
4794  proved
4795  """
4796  return Update(a, args)
4797 
4798 
def Update(a, args)
Definition: z3py.py:4739
def Store(a, args)
Definition: z3py.py:4782
def z3py.StrFromCode (   c)
Convert code to a string

Definition at line 11175 of file z3py.py.

11176  """Convert code to a string"""
11177  if not is_expr(c):
11178  c = _py2expr(c)
11179  return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11180 
Z3_ast Z3_API Z3_mk_string_from_code(Z3_context c, Z3_ast a)
Code to string conversion.
def StrFromCode(c)
Definition: z3py.py:11175
def is_expr(a)
Definition: z3py.py:1238
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 10976 of file z3py.py.

10976 def String(name, ctx=None):
10977  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10978 
10979  >>> x = String('x')
10980  """
10981  ctx = _get_ctx(ctx)
10982  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10983 
10984 
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
def String
Definition: z3py.py:10976
def to_symbol
Definition: z3py.py:124
def StringSort
Definition: z3py.py:10794
def z3py.Strings (   names,
  ctx = None 
)
Return a tuple of String constants. 

Definition at line 10985 of file z3py.py.

Referenced by Contains().

10985 def Strings(names, ctx=None):
10986  """Return a tuple of String constants. """
10987  ctx = _get_ctx(ctx)
10988  if isinstance(names, str):
10989  names = names.split(" ")
10990  return [String(name, ctx) for name in names]
10991 
10992 
def String
Definition: z3py.py:10976
def Strings
Definition: z3py.py:10985
def z3py.StringSort (   ctx = None)
Create a string sort
>>> s = StringSort()
>>> print(s)
String

Definition at line 10794 of file z3py.py.

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

10794 def StringSort(ctx=None):
10795  """Create a string sort
10796  >>> s = StringSort()
10797  >>> print(s)
10798  String
10799  """
10800  ctx = _get_ctx(ctx)
10801  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10802 
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.
Strings, Sequences and Regular expressions.
Definition: z3py.py:10773
def StringSort
Definition: z3py.py:10794
def z3py.StringVal (   s,
  ctx = None 
)
create a string expression

Definition at line 10969 of file z3py.py.

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

10969 def StringVal(s, ctx=None):
10970  """create a string expression"""
10971  s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
10972  ctx = _get_ctx(ctx)
10973  return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
10974 
10975 
def StringVal
Definition: z3py.py:10969
Z3_ast Z3_API Z3_mk_string(Z3_context c, Z3_string s)
Create a string constant out of the string that is passed in The string may contain escape encoding f...
def z3py.StrToCode (   s)
Convert a unit length string to integer code

Definition at line 11169 of file z3py.py.

11169 def StrToCode(s):
11170  """Convert a unit length string to integer code"""
11171  if not is_expr(s):
11172  s = _py2expr(s)
11173  return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11174 
Z3_ast Z3_API Z3_mk_string_to_code(Z3_context c, Z3_ast a)
String to code conversion.
def is_expr(a)
Definition: z3py.py:1238
def StrToCode(s)
Definition: z3py.py:11169
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 11146 of file z3py.py.

11146 def StrToInt(s):
11147  """Convert string expression to integer
11148  >>> a = StrToInt("1")
11149  >>> simplify(1 == a)
11150  True
11151  >>> b = StrToInt("2")
11152  >>> simplify(1 == b)
11153  False
11154  >>> c = StrToInt(IntToStr(2))
11155  >>> simplify(1 == c)
11156  False
11157  """
11158  s = _coerce_seq(s)
11159  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11160 
11161 
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
def StrToInt(s)
Definition: z3py.py:11146
def z3py.SubSeq (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 10998 of file z3py.py.

10998 def SubSeq(s, offset, length):
10999  """Extract substring or subsequence starting at offset"""
11000  return Extract(s, offset, length)
11001 
11002 
def SubSeq(s, offset, length)
Definition: z3py.py:10998
def Extract(high, low, a)
Definition: z3py.py:4120
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 8854 of file z3py.py.

8854 def substitute(t, *m):
8855  """Apply substitution m on t, m is a list of pairs of the form (from, to).
8856  Every occurrence in t of from is replaced with to.
8857 
8858  >>> x = Int('x')
8859  >>> y = Int('y')
8860  >>> substitute(x + 1, (x, y + 1))
8861  y + 1 + 1
8862  >>> f = Function('f', IntSort(), IntSort())
8863  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8864  1 + 1
8865  """
8866  if isinstance(m, tuple):
8867  m1 = _get_args(m)
8868  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8869  m = m1
8870  if z3_debug():
8871  _z3_assert(is_expr(t), "Z3 expression expected")
8872  _z3_assert(
8873  all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
8874  "Z3 invalid substitution, expression pairs expected.")
8875  _z3_assert(
8876  all([p[0].sort().eq(p[1].sort()) for p in m]),
8877  'Z3 invalid substitution, mismatching "from" and "to" sorts.')
8878  num = len(m)
8879  _from = (Ast * num)()
8880  _to = (Ast * num)()
8881  for i in range(num):
8882  _from[i] = m[i][0].as_ast()
8883  _to[i] = m[i][1].as_ast()
8884  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8885 
8886 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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. The result is the new AST. The arrays from and to must have size num_exprs. For every i smaller than num_exprs, we must have that sort of from[i] must be equal to sort of to[i].
def substitute(t, m)
Definition: z3py.py:8854
def eq(a, b)
Definition: z3py.py:472
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1238
def z3py.substitute_funs (   t,
  m 
)
Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
Every occurrence in to of the function from is replaced with the expression to.
The expression to can have free variables, that refer to the arguments of from.
For examples, see 

Definition at line 8907 of file z3py.py.

8907 def substitute_funs(t, *m):
8908  """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
8909  Every occurrence in to of the function from is replaced with the expression to.
8910  The expression to can have free variables, that refer to the arguments of from.
8911  For examples, see
8912  """
8913  if isinstance(m, tuple):
8914  m1 = _get_args(m)
8915  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8916  m = m1
8917  if z3_debug():
8918  _z3_assert(is_expr(t), "Z3 expression expected")
8919  _z3_assert(all([isinstance(p, tuple) and is_func_decl(p[0]) and is_expr(p[1]) for p in m]), "Z3 invalid substitution, funcion pairs expected.")
8920  num = len(m)
8921  _from = (FuncDecl * num)()
8922  _to = (Ast * num)()
8923  for i in range(num):
8924  _from[i] = m[i][0].as_func_decl()
8925  _to[i] = m[i][1].as_ast()
8926  return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8927 
8928 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1238
def substitute_funs(t, m)
Definition: z3py.py:8907
def is_func_decl(a)
Definition: z3py.py:846
Z3_ast Z3_API Z3_substitute_funs(Z3_context c, Z3_ast a, unsigned num_funs, Z3_func_decl const from[], Z3_ast const to[])
Substitute funcions in from with new expressions in to.
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 8887 of file z3py.py.

8887 def substitute_vars(t, *m):
8888  """Substitute the free variables in t with the expression in m.
8889 
8890  >>> v0 = Var(0, IntSort())
8891  >>> v1 = Var(1, IntSort())
8892  >>> x = Int('x')
8893  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8894  >>> # replace v0 with x+1 and v1 with x
8895  >>> substitute_vars(f(v0, v1), x + 1, x)
8896  f(x + 1, x)
8897  """
8898  if z3_debug():
8899  _z3_assert(is_expr(t), "Z3 expression expected")
8900  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8901  num = len(m)
8902  _to = (Ast * num)()
8903  for i in range(num):
8904  _to[i] = m[i].as_ast()
8905  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8906 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def substitute_vars(t, m)
Definition: z3py.py:8887
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the variables in a with the expressions in to. For every i smaller than num_exprs...
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1238
def z3py.SubString (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 10993 of file z3py.py.

10993 def SubString(s, offset, length):
10994  """Extract substring or subsequence starting at offset"""
10995  return Extract(s, offset, length)
10996 
10997 
def SubString(s, offset, length)
Definition: z3py.py:10993
def Extract(high, low, a)
Definition: z3py.py:4120
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 11058 of file z3py.py.

11058 def SuffixOf(a, b):
11059  """Check if 'a' is a suffix of 'b'
11060  >>> s1 = SuffixOf("ab", "abc")
11061  >>> simplify(s1)
11062  False
11063  >>> s2 = SuffixOf("bc", "abc")
11064  >>> simplify(s2)
11065  True
11066  """
11067  ctx = _get_ctx2(a, b)
11068  a = _coerce_seq(a, ctx)
11069  b = _coerce_seq(b, ctx)
11070  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11071 
11072 
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.
def SuffixOf(a, b)
Definition: z3py.py:11058
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 8929 of file z3py.py.

Referenced by BitVecs(), Ints(), IntVector(), Reals(), and RealVector().

8929 def Sum(*args):
8930  """Create the sum of the Z3 expressions.
8931 
8932  >>> a, b, c = Ints('a b c')
8933  >>> Sum(a, b, c)
8934  a + b + c
8935  >>> Sum([a, b, c])
8936  a + b + c
8937  >>> A = IntVector('a', 5)
8938  >>> Sum(A)
8939  a__0 + a__1 + a__2 + a__3 + a__4
8940  """
8941  args = _get_args(args)
8942  if len(args) == 0:
8943  return 0
8944  ctx = _ctx_from_ast_arg_list(args)
8945  if ctx is None:
8946  return _reduce(lambda a, b: a + b, args, 0)
8947  args = _coerce_expr_list(args, ctx)
8948  if is_bv(args[0]):
8949  return _reduce(lambda a, b: a + b, args, 0)
8950  else:
8951  _args, sz = _to_ast_array(args)
8952  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8953 
8954 
def Sum(args)
Definition: z3py.py:8929
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].
def is_bv(a)
Definition: z3py.py:3936
def z3py.tactic_description (   name,
  ctx = None 
)
Return a short description for the tactic named `name`.

>>> d = tactic_description('simplify')

Definition at line 8508 of file z3py.py.

Referenced by describe_tactics().

8508 def tactic_description(name, ctx=None):
8509  """Return a short description for the tactic named `name`.
8510 
8511  >>> d = tactic_description('simplify')
8512  """
8513  ctx = _get_ctx(ctx)
8514  return Z3_tactic_get_descr(ctx.ref(), name)
8515 
8516 
def tactic_description
Definition: z3py.py:8508
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.
def z3py.tactics (   ctx = None)
Return a list of all available tactics in Z3.

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

Definition at line 8497 of file z3py.py.

Referenced by describe_tactics().

8497 def tactics(ctx=None):
8498  """Return a list of all available tactics in Z3.
8499 
8500  >>> l = tactics()
8501  >>> l.count('simplify') == 1
8502  True
8503  """
8504  ctx = _get_ctx(ctx)
8505  return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8506 
8507 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
def tactics
Definition: z3py.py:8497
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 8365 of file z3py.py.

Referenced by Statistics.__getattr__(), Statistics.__getitem__(), Statistics.__len__(), Goal.convert_model(), Goal.depth(), Statistics.get_key_value(), and Statistics.keys().

8365 def Then(*ts, **ks):
8366  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8367 
8368  >>> x, y = Ints('x y')
8369  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8370  >>> t(And(x == 0, y > x + 1))
8371  [[Not(y <= 1)]]
8372  >>> t(And(x == 0, y > x + 1)).as_expr()
8373  Not(y <= 1)
8374  """
8375  return AndThen(*ts, **ks)
8376 
8377 
def Then(ts, ks)
Definition: z3py.py:8365
def AndThen(ts, ks)
Definition: z3py.py:8345
def z3py.to_Ast (   ptr)

Definition at line 11377 of file z3py.py.

Referenced by on_clause_eh().

11377 def to_Ast(ptr,):
11378  ast = Ast(ptr)
11379  super(ctypes.c_void_p, ast).__init__(ptr)
11380  return ast
11381 
def to_Ast(ptr)
Definition: z3py.py:11377
def z3py.to_AstVectorObj (   ptr)

Definition at line 11387 of file z3py.py.

Referenced by on_clause_eh().

11388  v = AstVectorObj(ptr)
11389  super(ctypes.c_void_p, v).__init__(ptr)
11390  return v
11391 
11392 # NB. my-hacky-class only works for a single instance of OnClause
11393 # it should be replaced with a proper correlation between OnClause
11394 # and object references that can be passed over the FFI.
11395 # for UserPropagator we use a global dictionary, which isn't great code.
11396 
def to_AstVectorObj(ptr)
Definition: z3py.py:11387
def z3py.to_ContextObj (   ptr)

Definition at line 11382 of file z3py.py.

11382 def to_ContextObj(ptr,):
11383  ctx = ContextObj(ptr)
11384  super(ctypes.c_void_p, ctx).__init__(ptr)
11385  return ctx
11386 
def to_ContextObj(ptr)
Definition: z3py.py:11382
def z3py.to_symbol (   s,
  ctx = None 
)
Convert an integer or string into a Z3 symbol.

Definition at line 124 of file z3py.py.

Referenced by Fixedpoint.add_rule(), Optimize.add_soft(), Array(), BitVec(), Bool(), Const(), CreateDatatypes(), DatatypeSort(), DeclareSort(), EnumSort(), FiniteDomainSort(), FP(), Function(), Int(), PropagateFunction(), prove(), Real(), RecFunction(), Fixedpoint.set_predicate_representation(), SolverFor(), String(), and Fixedpoint.update_rule().

124 def to_symbol(s, ctx=None):
125  """Convert an integer or string into a Z3 symbol."""
126  if _is_int(s):
127  return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
128  else:
129  return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
130 
131 
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
def to_symbol
Definition: z3py.py:124
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 3368 of file z3py.py.

Referenced by is_to_int().

3368 def ToInt(a):
3369  """ Return the Z3 expression ToInt(a).
3370 
3371  >>> x = Real('x')
3372  >>> x.sort()
3373  Real
3374  >>> n = ToInt(x)
3375  >>> n
3376  ToInt(x)
3377  >>> n.sort()
3378  Int
3379  """
3380  if z3_debug():
3381  _z3_assert(a.is_real(), "Z3 real expression expected.")
3382  ctx = a.ctx
3383  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3384 
3385 
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.
def z3_debug()
Definition: z3py.py:62
def ToInt(a)
Definition: z3py.py:3368
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 3350 of file z3py.py.

Referenced by ArithRef.__ge__(), ArithRef.__gt__(), ArithRef.__le__(), ArithRef.__lt__(), and is_to_real().

3350 def ToReal(a):
3351  """ Return the Z3 expression ToReal(a).
3352 
3353  >>> x = Int('x')
3354  >>> x.sort()
3355  Int
3356  >>> n = ToReal(x)
3357  >>> n
3358  ToReal(x)
3359  >>> n.sort()
3360  Real
3361  """
3362  if z3_debug():
3363  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3364  ctx = a.ctx
3365  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3366 
3367 
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
def ToReal(a)
Definition: z3py.py:3350
def z3_debug()
Definition: z3py.py:62
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 11370 of file z3py.py.

11371  """Given a binary relation R, such that the two arguments have the same sort
11372  create the transitive closure relation R+.
11373  The transitive closure R+ is a new relation.
11374  """
11375  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11376 
def TransitiveClosure(f)
Definition: z3py.py:11370
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
Function Declarations.
Definition: z3py.py:718
def z3py.TreeOrder (   a,
  index 
)

Definition at line 11362 of file z3py.py.

11362 def TreeOrder(a, index):
11363  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11364 
11365 
Function Declarations.
Definition: z3py.py:718
def TreeOrder(a, index)
Definition: z3py.py:11362
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.
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 8488 of file z3py.py.

8488 def TryFor(t, ms, ctx=None):
8489  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8490 
8491  If `t` does not terminate in `ms` milliseconds, then it fails.
8492  """
8493  t = _to_tactic(t, ctx)
8494  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8495 
8496 
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...
def TryFor
Definition: z3py.py:8488
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 5355 of file z3py.py.

5355 def TupleSort(name, sorts, ctx=None):
5356  """Create a named tuple sort base on a set of underlying sorts
5357  Example:
5358  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5359  """
5360  tuple = Datatype(name, ctx)
5361  projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5362  tuple.declare(name, *projects)
5363  tuple = tuple.create()
5364  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5365 
5366 
def TupleSort
Definition: z3py.py:5355
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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 4228 of file z3py.py.

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

4228 def UDiv(a, b):
4229  """Create the Z3 expression (unsigned) division `self / other`.
4230 
4231  Use the operator / for signed division.
4232 
4233  >>> x = BitVec('x', 32)
4234  >>> y = BitVec('y', 32)
4235  >>> UDiv(x, y)
4236  UDiv(x, y)
4237  >>> UDiv(x, y).sort()
4238  BitVec(32)
4239  >>> (x / y).sexpr()
4240  '(bvsdiv x y)'
4241  >>> UDiv(x, y).sexpr()
4242  '(bvudiv x y)'
4243  """
4244  _check_bv_args(a, b)
4245  a, b = _coerce_exprs(a, b)
4246  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4247 
4248 
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
def UDiv(a, b)
Definition: z3py.py:4228
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 4192 of file z3py.py.

Referenced by BitVecRef.__ge__().

4192 def UGE(a, b):
4193  """Create the Z3 expression (unsigned) `other >= self`.
4194 
4195  Use the operator >= for signed greater than or equal to.
4196 
4197  >>> x, y = BitVecs('x y', 32)
4198  >>> UGE(x, y)
4199  UGE(x, y)
4200  >>> (x >= y).sexpr()
4201  '(bvsge x y)'
4202  >>> UGE(x, y).sexpr()
4203  '(bvuge x y)'
4204  """
4205  _check_bv_args(a, b)
4206  a, b = _coerce_exprs(a, b)
4207  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4208 
4209 
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
def UGE(a, b)
Definition: z3py.py:4192
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 4210 of file z3py.py.

Referenced by BitVecRef.__gt__().

4210 def UGT(a, b):
4211  """Create the Z3 expression (unsigned) `other > self`.
4212 
4213  Use the operator > for signed greater than.
4214 
4215  >>> x, y = BitVecs('x y', 32)
4216  >>> UGT(x, y)
4217  UGT(x, y)
4218  >>> (x > y).sexpr()
4219  '(bvsgt x y)'
4220  >>> UGT(x, y).sexpr()
4221  '(bvugt x y)'
4222  """
4223  _check_bv_args(a, b)
4224  a, b = _coerce_exprs(a, b)
4225  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4226 
4227 
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
def UGT(a, b)
Definition: z3py.py:4210
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 4156 of file z3py.py.

Referenced by BitVecRef.__le__().

4156 def ULE(a, b):
4157  """Create the Z3 expression (unsigned) `other <= self`.
4158 
4159  Use the operator <= for signed less than or equal to.
4160 
4161  >>> x, y = BitVecs('x y', 32)
4162  >>> ULE(x, y)
4163  ULE(x, y)
4164  >>> (x <= y).sexpr()
4165  '(bvsle x y)'
4166  >>> ULE(x, y).sexpr()
4167  '(bvule x y)'
4168  """
4169  _check_bv_args(a, b)
4170  a, b = _coerce_exprs(a, b)
4171  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4172 
4173 
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
def ULE(a, b)
Definition: z3py.py:4156
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 4174 of file z3py.py.

Referenced by BitVecRef.__lt__().

4174 def ULT(a, b):
4175  """Create the Z3 expression (unsigned) `other < self`.
4176 
4177  Use the operator < for signed less than.
4178 
4179  >>> x, y = BitVecs('x y', 32)
4180  >>> ULT(x, y)
4181  ULT(x, y)
4182  >>> (x < y).sexpr()
4183  '(bvslt x y)'
4184  >>> ULT(x, y).sexpr()
4185  '(bvult x y)'
4186  """
4187  _check_bv_args(a, b)
4188  a, b = _coerce_exprs(a, b)
4189  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4190 
4191 
def ULT(a, b)
Definition: z3py.py:4174
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
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 11234 of file z3py.py.

Referenced by InRe().

11234 def Union(*args):
11235  """Create union of regular expressions.
11236  >>> re = Union(Re("a"), Re("b"), Re("c"))
11237  >>> print (simplify(InRe("d", re)))
11238  False
11239  """
11240  args = _get_args(args)
11241  sz = len(args)
11242  if z3_debug():
11243  _z3_assert(sz > 0, "At least one argument expected.")
11244  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11245  if sz == 1:
11246  return args[0]
11247  ctx = args[0].ctx
11248  v = (Ast * sz)()
11249  for i in range(sz):
11250  v[i] = args[i].as_ast()
11251  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11252 
11253 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Union(args)
Definition: z3py.py:11234
def is_re(s)
Definition: z3py.py:11216
def z3_debug()
Definition: z3py.py:62
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
def z3py.Unit (   a)
Create a singleton sequence

Definition at line 11038 of file z3py.py.

Referenced by is_seq(), Re(), and SeqSort().

11038 def Unit(a):
11039  """Create a singleton sequence"""
11040  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11041 
11042 
def Unit(a)
Definition: z3py.py:11038
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
def z3py.Update (   a,
  args 
)
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 4739 of file z3py.py.

Referenced by Store().

4739 def Update(a, *args):
4740  """Return a Z3 store array expression.
4741 
4742  >>> a = Array('a', IntSort(), IntSort())
4743  >>> i, v = Ints('i v')
4744  >>> s = Update(a, i, v)
4745  >>> s.sort()
4746  Array(Int, Int)
4747  >>> prove(s[i] == v)
4748  proved
4749  >>> j = Int('j')
4750  >>> prove(Implies(i != j, s[j] == a[j]))
4751  proved
4752  """
4753  if z3_debug():
4754  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4755  args = _get_args(args)
4756  ctx = a.ctx
4757  if len(args) <= 1:
4758  raise Z3Exception("array update requires index and value arguments")
4759  if len(args) == 2:
4760  i = args[0]
4761  v = args[1]
4762  i = a.sort().domain().cast(i)
4763  v = a.sort().range().cast(v)
4764  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4765  v = a.sort().range().cast(args[-1])
4766  idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4767  _args, sz = _to_ast_array(idxs)
4768  return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4769 
4770 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
def Update(a, args)
Definition: z3py.py:4739
def is_array_sort(a)
Definition: z3py.py:4599
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs, Z3_ast v)
n-ary Array update.
def z3_debug()
Definition: z3py.py:62
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 4249 of file z3py.py.

Referenced by BitVecRef.__mod__(), BitVecRef.__rmod__(), and SRem().

4249 def URem(a, b):
4250  """Create the Z3 expression (unsigned) remainder `self % other`.
4251 
4252  Use the operator % for signed modulus, and SRem() for signed remainder.
4253 
4254  >>> x = BitVec('x', 32)
4255  >>> y = BitVec('y', 32)
4256  >>> URem(x, y)
4257  URem(x, y)
4258  >>> URem(x, y).sort()
4259  BitVec(32)
4260  >>> (x % y).sexpr()
4261  '(bvsmod x y)'
4262  >>> URem(x, y).sexpr()
4263  '(bvurem x y)'
4264  """
4265  _check_bv_args(a, b)
4266  a, b = _coerce_exprs(a, b)
4267  return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4268 
4269 
def URem(a, b)
Definition: z3py.py:4249
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
def z3py.user_prop_created (   ctx,
  cb,
  id 
)

Definition at line 11496 of file z3py.py.

11496 def user_prop_created(ctx, cb, id):
11497  prop = _prop_closures.get(ctx)
11498  prop.cb = cb
11499  id = _to_expr_ref(to_Ast(id), prop.ctx())
11500  prop.created(id)
11501  prop.cb = None
11502 
def user_prop_created(ctx, cb, id)
Definition: z3py.py:11496
def to_Ast(ptr)
Definition: z3py.py:11377
def z3py.user_prop_decide (   ctx,
  cb,
  t_ref,
  idx_ref,
  phase_ref 
)

Definition at line 11527 of file z3py.py.

11527 def user_prop_decide(ctx, cb, t_ref, idx_ref, phase_ref):
11528  prop = _prop_closures.get(ctx)
11529  prop.cb = cb
11530  t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11531  t, idx, phase = prop.decide(t, idx, phase)
11532  t_ref = t
11533  idx_ref = idx
11534  phase_ref = phase
11535  prop.cb = None
11536 
11537 
def to_Ast(ptr)
Definition: z3py.py:11377
def user_prop_decide(ctx, cb, t_ref, idx_ref, phase_ref)
Definition: z3py.py:11527
def z3py.user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11517 of file z3py.py.

11517 def user_prop_diseq(ctx, cb, x, y):
11518  prop = _prop_closures.get(ctx)
11519  prop.cb = cb
11520  x = _to_expr_ref(to_Ast(x), prop.ctx())
11521  y = _to_expr_ref(to_Ast(y), prop.ctx())
11522  prop.diseq(x, y)
11523  prop.cb = None
11524 
11525 # TODO The decision callback is not fully implemented.
11526 # It needs to handle the ast*, unsigned* idx, and Z3_lbool*
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:11517
def to_Ast(ptr)
Definition: z3py.py:11377
def z3py.user_prop_eq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11509 of file z3py.py.

11509 def user_prop_eq(ctx, cb, x, y):
11510  prop = _prop_closures.get(ctx)
11511  prop.cb = cb
11512  x = _to_expr_ref(to_Ast(x), prop.ctx())
11513  y = _to_expr_ref(to_Ast(y), prop.ctx())
11514  prop.eq(x, y)
11515  prop.cb = None
11516 
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:11509
def to_Ast(ptr)
Definition: z3py.py:11377
def z3py.user_prop_final (   ctx,
  cb 
)

Definition at line 11503 of file z3py.py.

11503 def user_prop_final(ctx, cb):
11504  prop = _prop_closures.get(ctx)
11505  prop.cb = cb
11506  prop.final()
11507  prop.cb = None
11508 
def user_prop_final(ctx, cb)
Definition: z3py.py:11503
def z3py.user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 11488 of file z3py.py.

11488 def user_prop_fixed(ctx, cb, id, value):
11489  prop = _prop_closures.get(ctx)
11490  prop.cb = cb
11491  id = _to_expr_ref(to_Ast(id), prop.ctx())
11492  value = _to_expr_ref(to_Ast(value), prop.ctx())
11493  prop.fixed(id, value)
11494  prop.cb = None
11495 
def to_Ast(ptr)
Definition: z3py.py:11377
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:11488
def z3py.user_prop_fresh (   ctx,
  _new_ctx 
)

Definition at line 11474 of file z3py.py.

11474 def user_prop_fresh(ctx, _new_ctx):
11475  _prop_closures.set_threaded()
11476  prop = _prop_closures.get(ctx)
11477  nctx = Context()
11478  Z3_del_context(nctx.ctx)
11479  new_ctx = to_ContextObj(_new_ctx)
11480  nctx.ctx = new_ctx
11481  nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11482  nctx.owner = False
11483  new_prop = prop.fresh(nctx)
11484  _prop_closures.set(new_prop.id, new_prop)
11485  return new_prop.id
11486 
11487 
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
def user_prop_fresh(ctx, _new_ctx)
Definition: z3py.py:11474
def to_ContextObj(ptr)
Definition: z3py.py:11382
def z3py.user_prop_pop (   ctx,
  cb,
  num_scopes 
)

Definition at line 11468 of file z3py.py.

11468 def user_prop_pop(ctx, cb, num_scopes):
11469  prop = _prop_closures.get(ctx)
11470  prop.cb = cb
11471  prop.pop(num_scopes)
11472 
11473 
def user_prop_pop(ctx, cb, num_scopes)
Definition: z3py.py:11468
def z3py.user_prop_push (   ctx,
  cb 
)

Definition at line 11462 of file z3py.py.

11462 def user_prop_push(ctx, cb):
11463  prop = _prop_closures.get(ctx)
11464  prop.cb = cb
11465  prop.push()
11466 
11467 
def user_prop_push(ctx, cb)
Definition: z3py.py:11462
def z3py.Var (   idx,
  s 
)
Create a Z3 free variable. Free variables are used to create quantified formulas.
A free variable with index n is bound when it occurs within the scope of n+1 quantified
declarations.

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

Definition at line 1466 of file z3py.py.

Referenced by QuantifierRef.body(), QuantifierRef.children(), is_pattern(), MultiPattern(), QuantifierRef.pattern(), and RealVar().

1466 def Var(idx, s):
1467  """Create a Z3 free variable. Free variables are used to create quantified formulas.
1468  A free variable with index n is bound when it occurs within the scope of n+1 quantified
1469  declarations.
1470 
1471  >>> Var(0, IntSort())
1472  Var(0)
1473  >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1474  False
1475  """
1476  if z3_debug():
1477  _z3_assert(is_sort(s), "Z3 sort expected")
1478  return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1479 
1480 
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a variable.
def Var(idx, s)
Definition: z3py.py:1466
def is_sort(s)
Definition: z3py.py:647
def z3_debug()
Definition: z3py.py:62
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 8782 of file z3py.py.

8782 def When(p, t, ctx=None):
8783  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8784  Otherwise, it returns the input goal unmodified.
8785 
8786  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8787  >>> x, y = Ints('x y')
8788  >>> g = Goal()
8789  >>> g.add(x > 0)
8790  >>> g.add(y > 0)
8791  >>> t(g)
8792  [[x > 0, y > 0]]
8793  >>> g.add(x == y + 1)
8794  >>> t(g)
8795  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8796  """
8797  p = _to_probe(p, ctx)
8798  t = _to_tactic(t, ctx)
8799  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8800 
8801 
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...
def When
Definition: z3py.py:8782
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 8439 of file z3py.py.

Referenced by Goal.prec().

8439 def With(t, *args, **keys):
8440  """Return a tactic that applies tactic `t` using the given configuration options.
8441 
8442  >>> x, y = Ints('x y')
8443  >>> t = With(Tactic('simplify'), som=True)
8444  >>> t((x + 1)*(y + 2) == 0)
8445  [[2*x + y + x*y == -2]]
8446  """
8447  ctx = keys.pop("ctx", None)
8448  t = _to_tactic(t, ctx)
8449  p = args2params(args, keys, t.ctx)
8450  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8451 
8452 
def args2params
Definition: z3py.py:5458
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.
def With(t, args, keys)
Definition: z3py.py:8439
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 8453 of file z3py.py.

8453 def WithParams(t, p):
8454  """Return a tactic that applies tactic `t` using the given configuration options.
8455 
8456  >>> x, y = Ints('x y')
8457  >>> p = ParamsRef()
8458  >>> p.set("som", True)
8459  >>> t = WithParams(Tactic('simplify'), p)
8460  >>> t((x + 1)*(y + 2) == 0)
8461  [[2*x + y + x*y == -2]]
8462  """
8463  t = _to_tactic(t, None)
8464  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8465 
8466 
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.
def WithParams(t, p)
Definition: z3py.py:8453
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 1795 of file z3py.py.

1795 def Xor(a, b, ctx=None):
1796  """Create a Z3 Xor expression.
1797 
1798  >>> p, q = Bools('p q')
1799  >>> Xor(p, q)
1800  Xor(p, q)
1801  >>> simplify(Xor(p, q))
1802  Not(p == q)
1803  """
1804  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1805  s = BoolSort(ctx)
1806  a = s.cast(a)
1807  b = s.cast(b)
1808  return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1809 
1810 
def BoolSort
Definition: z3py.py:1687
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
def Xor
Definition: z3py.py:1795
def z3py.z3_debug ( )
def z3py.z3_error_handler (   c,
  e 
)

Definition at line 174 of file z3py.py.

175  # Do nothing error handler, just avoid exit(0)
176  # The wrappers in z3core.py will raise a Z3Exception if an error is detected
177  return
178 
179 
def z3_error_handler(c, e)
Definition: z3py.py:174
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 4385 of file z3py.py.

4385 def ZeroExt(n, a):
4386  """Return a bit-vector expression with `n` extra zero-bits.
4387 
4388  >>> x = BitVec('x', 16)
4389  >>> n = ZeroExt(8, x)
4390  >>> n.size()
4391  24
4392  >>> n
4393  ZeroExt(8, x)
4394  >>> n.sort()
4395  BitVec(24)
4396  >>> v0 = BitVecVal(2, 2)
4397  >>> v0
4398  2
4399  >>> v0.size()
4400  2
4401  >>> v = simplify(ZeroExt(6, v0))
4402  >>> v
4403  2
4404  >>> v.size()
4405  8
4406  """
4407  if z3_debug():
4408  _z3_assert(_is_int(n), "First argument must be an integer")
4409  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4410  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4411 
4412 
def ZeroExt(n, a)
Definition: z3py.py:4385
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3936
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i...

Variable Documentation

int _dflt_fpsort_ebits = 11

Definition at line 9334 of file z3py.py.

int _dflt_fpsort_sbits = 53

Definition at line 9335 of file z3py.py.

_dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN

Floating-Point Arithmetic.

Definition at line 9333 of file z3py.py.

_main_ctx = None

Definition at line 236 of file z3py.py.

_my_hacky_class = None

Definition at line 11397 of file z3py.py.

tuple _on_clause_eh = Z3_on_clause_eh(on_clause_eh)

Definition at line 11404 of file z3py.py.

tuple _on_model_eh = on_model_eh_type(_global_on_model)

Definition at line 7855 of file z3py.py.

dictionary _on_models = {}

Definition at line 7847 of file z3py.py.

_prop_closures = None

Definition at line 11453 of file z3py.py.

tuple _ROUNDING_MODES
Initial value:
1 = frozenset({
2  Z3_OP_FPA_RM_TOWARD_ZERO,
3  Z3_OP_FPA_RM_TOWARD_NEGATIVE,
4  Z3_OP_FPA_RM_TOWARD_POSITIVE,
5  Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN,
6  Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY
7 })

Definition at line 9353 of file z3py.py.

tuple _user_prop_created = Z3_created_eh(user_prop_created)

Definition at line 11542 of file z3py.py.

tuple _user_prop_decide = Z3_decide_eh(user_prop_decide)

Definition at line 11546 of file z3py.py.

tuple _user_prop_diseq = Z3_eq_eh(user_prop_diseq)

Definition at line 11545 of file z3py.py.

tuple _user_prop_eq = Z3_eq_eh(user_prop_eq)

Definition at line 11544 of file z3py.py.

tuple _user_prop_final = Z3_final_eh(user_prop_final)

Definition at line 11543 of file z3py.py.

tuple _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)

Definition at line 11541 of file z3py.py.

tuple _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)

Definition at line 11540 of file z3py.py.

tuple _user_prop_pop = Z3_pop_eh(user_prop_pop)

Definition at line 11539 of file z3py.py.

tuple _user_prop_push = Z3_push_eh(user_prop_push)

Definition at line 11538 of file z3py.py.

tuple sat = CheckSatResult(Z3_L_TRUE)

Definition at line 6884 of file z3py.py.

tuple unknown = CheckSatResult(Z3_L_UNDEF)

Definition at line 6886 of file z3py.py.

tuple unsat = CheckSatResult(Z3_L_FALSE)

Definition at line 6885 of file z3py.py.

Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.