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  TypeVarRef
 
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 DeclareTypeVar
 
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 (bv)
 
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, n, dep, 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, idx, phase)
 
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 9048 of file z3py.py.

9048 def Abs(arg):
9049  """Create the absolute value of an arithmetic expression"""
9050  return If(arg > 0, arg, -arg)
9051 
9052 
def If
Definition: z3py.py:1399
def Abs(arg)
Definition: z3py.py:9048
def z3py.AllChar (   regex_sort,
  ctx = None 
)
Create a regular expression that accepts all single character strings

Definition at line 11428 of file z3py.py.

11428 def AllChar(regex_sort, ctx=None):
11429  """Create a regular expression that accepts all single character strings
11430  """
11431  return ReRef(Z3_mk_re_allchar(regex_sort.ctx_ref(), regex_sort.ast), regex_sort.ctx)
11432 
11433 # Special Relations
11434 
11435 
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:11428
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 1889 of file z3py.py.

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

1889 def And(*args):
1890  """Create a Z3 and-expression or and-probe.
1891 
1892  >>> p, q, r = Bools('p q r')
1893  >>> And(p, q, r)
1894  And(p, q, r)
1895  >>> P = BoolVector('p', 5)
1896  >>> And(P)
1897  And(p__0, p__1, p__2, p__3, p__4)
1898  """
1899  last_arg = None
1900  if len(args) > 0:
1901  last_arg = args[len(args) - 1]
1902  if isinstance(last_arg, Context):
1903  ctx = args[len(args) - 1]
1904  args = args[:len(args) - 1]
1905  elif len(args) == 1 and isinstance(args[0], AstVector):
1906  ctx = args[0].ctx
1907  args = [a for a in args[0]]
1908  else:
1909  ctx = None
1910  args = _get_args(args)
1911  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1912  if z3_debug():
1913  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1914  if _has_probe(args):
1915  return _probe_and(args, ctx)
1916  else:
1917  args = _coerce_expr_list(args, ctx)
1918  _args, sz = _to_ast_array(args)
1919  return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1920 
1921 
def And(args)
Definition: z3py.py:1889
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 8413 of file z3py.py.

Referenced by Then().

8413 def AndThen(*ts, **ks):
8414  """Return a tactic that applies the tactics in `*ts` in sequence.
8415 
8416  >>> x, y = Ints('x y')
8417  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
8418  >>> t(And(x == 0, y > x + 1))
8419  [[Not(y <= 1)]]
8420  >>> t(And(x == 0, y > x + 1)).as_expr()
8421  Not(y <= 1)
8422  """
8423  if z3_debug():
8424  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8425  ctx = ks.get("ctx", None)
8426  num = len(ts)
8427  r = ts[0]
8428  for i in range(num - 1):
8429  r = _and_then(r, ts[i + 1], ctx)
8430  return r
8431 
8432 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def AndThen(ts, ks)
Definition: z3py.py:8413
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 5512 of file z3py.py.

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

5512 def args2params(arguments, keywords, ctx=None):
5513  """Convert python arguments into a Z3_params object.
5514  A ':' is added to the keywords, and '_' is replaced with '-'
5515 
5516  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5517  (params model true relevancy 2 elim_and true)
5518  """
5519  if z3_debug():
5520  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5521  prev = None
5522  r = ParamsRef(ctx)
5523  for a in arguments:
5524  if prev is None:
5525  prev = a
5526  else:
5527  r.set(prev, a)
5528  prev = None
5529  for k in keywords:
5530  v = keywords[k]
5531  r.set(k, v)
5532  return r
5533 
5534 
def args2params
Definition: z3py.py:5512
Parameter Sets.
Definition: z3py.py:5466
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 4779 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().

4779 def Array(name, *sorts):
4780  """Return an array constant named `name` with the given domain and range sorts.
4781 
4782  >>> a = Array('a', IntSort(), IntSort())
4783  >>> a.sort()
4784  Array(Int, Int)
4785  >>> a[0]
4786  a[0]
4787  """
4788  s = ArraySort(sorts)
4789  ctx = s.ctx
4790  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4791 
4792 
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:4746
def Array(name, sorts)
Definition: z3py.py:4779
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 4746 of file z3py.py.

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

4746 def ArraySort(*sig):
4747  """Return the Z3 array sort with the given domain and range sorts.
4748 
4749  >>> A = ArraySort(IntSort(), BoolSort())
4750  >>> A
4751  Array(Int, Bool)
4752  >>> A.domain()
4753  Int
4754  >>> A.range()
4755  Bool
4756  >>> AA = ArraySort(IntSort(), A)
4757  >>> AA
4758  Array(Int, Array(Int, Bool))
4759  """
4760  sig = _get_args(sig)
4761  if z3_debug():
4762  _z3_assert(len(sig) > 1, "At least two arguments expected")
4763  arity = len(sig) - 1
4764  r = sig[arity]
4765  d = sig[0]
4766  if z3_debug():
4767  for s in sig:
4768  _z3_assert(is_sort(s), "Z3 sort expected")
4769  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4770  ctx = d.ctx
4771  if len(sig) == 2:
4772  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4773  dom = (Sort * arity)()
4774  for i in range(arity):
4775  dom[i] = sig[i].ast
4776  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4777 
4778 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def ArraySort(sig)
Definition: z3py.py:4746
Arrays.
Definition: z3py.py:4567
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-least Pseudo-Boolean k constraint.

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

Definition at line 9071 of file z3py.py.

9071 def AtLeast(*args):
9072  """Create an at-least Pseudo-Boolean k constraint.
9073 
9074  >>> a, b, c = Bools('a b c')
9075  >>> f = AtLeast(a, b, c, 2)
9076  """
9077  args = _get_args(args)
9078  if z3_debug():
9079  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9080  ctx = _ctx_from_ast_arg_list(args)
9081  if z3_debug():
9082  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9083  args1 = _coerce_expr_list(args[:-1], ctx)
9084  k = args[-1]
9085  _args, sz = _to_ast_array(args1)
9086  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
9087 
9088 
def AtLeast(args)
Definition: z3py.py:9071
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 9053 of file z3py.py.

9053 def AtMost(*args):
9054  """Create an at-most Pseudo-Boolean k constraint.
9055 
9056  >>> a, b, c = Bools('a b c')
9057  >>> f = AtMost(a, b, c, 2)
9058  """
9059  args = _get_args(args)
9060  if z3_debug():
9061  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
9062  ctx = _ctx_from_ast_arg_list(args)
9063  if z3_debug():
9064  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
9065  args1 = _coerce_expr_list(args[:-1], ctx)
9066  k = args[-1]
9067  _args, sz = _to_ast_array(args1)
9068  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
9069 
9070 
def AtMost(args)
Definition: z3py.py:9053
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 4083 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().

4083 def BitVec(name, bv, ctx=None):
4084  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
4085  If `ctx=None`, then the global context is used.
4086 
4087  >>> x = BitVec('x', 16)
4088  >>> is_bv(x)
4089  True
4090  >>> x.size()
4091  16
4092  >>> x.sort()
4093  BitVec(16)
4094  >>> word = BitVecSort(16)
4095  >>> x2 = BitVec('x', word)
4096  >>> eq(x, x2)
4097  True
4098  """
4099  if isinstance(bv, BitVecSortRef):
4100  ctx = bv.ctx
4101  else:
4102  ctx = _get_ctx(ctx)
4103  bv = BitVecSort(bv, ctx)
4104  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
4105 
4106 
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:4051
def BitVec
Definition: z3py.py:4083
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 4107 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().

4107 def BitVecs(names, bv, ctx=None):
4108  """Return a tuple of bit-vector constants of size bv.
4109 
4110  >>> x, y, z = BitVecs('x y z', 16)
4111  >>> x.size()
4112  16
4113  >>> x.sort()
4114  BitVec(16)
4115  >>> Sum(x, y, z)
4116  0 + x + y + z
4117  >>> Product(x, y, z)
4118  1*x*y*z
4119  >>> simplify(Product(x, y, z))
4120  x*y*z
4121  """
4122  ctx = _get_ctx(ctx)
4123  if isinstance(names, str):
4124  names = names.split(" ")
4125  return [BitVec(name, bv, ctx) for name in names]
4126 
4127 
def BitVec
Definition: z3py.py:4083
def BitVecs
Definition: z3py.py:4107
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 4051 of file z3py.py.

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

4051 def BitVecSort(sz, ctx=None):
4052  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
4053 
4054  >>> Byte = BitVecSort(8)
4055  >>> Word = BitVecSort(16)
4056  >>> Byte
4057  BitVec(8)
4058  >>> x = Const('x', Byte)
4059  >>> eq(x, BitVec('x', 8))
4060  True
4061  """
4062  ctx = _get_ctx(ctx)
4063  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
4064 
4065 
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:4051
Bit-Vectors.
Definition: z3py.py:3489
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 4066 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().

4066 def BitVecVal(val, bv, ctx=None):
4067  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
4068 
4069  >>> v = BitVecVal(10, 32)
4070  >>> v
4071  10
4072  >>> print("0x%.8x" % v.as_long())
4073  0x0000000a
4074  """
4075  if is_bv_sort(bv):
4076  ctx = bv.ctx
4077  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
4078  else:
4079  ctx = _get_ctx(ctx)
4080  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
4081 
4082 
def BitVecSort
Definition: z3py.py:4051
def BitVecVal
Definition: z3py.py:4066
def is_bv_sort(s)
Definition: z3py.py:3522
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 1768 of file z3py.py.

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

1768 def Bool(name, ctx=None):
1769  """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1770 
1771  >>> p = Bool('p')
1772  >>> q = Bool('q')
1773  >>> And(p, q)
1774  And(p, q)
1775  """
1776  ctx = _get_ctx(ctx)
1777  return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1778 
1779 
def BoolSort
Definition: z3py.py:1731
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:1768
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 1780 of file z3py.py.

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

1780 def Bools(names, ctx=None):
1781  """Return a tuple of Boolean constants.
1782 
1783  `names` is a single string containing all names separated by blank spaces.
1784  If `ctx=None`, then the global context is used.
1785 
1786  >>> p, q, r = Bools('p q r')
1787  >>> And(p, Or(q, r))
1788  And(p, Or(q, r))
1789  """
1790  ctx = _get_ctx(ctx)
1791  if isinstance(names, str):
1792  names = names.split(" ")
1793  return [Bool(name, ctx) for name in names]
1794 
1795 
def Bools
Definition: z3py.py:1780
def Bool
Definition: z3py.py:1768
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 1731 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().

1731 def BoolSort(ctx=None):
1732  """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1733 
1734  >>> BoolSort()
1735  Bool
1736  >>> p = Const('p', BoolSort())
1737  >>> is_bool(p)
1738  True
1739  >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1740  >>> r(0, 1)
1741  r(0, 1)
1742  >>> is_bool(r(0, 1))
1743  True
1744  """
1745  ctx = _get_ctx(ctx)
1746  return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1747 
1748 
def BoolSort
Definition: z3py.py:1731
def is_bool(a)
Definition: z3py.py:1611
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 1749 of file z3py.py.

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

1749 def BoolVal(val, ctx=None):
1750  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1751 
1752  >>> BoolVal(True)
1753  True
1754  >>> is_true(BoolVal(True))
1755  True
1756  >>> is_true(True)
1757  False
1758  >>> is_false(BoolVal(False))
1759  True
1760  """
1761  ctx = _get_ctx(ctx)
1762  if val:
1763  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1764  else:
1765  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1766 
1767 
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:1749
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 1796 of file z3py.py.

Referenced by And(), and Or().

1796 def BoolVector(prefix, sz, ctx=None):
1797  """Return a list of Boolean constants of size `sz`.
1798 
1799  The constants are named using the given prefix.
1800  If `ctx=None`, then the global context is used.
1801 
1802  >>> P = BoolVector('p', 3)
1803  >>> P
1804  [p__0, p__1, p__2]
1805  >>> And(P)
1806  And(p__0, p__1, p__2)
1807  """
1808  return [Bool("%s__%s" % (prefix, i)) for i in range(sz)]
1809 
1810 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Bool
Definition: z3py.py:1768
def BoolVector
Definition: z3py.py:1796
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 4019 of file z3py.py.

4019 def BV2Int(a, is_signed=False):
4020  """Return the Z3 expression BV2Int(a).
4021 
4022  >>> b = BitVec('b', 3)
4023  >>> BV2Int(b).sort()
4024  Int
4025  >>> x = Int('x')
4026  >>> x > BV2Int(b)
4027  x > BV2Int(b)
4028  >>> x > BV2Int(b, is_signed=False)
4029  x > BV2Int(b)
4030  >>> x > BV2Int(b, is_signed=True)
4031  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
4032  >>> solve(x > BV2Int(b), b == 1, x < 3)
4033  [x = 2, b = 1]
4034  """
4035  if z3_debug():
4036  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4037  ctx = a.ctx
4038  # investigate problem with bv2int
4039  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
4040 
4041 
def BV2Int
Definition: z3py.py:4019
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:3990
def z3py.BVAddNoOverflow (   a,
  b,
  signed 
)
A predicate the determines that bit-vector addition does not overflow

Definition at line 4505 of file z3py.py.

4505 def BVAddNoOverflow(a, b, signed):
4506  """A predicate the determines that bit-vector addition does not overflow"""
4507  _check_bv_args(a, b)
4508  a, b = _coerce_exprs(a, b)
4509  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4510 
4511 
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4505
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 4512 of file z3py.py.

4513  """A predicate the determines that signed bit-vector addition does not underflow"""
4514  _check_bv_args(a, b)
4515  a, b = _coerce_exprs(a, b)
4516  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4517 
4518 
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4512
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 4547 of file z3py.py.

4547 def BVMulNoOverflow(a, b, signed):
4548  """A predicate the determines that bit-vector multiplication does not overflow"""
4549  _check_bv_args(a, b)
4550  a, b = _coerce_exprs(a, b)
4551  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4552 
4553 
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4547
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 4554 of file z3py.py.

4555  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4556  _check_bv_args(a, b)
4557  a, b = _coerce_exprs(a, b)
4558  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4559 
4560 
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:4554
def z3py.BVRedAnd (   a)
Return the reduction-and expression of `a`.

Definition at line 4491 of file z3py.py.

4491 def BVRedAnd(a):
4492  """Return the reduction-and expression of `a`."""
4493  if z3_debug():
4494  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4495  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4496 
4497 
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:4491
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3990
def z3py.BVRedOr (   a)
Return the reduction-or expression of `a`.

Definition at line 4498 of file z3py.py.

4498 def BVRedOr(a):
4499  """Return the reduction-or expression of `a`."""
4500  if z3_debug():
4501  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4502  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4503 
4504 
def BVRedOr(a)
Definition: z3py.py:4498
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:3990
def z3py.BVSDivNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector signed division does not overflow

Definition at line 4533 of file z3py.py.

4534  """A predicate the determines that bit-vector signed division does not overflow"""
4535  _check_bv_args(a, b)
4536  a, b = _coerce_exprs(a, b)
4537  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4538 
4539 
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4533
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 4540 of file z3py.py.

4541  """A predicate the determines that bit-vector unary negation does not overflow"""
4542  if z3_debug():
4543  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4544  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4545 
4546 
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:4540
def is_bv(a)
Definition: z3py.py:3990
def z3py.BVSubNoOverflow (   a,
  b 
)
A predicate the determines that bit-vector subtraction does not overflow

Definition at line 4519 of file z3py.py.

4520  """A predicate the determines that bit-vector subtraction does not overflow"""
4521  _check_bv_args(a, b)
4522  a, b = _coerce_exprs(a, b)
4523  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4524 
4525 
def BVSubNoOverflow(a, b)
Definition: z3py.py:4519
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 4526 of file z3py.py.

4526 def BVSubNoUnderflow(a, b, signed):
4527  """A predicate the determines that bit-vector subtraction does not underflow"""
4528  _check_bv_args(a, b)
4529  a, b = _coerce_exprs(a, b)
4530  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4531 
4532 
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4526
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 3470 of file z3py.py.

3470 def Cbrt(a, ctx=None):
3471  """ Return a Z3 expression which represents the cubic root of a.
3472 
3473  >>> x = Real('x')
3474  >>> Cbrt(x)
3475  x**(1/3)
3476  """
3477  if not is_expr(a):
3478  ctx = _get_ctx(ctx)
3479  a = RealVal(a, ctx)
3480  return a ** "1/3"
3481 
def Cbrt
Definition: z3py.py:3470
def RealVal
Definition: z3py.py:3246
def is_expr(a)
Definition: z3py.py:1260
def z3py.CharFromBv (   bv)

Definition at line 10972 of file z3py.py.

10972 def CharFromBv(bv):
10973  if not is_expr(bv):
10974  raise Z3Exception("Bit-vector expression needed")
10975  return _to_expr_ref(Z3_mk_char_from_bv(bv.ctx_ref(), bv.as_ast()), bv.ctx)
10976 
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 CharFromBv(bv)
Definition: z3py.py:10972
def is_expr(a)
Definition: z3py.py:1260
def z3py.CharIsDigit (   ch,
  ctx = None 
)

Definition at line 10985 of file z3py.py.

10985 def CharIsDigit(ch, ctx=None):
10986  ch = _coerce_char(ch, ctx)
10987  return ch.is_digit()
10988 
def CharIsDigit
Definition: z3py.py:10985
def z3py.CharSort (   ctx = None)
Create a character sort
>>> ch = CharSort()
>>> print(ch)
Char

Definition at line 10871 of file z3py.py.

10871 def CharSort(ctx=None):
10872  """Create a character sort
10873  >>> ch = CharSort()
10874  >>> print(ch)
10875  Char
10876  """
10877  ctx = _get_ctx(ctx)
10878  return CharSortRef(Z3_mk_char_sort(ctx.ref()), ctx)
10879 
10880 
def CharSort
Definition: z3py.py:10871
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 10977 of file z3py.py.

10977 def CharToBv(ch, ctx=None):
10978  ch = _coerce_char(ch, ctx)
10979  return ch.to_bv()
10980 
def CharToBv
Definition: z3py.py:10977
def z3py.CharToInt (   ch,
  ctx = None 
)

Definition at line 10981 of file z3py.py.

10981 def CharToInt(ch, ctx=None):
10982  ch = _coerce_char(ch, ctx)
10983  return ch.to_int()
10984 
def CharToInt
Definition: z3py.py:10981
def z3py.CharVal (   ch,
  ctx = None 
)

Definition at line 10964 of file z3py.py.

10964 def CharVal(ch, ctx=None):
10965  ctx = _get_ctx(ctx)
10966  if isinstance(ch, str):
10967  ch = ord(ch)
10968  if not isinstance(ch, int):
10969  raise Z3Exception("character value should be an ordinal")
10970  return _to_expr_ref(Z3_mk_char(ctx.ref(), ch), ctx)
10971 
Z3_ast Z3_API Z3_mk_char(Z3_context c, unsigned ch)
Create a character literal.
def CharVal
Definition: z3py.py:10964
def z3py.Complement (   re)
Create the complement regular expression.

Definition at line 11370 of file z3py.py.

11370 def Complement(re):
11371  """Create the complement regular expression."""
11372  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
11373 
11374 
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:11370
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 4128 of file z3py.py.

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

4128 def Concat(*args):
4129  """Create a Z3 bit-vector concatenation expression.
4130 
4131  >>> v = BitVecVal(1, 4)
4132  >>> Concat(v, v+1, v)
4133  Concat(Concat(1, 1 + 1), 1)
4134  >>> simplify(Concat(v, v+1, v))
4135  289
4136  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
4137  121
4138  """
4139  args = _get_args(args)
4140  sz = len(args)
4141  if z3_debug():
4142  _z3_assert(sz >= 2, "At least two arguments expected.")
4143 
4144  ctx = None
4145  for a in args:
4146  if is_expr(a):
4147  ctx = a.ctx
4148  break
4149  if is_seq(args[0]) or isinstance(args[0], str):
4150  args = [_coerce_seq(s, ctx) for s in args]
4151  if z3_debug():
4152  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
4153  v = (Ast * sz)()
4154  for i in range(sz):
4155  v[i] = args[i].as_ast()
4156  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
4157 
4158  if is_re(args[0]):
4159  if z3_debug():
4160  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
4161  v = (Ast * sz)()
4162  for i in range(sz):
4163  v[i] = args[i].as_ast()
4164  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
4165 
4166  if z3_debug():
4167  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
4168  r = args[0]
4169  for i in range(sz - 1):
4170  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i + 1].as_ast()), ctx)
4171  return r
4172 
4173 
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:11284
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
def is_bv(a)
Definition: z3py.py:3990
def Concat(args)
Definition: z3py.py:4128
def is_seq(a)
Definition: z3py.py:11010
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 8870 of file z3py.py.

Referenced by If().

8870 def Cond(p, t1, t2, ctx=None):
8871  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8872 
8873  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8874  """
8875  p = _to_probe(p, ctx)
8876  t1 = _to_tactic(t1, ctx)
8877  t2 = _to_tactic(t2, ctx)
8878  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8879 
def Cond
Definition: z3py.py:8870
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 1455 of file z3py.py.

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

1455 def Const(name, sort):
1456  """Create a constant of the given sort.
1457 
1458  >>> Const('x', IntSort())
1459  x
1460  """
1461  if z3_debug():
1462  _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1463  ctx = sort.ctx
1464  return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1465 
1466 
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:1455
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 1467 of file z3py.py.

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

1467 def Consts(names, sort):
1468  """Create several constants of the given sort.
1469 
1470  `names` is a string containing the names of all constants to be created.
1471  Blank spaces separate the names of different constants.
1472 
1473  >>> x, y, z = Consts('x y z', IntSort())
1474  >>> x + y + z
1475  x + y + z
1476  """
1477  if isinstance(names, str):
1478  names = names.split(" ")
1479  return [Const(name, sort) for name in names]
1480 
1481 
def Consts(names, sort)
Definition: z3py.py:1467
def Const(name, sort)
Definition: z3py.py:1455
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 11141 of file z3py.py.

11141 def Contains(a, b):
11142  """Check if 'a' contains 'b'
11143  >>> s1 = Contains("abc", "ab")
11144  >>> simplify(s1)
11145  True
11146  >>> s2 = Contains("abc", "bc")
11147  >>> simplify(s2)
11148  True
11149  >>> x, y, z = Strings('x y z')
11150  >>> s3 = Contains(Concat(x,y,z), y)
11151  >>> simplify(s3)
11152  True
11153  """
11154  ctx = _get_ctx2(a, b)
11155  a = _coerce_seq(a, ctx)
11156  b = _coerce_seq(b, ctx)
11157  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11158 
11159 
def Contains(a, b)
Definition: z3py.py:11141
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 5204 of file z3py.py.

Referenced by Datatype.create().

5205  """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
5206 
5207  In the following example we define a Tree-List using two mutually recursive datatypes.
5208 
5209  >>> TreeList = Datatype('TreeList')
5210  >>> Tree = Datatype('Tree')
5211  >>> # Tree has two constructors: leaf and node
5212  >>> Tree.declare('leaf', ('val', IntSort()))
5213  >>> # a node contains a list of trees
5214  >>> Tree.declare('node', ('children', TreeList))
5215  >>> TreeList.declare('nil')
5216  >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
5217  >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
5218  >>> Tree.val(Tree.leaf(10))
5219  val(leaf(10))
5220  >>> simplify(Tree.val(Tree.leaf(10)))
5221  10
5222  >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
5223  >>> n1
5224  node(cons(leaf(10), cons(leaf(20), nil)))
5225  >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
5226  >>> simplify(n2 == n1)
5227  False
5228  >>> simplify(TreeList.car(Tree.children(n2)) == n1)
5229  True
5230  """
5231  ds = _get_args(ds)
5232  if z3_debug():
5233  _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
5234  _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
5235  _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
5236  _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
5237  ctx = ds[0].ctx
5238  num = len(ds)
5239  names = (Symbol * num)()
5240  out = (Sort * num)()
5241  clists = (ConstructorList * num)()
5242  to_delete = []
5243  for i in range(num):
5244  d = ds[i]
5245  names[i] = to_symbol(d.name, ctx)
5246  num_cs = len(d.constructors)
5247  cs = (Constructor * num_cs)()
5248  for j in range(num_cs):
5249  c = d.constructors[j]
5250  cname = to_symbol(c[0], ctx)
5251  rname = to_symbol(c[1], ctx)
5252  fs = c[2]
5253  num_fs = len(fs)
5254  fnames = (Symbol * num_fs)()
5255  sorts = (Sort * num_fs)()
5256  refs = (ctypes.c_uint * num_fs)()
5257  for k in range(num_fs):
5258  fname = fs[k][0]
5259  ftype = fs[k][1]
5260  fnames[k] = to_symbol(fname, ctx)
5261  if isinstance(ftype, Datatype):
5262  if z3_debug():
5263  _z3_assert(
5264  ds.count(ftype) == 1,
5265  "One and only one occurrence of each datatype is expected",
5266  )
5267  sorts[k] = None
5268  refs[k] = ds.index(ftype)
5269  else:
5270  if z3_debug():
5271  _z3_assert(is_sort(ftype), "Z3 sort expected")
5272  sorts[k] = ftype.ast
5273  refs[k] = 0
5274  cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
5275  to_delete.append(ScopedConstructor(cs[j], ctx))
5276  clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
5277  to_delete.append(ScopedConstructorList(clists[i], ctx))
5278  Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
5279  result = []
5280  # Create a field for every constructor, recognizer and accessor
5281  for i in range(num):
5282  dref = DatatypeSortRef(out[i], ctx)
5283  num_cs = dref.num_constructors()
5284  for j in range(num_cs):
5285  cref = dref.constructor(j)
5286  cref_name = cref.name()
5287  cref_arity = cref.arity()
5288  if cref.arity() == 0:
5289  cref = cref()
5290  setattr(dref, cref_name, cref)
5291  rref = dref.recognizer(j)
5292  setattr(dref, "is_" + cref_name, rref)
5293  for k in range(cref_arity):
5294  aref = dref.accessor(j, k)
5295  setattr(dref, aref.name(), aref)
5296  result.append(dref)
5297  return tuple(result)
5298 
5299 
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:5204
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 5404 of file z3py.py.

5404 def DatatypeSort(name, ctx = None):
5405  """Create a reference to a sort that was declared, or will be declared, as a recursive datatype"""
5406  ctx = _get_ctx(ctx)
5407  return DatatypeSortRef(Z3_mk_datatype_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
5408 
def DatatypeSort
Definition: z3py.py:5404
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 695 of file z3py.py.

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

695 def DeclareSort(name, ctx=None):
696  """Create a new uninterpreted sort named `name`.
697 
698  If `ctx=None`, then the new sort is declared in the global Z3Py context.
699 
700  >>> A = DeclareSort('A')
701  >>> a = Const('a', A)
702  >>> b = Const('b', A)
703  >>> a.sort() == A
704  True
705  >>> b.sort() == A
706  True
707  >>> a == b
708  a == b
709  """
710  ctx = _get_ctx(ctx)
711  return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
712 
def DeclareSort
Definition: z3py.py:695
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.DeclareTypeVar (   name,
  ctx = None 
)
Create a new type variable named `name`.

If `ctx=None`, then the new sort is declared in the global Z3Py context.

Definition at line 723 of file z3py.py.

723 def DeclareTypeVar(name, ctx=None):
724  """Create a new type variable named `name`.
725 
726  If `ctx=None`, then the new sort is declared in the global Z3Py context.
727 
728  """
729  ctx = _get_ctx(ctx)
730  return TypeVarRef(Z3_mk_type_variable(ctx.ref(), to_symbol(name, ctx)), ctx)
731 
732 
def DeclareTypeVar
Definition: z3py.py:723
Z3_sort Z3_API Z3_mk_type_variable(Z3_context c, Z3_symbol s)
Create a type variable.
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 4825 of file z3py.py.

Referenced by is_default().

4825 def Default(a):
4826  """ Return a default value for array expression.
4827  >>> b = K(IntSort(), 1)
4828  >>> prove(Default(b) == 1)
4829  proved
4830  """
4831  if z3_debug():
4832  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4833  return a.default()
4834 
4835 
def is_array_sort(a)
Definition: z3py.py:4653
def Default(a)
Definition: z3py.py:4825
def z3_debug()
Definition: z3py.py:62
def z3py.describe_probes ( )
Display a (tabular) description of all available probes in Z3.

Definition at line 8791 of file z3py.py.

8792  """Display a (tabular) description of all available probes in Z3."""
8793  if in_html_mode():
8794  even = True
8795  print('<table border="1" cellpadding="2" cellspacing="0">')
8796  for p in probes():
8797  if even:
8798  print('<tr style="background-color:#CFCFCF">')
8799  even = False
8800  else:
8801  print("<tr>")
8802  even = True
8803  print("<td>%s</td><td>%s</td></tr>" % (p, insert_line_breaks(probe_description(p), 40)))
8804  print("</table>")
8805  else:
8806  for p in probes():
8807  print("%s : %s" % (p, probe_description(p)))
8808 
8809 
def probe_description
Definition: z3py.py:8782
def probes
Definition: z3py.py:8771
def describe_probes()
Definition: z3py.py:8791
def z3py.describe_tactics ( )
Display a (tabular) description of all available tactics in Z3.

Definition at line 8585 of file z3py.py.

8586  """Display a (tabular) description of all available tactics in Z3."""
8587  if in_html_mode():
8588  even = True
8589  print('<table border="1" cellpadding="2" cellspacing="0">')
8590  for t in tactics():
8591  if even:
8592  print('<tr style="background-color:#CFCFCF">')
8593  even = False
8594  else:
8595  print("<tr>")
8596  even = True
8597  print("<td>%s</td><td>%s</td></tr>" % (t, insert_line_breaks(tactic_description(t), 40)))
8598  print("</table>")
8599  else:
8600  for t in tactics():
8601  print("%s : %s" % (t, tactic_description(t)))
8602 
8603 
def describe_tactics()
Definition: z3py.py:8585
def tactic_description
Definition: z3py.py:8576
def tactics
Definition: z3py.py:8565
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 1137 of file z3py.py.

1137 def deserialize(st):
1138  """inverse function to the serialize method on ExprRef.
1139  It is made available to make it easier for users to serialize expressions back and forth between
1140  strings. Solvers can be serialized using the 'sexpr()' method.
1141  """
1142  s = Solver()
1143  s.from_string(st)
1144  if len(s.assertions()) != 1:
1145  raise Z3Exception("single assertion expected")
1146  fml = s.assertions()[0]
1147  if fml.num_args() != 1:
1148  raise Z3Exception("dummy function 'F' expected")
1149  return fml.arg(0)
1150 
def deserialize(st)
Definition: z3py.py:1137
def z3py.Diff (   a,
  b,
  ctx = None 
)
Create the difference regular expression

Definition at line 11420 of file z3py.py.

11420 def Diff(a, b, ctx=None):
11421  """Create the difference regular expression
11422  """
11423  if z3_debug():
11424  _z3_assert(is_expr(a), "expression expected")
11425  _z3_assert(is_expr(b), "expression expected")
11426  return ReRef(Z3_mk_re_diff(a.ctx_ref(), a.ast, b.ast), a.ctx)
11427 
def Diff
Definition: z3py.py:11420
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
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 5421 of file z3py.py.

5421 def DisjointSum(name, sorts, ctx=None):
5422  """Create a named tagged union sort base on a set of underlying sorts
5423  Example:
5424  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5425  """
5426  sum = Datatype(name, ctx)
5427  for i in range(len(sorts)):
5428  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5429  sum = sum.create()
5430  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5431 
5432 
def DisjointSum
Definition: z3py.py:5421
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 1422 of file z3py.py.

1422 def Distinct(*args):
1423  """Create a Z3 distinct expression.
1424 
1425  >>> x = Int('x')
1426  >>> y = Int('y')
1427  >>> Distinct(x, y)
1428  x != y
1429  >>> z = Int('z')
1430  >>> Distinct(x, y, z)
1431  Distinct(x, y, z)
1432  >>> simplify(Distinct(x, y, z))
1433  Distinct(x, y, z)
1434  >>> simplify(Distinct(x, y, z), blast_distinct=True)
1435  And(Not(x == y), Not(x == z), Not(y == z))
1436  """
1437  args = _get_args(args)
1438  ctx = _ctx_from_ast_arg_list(args)
1439  if z3_debug():
1440  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1441  args = _coerce_expr_list(args, ctx)
1442  _args, sz = _to_ast_array(args)
1443  return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1444 
1445 
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:1422
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 11071 of file z3py.py.

11071 def Empty(s):
11072  """Create the empty sequence of the given sort
11073  >>> e = Empty(StringSort())
11074  >>> e2 = StringVal("")
11075  >>> print(e.eq(e2))
11076  True
11077  >>> e3 = Empty(SeqSort(IntSort()))
11078  >>> print(e3)
11079  Empty(Seq(Int))
11080  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
11081  >>> print(e4)
11082  Empty(ReSort(Seq(Int)))
11083  """
11084  if isinstance(s, SeqSortRef):
11085  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
11086  if isinstance(s, ReSortRef):
11087  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
11088  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
11089 
11090 
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:11071
def z3py.EmptySet (   s)
Create the empty set
>>> EmptySet(IntSort())
K(Int, False)

Definition at line 4968 of file z3py.py.

4968 def EmptySet(s):
4969  """Create the empty set
4970  >>> EmptySet(IntSort())
4971  K(Int, False)
4972  """
4973  ctx = s.ctx
4974  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4975 
4976 
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
def EmptySet(s)
Definition: z3py.py:4968
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 11539 of file z3py.py.

11540  global _prop_closures
11541  if _prop_closures is None:
11542  _prop_closures = PropClosures()
11543 
11544 
def ensure_prop_closures()
Definition: z3py.py:11539
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 5433 of file z3py.py.

5433 def EnumSort(name, values, ctx=None):
5434  """Return a new enumeration sort named `name` containing the given values.
5435 
5436  The result is a pair (sort, list of constants).
5437  Example:
5438  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5439  """
5440  if z3_debug():
5441  _z3_assert(isinstance(name, str), "Name must be a string")
5442  _z3_assert(all([isinstance(v, str) for v in values]), "Enumeration sort values must be strings")
5443  _z3_assert(len(values) > 0, "At least one value expected")
5444  ctx = _get_ctx(ctx)
5445  num = len(values)
5446  _val_names = (Symbol * num)()
5447  for i in range(num):
5448  _val_names[i] = to_symbol(values[i])
5449  _values = (FuncDecl * num)()
5450  _testers = (FuncDecl * num)()
5451  name = to_symbol(name)
5452  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5453  V = []
5454  for i in range(num):
5455  V.append(FuncDeclRef(_values[i], ctx))
5456  V = [a() for a in V]
5457  return S, V
5458 
Function Declarations.
Definition: z3py.py:740
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def EnumSort
Definition: z3py.py:5433
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 2290 of file z3py.py.

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

2290 def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2291  """Create a Z3 exists formula.
2292 
2293  The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2294 
2295 
2296  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2297  >>> x = Int('x')
2298  >>> y = Int('y')
2299  >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2300  >>> q
2301  Exists([x, y], f(x, y) >= x)
2302  >>> is_quantifier(q)
2303  True
2304  >>> r = Tactic('nnf')(q).as_expr()
2305  >>> is_quantifier(r)
2306  False
2307  """
2308  return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2309 
2310 
def Exists
Definition: z3py.py:2290
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 4914 of file z3py.py.

4914 def Ext(a, b):
4915  """Return extensionality index for one-dimensional arrays.
4916  >> a, b = Consts('a b', SetSort(IntSort()))
4917  >> Ext(a, b)
4918  Ext(a, b)
4919  """
4920  ctx = a.ctx
4921  if z3_debug():
4922  _z3_assert(is_array_sort(a) and (is_array(b) or b.is_lambda()), "arguments must be arrays")
4923  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4924 
4925 
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:4653
def is_array(a)
Definition: z3py.py:4657
def z3_debug()
Definition: z3py.py:62
def Ext(a, b)
Definition: z3py.py:4914
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 4174 of file z3py.py.

4174 def Extract(high, low, a):
4175  """Create a Z3 bit-vector extraction expression.
4176  Extract is overloaded to also work on sequence extraction.
4177  The functions SubString and SubSeq are redirected to Extract.
4178  For this case, the arguments are reinterpreted as:
4179  high - is a sequence (string)
4180  low - is an offset
4181  a - is the length to be extracted
4182 
4183  >>> x = BitVec('x', 8)
4184  >>> Extract(6, 2, x)
4185  Extract(6, 2, x)
4186  >>> Extract(6, 2, x).sort()
4187  BitVec(5)
4188  >>> simplify(Extract(StringVal("abcd"),2,1))
4189  "c"
4190  """
4191  if isinstance(high, str):
4192  high = StringVal(high)
4193  if is_seq(high):
4194  s = high
4195  offset, length = _coerce_exprs(low, a, s.ctx)
4196  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
4197  if z3_debug():
4198  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
4199  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0,
4200  "First and second arguments must be non negative integers")
4201  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
4202  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
4203 
4204 
def StringVal
Definition: z3py.py:11037
def Extract(high, low, a)
Definition: z3py.py:4174
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:3990
def is_seq(a)
Definition: z3py.py:11010
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 8828 of file z3py.py.

8828 def FailIf(p, ctx=None):
8829  """Return a tactic that fails if the probe `p` evaluates to true.
8830  Otherwise, it returns the input goal unmodified.
8831 
8832  In the following example, the tactic applies 'simplify' if and only if there are
8833  more than 2 constraints in the goal.
8834 
8835  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8836  >>> x, y = Ints('x y')
8837  >>> g = Goal()
8838  >>> g.add(x > 0)
8839  >>> g.add(y > 0)
8840  >>> t(g)
8841  [[x > 0, y > 0]]
8842  >>> g.add(x == y + 1)
8843  >>> t(g)
8844  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8845  """
8846  p = _to_probe(p, ctx)
8847  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8848 
8849 
def FailIf
Definition: z3py.py:8828
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 7776 of file z3py.py.

7776 def FiniteDomainSort(name, sz, ctx=None):
7777  """Create a named finite domain sort of a given size sz"""
7778  if not isinstance(name, Symbol):
7779  name = to_symbol(name)
7780  ctx = _get_ctx(ctx)
7781  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7782 
7783 
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:7776
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 7846 of file z3py.py.

7846 def FiniteDomainVal(val, sort, ctx=None):
7847  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7848 
7849  >>> s = FiniteDomainSort('S', 256)
7850  >>> FiniteDomainVal(255, s)
7851  255
7852  >>> FiniteDomainVal('100', s)
7853  100
7854  """
7855  if z3_debug():
7856  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort")
7857  ctx = sort.ctx
7858  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7859 
7860 
def FiniteDomainVal
Definition: z3py.py:7846
def is_finite_domain_sort(s)
Definition: z3py.py:7784
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 9556 of file z3py.py.

9556 def Float128(ctx=None):
9557  """Floating-point 128-bit (quadruple) sort."""
9558  ctx = _get_ctx(ctx)
9559  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
9560 
9561 
def Float128
Definition: z3py.py:9556
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 9520 of file z3py.py.

9520 def Float16(ctx=None):
9521  """Floating-point 16-bit (half) sort."""
9522  ctx = _get_ctx(ctx)
9523  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
9524 
9525 
def Float16
Definition: z3py.py:9520
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 9532 of file z3py.py.

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

9532 def Float32(ctx=None):
9533  """Floating-point 32-bit (single) sort."""
9534  ctx = _get_ctx(ctx)
9535  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
9536 
9537 
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:9532
def z3py.Float64 (   ctx = None)
Floating-point 64-bit (double) sort.

Definition at line 9544 of file z3py.py.

Referenced by fpFPToFP(), and fpToFP().

9544 def Float64(ctx=None):
9545  """Floating-point 64-bit (double) sort."""
9546  ctx = _get_ctx(ctx)
9547  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
9548 
9549 
def Float64
Definition: z3py.py:9544
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 9550 of file z3py.py.

9550 def FloatDouble(ctx=None):
9551  """Floating-point 64-bit (double) sort."""
9552  ctx = _get_ctx(ctx)
9553  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
9554 
9555 
def FloatDouble
Definition: z3py.py:9550
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 9526 of file z3py.py.

9526 def FloatHalf(ctx=None):
9527  """Floating-point 16-bit (half) sort."""
9528  ctx = _get_ctx(ctx)
9529  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
9530 
9531 
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:9526
def z3py.FloatQuadruple (   ctx = None)
Floating-point 128-bit (quadruple) sort.

Definition at line 9562 of file z3py.py.

9562 def FloatQuadruple(ctx=None):
9563  """Floating-point 128-bit (quadruple) sort."""
9564  ctx = _get_ctx(ctx)
9565  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
9566 
9567 
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:9562
def z3py.FloatSingle (   ctx = None)
Floating-point 32-bit (single) sort.

Definition at line 9538 of file z3py.py.

9538 def FloatSingle(ctx=None):
9539  """Floating-point 32-bit (single) sort."""
9540  ctx = _get_ctx(ctx)
9541  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
9542 
9543 
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:9538
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 2272 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().

2272 def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2273  """Create a Z3 forall formula.
2274 
2275  The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2276 
2277  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2278  >>> x = Int('x')
2279  >>> y = Int('y')
2280  >>> ForAll([x, y], f(x, y) >= x)
2281  ForAll([x, y], f(x, y) >= x)
2282  >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2283  ForAll([x, y], f(x, y) >= x)
2284  >>> ForAll([x, y], f(x, y) >= x, weight=10)
2285  ForAll([x, y], f(x, y) >= x)
2286  """
2287  return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2288 
2289 
def ForAll
Definition: z3py.py:2272
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 10188 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().

10188 def FP(name, fpsort, ctx=None):
10189  """Return a floating-point constant named `name`.
10190  `fpsort` is the floating-point sort.
10191  If `ctx=None`, then the global context is used.
10192 
10193  >>> x = FP('x', FPSort(8, 24))
10194  >>> is_fp(x)
10195  True
10196  >>> x.ebits()
10197  8
10198  >>> x.sort()
10199  FPSort(8, 24)
10200  >>> word = FPSort(8, 24)
10201  >>> x2 = FP('x', word)
10202  >>> eq(x, x2)
10203  True
10204  """
10205  if isinstance(fpsort, FPSortRef) and ctx is None:
10206  ctx = fpsort.ctx
10207  else:
10208  ctx = _get_ctx(ctx)
10209  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
10210 
10211 
def FP
Definition: z3py.py:10188
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 10231 of file z3py.py.

10231 def fpAbs(a, ctx=None):
10232  """Create a Z3 floating-point absolute value expression.
10233 
10234  >>> s = FPSort(8, 24)
10235  >>> rm = RNE()
10236  >>> x = FPVal(1.0, s)
10237  >>> fpAbs(x)
10238  fpAbs(1)
10239  >>> y = FPVal(-20.0, s)
10240  >>> y
10241  -1.25*(2**4)
10242  >>> fpAbs(y)
10243  fpAbs(-1.25*(2**4))
10244  >>> fpAbs(-1.25*(2**4))
10245  fpAbs(-1.25*(2**4))
10246  >>> fpAbs(x).sort()
10247  FPSort(8, 24)
10248  """
10249  ctx = _get_ctx(ctx)
10250  [a] = _coerce_fp_expr_list([a], ctx)
10251  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
10252 
10253 
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
def fpAbs
Definition: z3py.py:10231
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 10322 of file z3py.py.

Referenced by FPs().

10322 def fpAdd(rm, a, b, ctx=None):
10323  """Create a Z3 floating-point addition expression.
10324 
10325  >>> s = FPSort(8, 24)
10326  >>> rm = RNE()
10327  >>> x = FP('x', s)
10328  >>> y = FP('y', s)
10329  >>> fpAdd(rm, x, y)
10330  x + y
10331  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
10332  fpAdd(RTZ(), x, y)
10333  >>> fpAdd(rm, x, y).sort()
10334  FPSort(8, 24)
10335  """
10336  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
10337 
10338 
def fpAdd
Definition: z3py.py:10322
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 10644 of file z3py.py.

10644 def fpBVToFP(v, sort, ctx=None):
10645  """Create a Z3 floating-point conversion expression that represents the
10646  conversion from a bit-vector term to a floating-point term.
10647 
10648  >>> x_bv = BitVecVal(0x3F800000, 32)
10649  >>> x_fp = fpBVToFP(x_bv, Float32())
10650  >>> x_fp
10651  fpToFP(1065353216)
10652  >>> simplify(x_fp)
10653  1
10654  """
10655  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
10656  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
10657  ctx = _get_ctx(ctx)
10658  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
10659 
10660 
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:10644
def is_fp_sort(s)
Definition: z3py.py:9572
def is_bv(a)
Definition: z3py.py:3990
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 10369 of file z3py.py.

10369 def fpDiv(rm, a, b, ctx=None):
10370  """Create a Z3 floating-point division expression.
10371 
10372  >>> s = FPSort(8, 24)
10373  >>> rm = RNE()
10374  >>> x = FP('x', s)
10375  >>> y = FP('y', s)
10376  >>> fpDiv(rm, x, y)
10377  x / y
10378  >>> fpDiv(rm, x, y).sort()
10379  FPSort(8, 24)
10380  """
10381  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
10382 
10383 
def fpDiv
Definition: z3py.py:10369
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 10552 of file z3py.py.

Referenced by fpFP(), and fpNEQ().

10552 def fpEQ(a, b, ctx=None):
10553  """Create the Z3 floating-point expression `fpEQ(other, self)`.
10554 
10555  >>> x, y = FPs('x y', FPSort(8, 24))
10556  >>> fpEQ(x, y)
10557  fpEQ(x, y)
10558  >>> fpEQ(x, y).sexpr()
10559  '(fp.eq x y)'
10560  """
10561  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
10562 
10563 
def fpEQ
Definition: z3py.py:10552
def z3py.fpFMA (   rm,
  a,
  b,
  c,
  ctx = None 
)
Create a Z3 floating-point fused multiply-add expression.

Definition at line 10428 of file z3py.py.

10428 def fpFMA(rm, a, b, c, ctx=None):
10429  """Create a Z3 floating-point fused multiply-add expression.
10430  """
10431  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
10432 
10433 
def fpFMA
Definition: z3py.py:10428
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 10576 of file z3py.py.

10576 def fpFP(sgn, exp, sig, ctx=None):
10577  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
10578 
10579  >>> s = FPSort(8, 24)
10580  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
10581  >>> print(x)
10582  fpFP(1, 127, 4194304)
10583  >>> xv = FPVal(-1.5, s)
10584  >>> print(xv)
10585  -1.5
10586  >>> slvr = Solver()
10587  >>> slvr.add(fpEQ(x, xv))
10588  >>> slvr.check()
10589  sat
10590  >>> xv = FPVal(+1.5, s)
10591  >>> print(xv)
10592  1.5
10593  >>> slvr = Solver()
10594  >>> slvr.add(fpEQ(x, xv))
10595  >>> slvr.check()
10596  unsat
10597  """
10598  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
10599  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
10600  ctx = _get_ctx(ctx)
10601  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
10602  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
10603 
10604 
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:10576
def is_bv(a)
Definition: z3py.py:3990
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 10661 of file z3py.py.

10661 def fpFPToFP(rm, v, sort, ctx=None):
10662  """Create a Z3 floating-point conversion expression that represents the
10663  conversion from a floating-point term to a floating-point term of different precision.
10664 
10665  >>> x_sgl = FPVal(1.0, Float32())
10666  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
10667  >>> x_dbl
10668  fpToFP(RNE(), 1)
10669  >>> simplify(x_dbl)
10670  1
10671  >>> x_dbl.sort()
10672  FPSort(11, 53)
10673  """
10674  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10675  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
10676  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10677  ctx = _get_ctx(ctx)
10678  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10679 
10680 
def fpFPToFP
Definition: z3py.py:10661
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:9572
def is_fprm(a)
Definition: z3py.py:9832
def is_fp(a)
Definition: z3py.py:9988
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 10540 of file z3py.py.

10540 def fpGEQ(a, b, ctx=None):
10541  """Create the Z3 floating-point expression `other >= self`.
10542 
10543  >>> x, y = FPs('x y', FPSort(8, 24))
10544  >>> fpGEQ(x, y)
10545  x >= y
10546  >>> (x >= y).sexpr()
10547  '(fp.geq x y)'
10548  """
10549  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
10550 
10551 
def fpGEQ
Definition: z3py.py:10540
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 10528 of file z3py.py.

10528 def fpGT(a, b, ctx=None):
10529  """Create the Z3 floating-point expression `other > self`.
10530 
10531  >>> x, y = FPs('x y', FPSort(8, 24))
10532  >>> fpGT(x, y)
10533  x > y
10534  >>> (x > y).sexpr()
10535  '(fp.gt x y)'
10536  """
10537  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
10538 
10539 
def fpGT
Definition: z3py.py:10528
def z3py.fpInfinity (   s,
  negative 
)
Create a Z3 floating-point +oo or -oo term.

Definition at line 10116 of file z3py.py.

10116 def fpInfinity(s, negative):
10117  """Create a Z3 floating-point +oo or -oo term."""
10118  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10119  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10120  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
10121 
10122 
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:10116
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 10458 of file z3py.py.

10458 def fpIsInf(a, ctx=None):
10459  """Create a Z3 floating-point isInfinite expression.
10460 
10461  >>> s = FPSort(8, 24)
10462  >>> x = FP('x', s)
10463  >>> fpIsInf(x)
10464  fpIsInf(x)
10465  """
10466  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
10467 
10468 
def fpIsInf
Definition: z3py.py:10458
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 10446 of file z3py.py.

10446 def fpIsNaN(a, ctx=None):
10447  """Create a Z3 floating-point isNaN expression.
10448 
10449  >>> s = FPSort(8, 24)
10450  >>> x = FP('x', s)
10451  >>> y = FP('y', s)
10452  >>> fpIsNaN(x)
10453  fpIsNaN(x)
10454  """
10455  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
10456 
10457 
def fpIsNaN
Definition: z3py.py:10446
def z3py.fpIsNegative (   a,
  ctx = None 
)
Create a Z3 floating-point isNegative expression.

Definition at line 10487 of file z3py.py.

10487 def fpIsNegative(a, ctx=None):
10488  """Create a Z3 floating-point isNegative expression.
10489  """
10490  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
10491 
10492 
def fpIsNegative
Definition: z3py.py:10487
def z3py.fpIsNormal (   a,
  ctx = None 
)
Create a Z3 floating-point isNormal expression.

Definition at line 10475 of file z3py.py.

10475 def fpIsNormal(a, ctx=None):
10476  """Create a Z3 floating-point isNormal expression.
10477  """
10478  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
10479 
10480 
def fpIsNormal
Definition: z3py.py:10475
def z3py.fpIsPositive (   a,
  ctx = None 
)
Create a Z3 floating-point isPositive expression.

Definition at line 10493 of file z3py.py.

10493 def fpIsPositive(a, ctx=None):
10494  """Create a Z3 floating-point isPositive expression.
10495  """
10496  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
10497 
10498 
def fpIsPositive
Definition: z3py.py:10493
def z3py.fpIsSubnormal (   a,
  ctx = None 
)
Create a Z3 floating-point isSubnormal expression.

Definition at line 10481 of file z3py.py.

10481 def fpIsSubnormal(a, ctx=None):
10482  """Create a Z3 floating-point isSubnormal expression.
10483  """
10484  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
10485 
10486 
def fpIsSubnormal
Definition: z3py.py:10481
def z3py.fpIsZero (   a,
  ctx = None 
)
Create a Z3 floating-point isZero expression.

Definition at line 10469 of file z3py.py.

10469 def fpIsZero(a, ctx=None):
10470  """Create a Z3 floating-point isZero expression.
10471  """
10472  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
10473 
10474 
def fpIsZero
Definition: z3py.py:10469
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 10516 of file z3py.py.

10516 def fpLEQ(a, b, ctx=None):
10517  """Create the Z3 floating-point expression `other <= self`.
10518 
10519  >>> x, y = FPs('x y', FPSort(8, 24))
10520  >>> fpLEQ(x, y)
10521  x <= y
10522  >>> (x <= y).sexpr()
10523  '(fp.leq x y)'
10524  """
10525  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
10526 
10527 
def fpLEQ
Definition: z3py.py:10516
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 10504 of file z3py.py.

10504 def fpLT(a, b, ctx=None):
10505  """Create the Z3 floating-point expression `other < self`.
10506 
10507  >>> x, y = FPs('x y', FPSort(8, 24))
10508  >>> fpLT(x, y)
10509  x < y
10510  >>> (x < y).sexpr()
10511  '(fp.lt x y)'
10512  """
10513  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
10514 
10515 
def fpLT
Definition: z3py.py:10504
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 10413 of file z3py.py.

10413 def fpMax(a, b, ctx=None):
10414  """Create a Z3 floating-point maximum expression.
10415 
10416  >>> s = FPSort(8, 24)
10417  >>> rm = RNE()
10418  >>> x = FP('x', s)
10419  >>> y = FP('y', s)
10420  >>> fpMax(x, y)
10421  fpMax(x, y)
10422  >>> fpMax(x, y).sort()
10423  FPSort(8, 24)
10424  """
10425  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
10426 
10427 
def fpMax
Definition: z3py.py:10413
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 10398 of file z3py.py.

10398 def fpMin(a, b, ctx=None):
10399  """Create a Z3 floating-point minimum expression.
10400 
10401  >>> s = FPSort(8, 24)
10402  >>> rm = RNE()
10403  >>> x = FP('x', s)
10404  >>> y = FP('y', s)
10405  >>> fpMin(x, y)
10406  fpMin(x, y)
10407  >>> fpMin(x, y).sort()
10408  FPSort(8, 24)
10409  """
10410  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
10411 
10412 
def fpMin
Definition: z3py.py:10398
def z3py.fpMinusInfinity (   s)
Create a Z3 floating-point -oo term.

Definition at line 10110 of file z3py.py.

10111  """Create a Z3 floating-point -oo term."""
10112  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10113  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
10114 
10115 
def fpMinusInfinity(s)
Definition: z3py.py:10110
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 10129 of file z3py.py.

10130  """Create a Z3 floating-point -0.0 term."""
10131  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10132  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
10133 
10134 
def fpMinusZero(s)
Definition: z3py.py:10129
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 10354 of file z3py.py.

Referenced by FPs().

10354 def fpMul(rm, a, b, ctx=None):
10355  """Create a Z3 floating-point multiplication expression.
10356 
10357  >>> s = FPSort(8, 24)
10358  >>> rm = RNE()
10359  >>> x = FP('x', s)
10360  >>> y = FP('y', s)
10361  >>> fpMul(rm, x, y)
10362  x * y
10363  >>> fpMul(rm, x, y).sort()
10364  FPSort(8, 24)
10365  """
10366  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
10367 
10368 
def fpMul
Definition: z3py.py:10354
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 10076 of file z3py.py.

10076 def fpNaN(s):
10077  """Create a Z3 floating-point NaN term.
10078 
10079  >>> s = FPSort(8, 24)
10080  >>> set_fpa_pretty(True)
10081  >>> fpNaN(s)
10082  NaN
10083  >>> pb = get_fpa_pretty()
10084  >>> set_fpa_pretty(False)
10085  >>> fpNaN(s)
10086  fpNaN(FPSort(8, 24))
10087  >>> set_fpa_pretty(pb)
10088  """
10089  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10090  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
10091 
10092 
def fpNaN(s)
Definition: z3py.py:10076
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 10254 of file z3py.py.

10254 def fpNeg(a, 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  >>> fpNeg(x)
10261  -x
10262  >>> fpNeg(x).sort()
10263  FPSort(8, 24)
10264  """
10265  ctx = _get_ctx(ctx)
10266  [a] = _coerce_fp_expr_list([a], ctx)
10267  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
10268 
10269 
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
def fpNeg
Definition: z3py.py:10254
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 10564 of file z3py.py.

10564 def fpNEQ(a, b, ctx=None):
10565  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
10566 
10567  >>> x, y = FPs('x y', FPSort(8, 24))
10568  >>> fpNEQ(x, y)
10569  Not(fpEQ(x, y))
10570  >>> (x != y).sexpr()
10571  '(distinct x y)'
10572  """
10573  return Not(fpEQ(a, b, ctx))
10574 
10575 
def Not
Definition: z3py.py:1855
def fpEQ
Definition: z3py.py:10552
def fpNEQ
Definition: z3py.py:10564
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 10093 of file z3py.py.

10094  """Create a Z3 floating-point +oo term.
10095 
10096  >>> s = FPSort(8, 24)
10097  >>> pb = get_fpa_pretty()
10098  >>> set_fpa_pretty(True)
10099  >>> fpPlusInfinity(s)
10100  +oo
10101  >>> set_fpa_pretty(False)
10102  >>> fpPlusInfinity(s)
10103  fpPlusInfinity(FPSort(8, 24))
10104  >>> set_fpa_pretty(pb)
10105  """
10106  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10107  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
10108 
10109 
def fpPlusInfinity(s)
Definition: z3py.py:10093
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 10123 of file z3py.py.

10123 def fpPlusZero(s):
10124  """Create a Z3 floating-point +0.0 term."""
10125  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10126  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
10127 
10128 
def fpPlusZero(s)
Definition: z3py.py:10123
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 10681 of file z3py.py.

10681 def fpRealToFP(rm, v, sort, ctx=None):
10682  """Create a Z3 floating-point conversion expression that represents the
10683  conversion from a real term to a floating-point term.
10684 
10685  >>> x_r = RealVal(1.5)
10686  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
10687  >>> x_fp
10688  fpToFP(RNE(), 3/2)
10689  >>> simplify(x_fp)
10690  1.5
10691  """
10692  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10693  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
10694  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10695  ctx = _get_ctx(ctx)
10696  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10697 
10698 
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:2755
def fpRealToFP
Definition: z3py.py:10681
def is_fp_sort(s)
Definition: z3py.py:9572
def is_fprm(a)
Definition: z3py.py:9832
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 10384 of file z3py.py.

10384 def fpRem(a, b, ctx=None):
10385  """Create a Z3 floating-point remainder expression.
10386 
10387  >>> s = FPSort(8, 24)
10388  >>> x = FP('x', s)
10389  >>> y = FP('y', s)
10390  >>> fpRem(x, y)
10391  fpRem(x, y)
10392  >>> fpRem(x, y).sort()
10393  FPSort(8, 24)
10394  """
10395  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
10396 
10397 
def fpRem
Definition: z3py.py:10384
def z3py.fpRoundToIntegral (   rm,
  a,
  ctx = None 
)
Create a Z3 floating-point roundToIntegral expression.

Definition at line 10440 of file z3py.py.

10440 def fpRoundToIntegral(rm, a, ctx=None):
10441  """Create a Z3 floating-point roundToIntegral expression.
10442  """
10443  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
10444 
10445 
def fpRoundToIntegral
Definition: z3py.py:10440
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 10212 of file z3py.py.

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

10212 def FPs(names, fpsort, ctx=None):
10213  """Return an array of floating-point constants.
10214 
10215  >>> x, y, z = FPs('x y z', FPSort(8, 24))
10216  >>> x.sort()
10217  FPSort(8, 24)
10218  >>> x.sbits()
10219  24
10220  >>> x.ebits()
10221  8
10222  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
10223  x + y * z
10224  """
10225  ctx = _get_ctx(ctx)
10226  if isinstance(names, str):
10227  names = names.split(" ")
10228  return [FP(name, fpsort, ctx) for name in names]
10229 
10230 
def FP
Definition: z3py.py:10188
def FPs
Definition: z3py.py:10212
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 10699 of file z3py.py.

10699 def fpSignedToFP(rm, v, sort, ctx=None):
10700  """Create a Z3 floating-point conversion expression that represents the
10701  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
10702 
10703  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10704  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
10705  >>> x_fp
10706  fpToFP(RNE(), 4294967291)
10707  >>> simplify(x_fp)
10708  -1.25*(2**2)
10709  """
10710  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10711  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10712  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10713  ctx = _get_ctx(ctx)
10714  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10715 
10716 
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:10699
def is_fp_sort(s)
Definition: z3py.py:9572
def is_bv(a)
Definition: z3py.py:3990
def is_fprm(a)
Definition: z3py.py:9832
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 10017 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().

10017 def FPSort(ebits, sbits, ctx=None):
10018  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
10019 
10020  >>> Single = FPSort(8, 24)
10021  >>> Double = FPSort(11, 53)
10022  >>> Single
10023  FPSort(8, 24)
10024  >>> x = Const('x', Single)
10025  >>> eq(x, FP('x', FPSort(8, 24)))
10026  True
10027  """
10028  ctx = _get_ctx(ctx)
10029  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
10030 
10031 
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
def FPSort
Definition: z3py.py:10017
def z3py.fpSqrt (   rm,
  a,
  ctx = None 
)
Create a Z3 floating-point square root expression.

Definition at line 10434 of file z3py.py.

10434 def fpSqrt(rm, a, ctx=None):
10435  """Create a Z3 floating-point square root expression.
10436  """
10437  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
10438 
10439 
def fpSqrt
Definition: z3py.py:10434
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 10339 of file z3py.py.

10339 def fpSub(rm, a, b, ctx=None):
10340  """Create a Z3 floating-point subtraction expression.
10341 
10342  >>> s = FPSort(8, 24)
10343  >>> rm = RNE()
10344  >>> x = FP('x', s)
10345  >>> y = FP('y', s)
10346  >>> fpSub(rm, x, y)
10347  x - y
10348  >>> fpSub(rm, x, y).sort()
10349  FPSort(8, 24)
10350  """
10351  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
10352 
10353 
def fpSub
Definition: z3py.py:10339
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 10605 of file z3py.py.

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

10605 def fpToFP(a1, a2=None, a3=None, ctx=None):
10606  """Create a Z3 floating-point conversion expression from other term sorts
10607  to floating-point.
10608 
10609  From a bit-vector term in IEEE 754-2008 format:
10610  >>> x = FPVal(1.0, Float32())
10611  >>> x_bv = fpToIEEEBV(x)
10612  >>> simplify(fpToFP(x_bv, Float32()))
10613  1
10614 
10615  From a floating-point term with different precision:
10616  >>> x = FPVal(1.0, Float32())
10617  >>> x_db = fpToFP(RNE(), x, Float64())
10618  >>> x_db.sort()
10619  FPSort(11, 53)
10620 
10621  From a real term:
10622  >>> x_r = RealVal(1.5)
10623  >>> simplify(fpToFP(RNE(), x_r, Float32()))
10624  1.5
10625 
10626  From a signed bit-vector term:
10627  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10628  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
10629  -1.25*(2**2)
10630  """
10631  ctx = _get_ctx(ctx)
10632  if is_bv(a1) and is_fp_sort(a2):
10633  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
10634  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
10635  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10636  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
10637  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10638  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
10639  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
10640  else:
10641  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
10642 
10643 
def fpToFP
Definition: z3py.py:10605
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:2755
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:9572
def is_bv(a)
Definition: z3py.py:3990
def is_fprm(a)
Definition: z3py.py:9832
def is_fp(a)
Definition: z3py.py:9988
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 10735 of file z3py.py.

Referenced by fpUnsignedToFP().

10735 def fpToFPUnsigned(rm, x, s, ctx=None):
10736  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
10737  if z3_debug():
10738  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10739  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
10740  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
10741  ctx = _get_ctx(ctx)
10742  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
10743 
10744 
def fpToFPUnsigned
Definition: z3py.py:10735
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:9572
def is_bv(a)
Definition: z3py.py:3990
def is_fprm(a)
Definition: z3py.py:9832
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 10809 of file z3py.py.

Referenced by fpToFP().

10809 def fpToIEEEBV(x, ctx=None):
10810  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
10811 
10812  The size of the resulting bit-vector is automatically determined.
10813 
10814  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
10815  knows only one NaN and it will always produce the same bit-vector representation of
10816  that NaN.
10817 
10818  >>> x = FP('x', FPSort(8, 24))
10819  >>> y = fpToIEEEBV(x)
10820  >>> print(is_fp(x))
10821  True
10822  >>> print(is_bv(y))
10823  True
10824  >>> print(is_fp(y))
10825  False
10826  >>> print(is_bv(x))
10827  False
10828  """
10829  if z3_debug():
10830  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10831  ctx = _get_ctx(ctx)
10832  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10833 
10834 
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:10809
def is_fp(a)
Definition: z3py.py:9988
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 10789 of file z3py.py.

10789 def fpToReal(x, ctx=None):
10790  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
10791 
10792  >>> x = FP('x', FPSort(8, 24))
10793  >>> y = fpToReal(x)
10794  >>> print(is_fp(x))
10795  True
10796  >>> print(is_real(y))
10797  True
10798  >>> print(is_fp(y))
10799  False
10800  >>> print(is_real(x))
10801  False
10802  """
10803  if z3_debug():
10804  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
10805  ctx = _get_ctx(ctx)
10806  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
10807 
10808 
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:10789
def is_fp(a)
Definition: z3py.py:9988
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 10745 of file z3py.py.

10745 def fpToSBV(rm, x, s, ctx=None):
10746  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
10747 
10748  >>> x = FP('x', FPSort(8, 24))
10749  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
10750  >>> print(is_fp(x))
10751  True
10752  >>> print(is_bv(y))
10753  True
10754  >>> print(is_fp(y))
10755  False
10756  >>> print(is_bv(x))
10757  False
10758  """
10759  if z3_debug():
10760  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10761  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10762  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10763  ctx = _get_ctx(ctx)
10764  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10765 
10766 
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:10745
def z3_debug()
Definition: z3py.py:62
def is_bv_sort(s)
Definition: z3py.py:3522
def is_fprm(a)
Definition: z3py.py:9832
def is_fp(a)
Definition: z3py.py:9988
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 10767 of file z3py.py.

10767 def fpToUBV(rm, x, s, ctx=None):
10768  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
10769 
10770  >>> x = FP('x', FPSort(8, 24))
10771  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
10772  >>> print(is_fp(x))
10773  True
10774  >>> print(is_bv(y))
10775  True
10776  >>> print(is_fp(y))
10777  False
10778  >>> print(is_bv(x))
10779  False
10780  """
10781  if z3_debug():
10782  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
10783  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
10784  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
10785  ctx = _get_ctx(ctx)
10786  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
10787 
10788 
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:3522
def fpToUBV
Definition: z3py.py:10767
def is_fprm(a)
Definition: z3py.py:9832
def is_fp(a)
Definition: z3py.py:9988
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 10717 of file z3py.py.

10717 def fpUnsignedToFP(rm, v, sort, ctx=None):
10718  """Create a Z3 floating-point conversion expression that represents the
10719  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
10720 
10721  >>> x_signed = BitVecVal(-5, BitVecSort(32))
10722  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
10723  >>> x_fp
10724  fpToFPUnsigned(RNE(), 4294967291)
10725  >>> simplify(x_fp)
10726  1*(2**32)
10727  """
10728  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
10729  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
10730  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
10731  ctx = _get_ctx(ctx)
10732  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
10733 
10734 
def fpUnsignedToFP
Definition: z3py.py:10717
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:9572
def is_bv(a)
Definition: z3py.py:3990
def is_fprm(a)
Definition: z3py.py:9832
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 10142 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().

10142 def FPVal(sig, exp=None, fps=None, ctx=None):
10143  """Return a floating-point value of value `val` and sort `fps`.
10144  If `ctx=None`, then the global context is used.
10145 
10146  >>> v = FPVal(20.0, FPSort(8, 24))
10147  >>> v
10148  1.25*(2**4)
10149  >>> print("0x%.8x" % v.exponent_as_long(False))
10150  0x00000004
10151  >>> v = FPVal(2.25, FPSort(8, 24))
10152  >>> v
10153  1.125*(2**1)
10154  >>> v = FPVal(-2.25, FPSort(8, 24))
10155  >>> v
10156  -1.125*(2**1)
10157  >>> FPVal(-0.0, FPSort(8, 24))
10158  -0.0
10159  >>> FPVal(0.0, FPSort(8, 24))
10160  +0.0
10161  >>> FPVal(+0.0, FPSort(8, 24))
10162  +0.0
10163  """
10164  ctx = _get_ctx(ctx)
10165  if is_fp_sort(exp):
10166  fps = exp
10167  exp = None
10168  elif fps is None:
10169  fps = _dflt_fps(ctx)
10170  _z3_assert(is_fp_sort(fps), "sort mismatch")
10171  if exp is None:
10172  exp = 0
10173  val = _to_float_str(sig)
10174  if val == "NaN" or val == "nan":
10175  return fpNaN(fps)
10176  elif val == "-0.0":
10177  return fpMinusZero(fps)
10178  elif val == "0.0" or val == "+0.0":
10179  return fpPlusZero(fps)
10180  elif val == "+oo" or val == "+inf" or val == "+Inf":
10181  return fpPlusInfinity(fps)
10182  elif val == "-oo" or val == "-inf" or val == "-Inf":
10183  return fpMinusInfinity(fps)
10184  else:
10185  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
10186 
10187 
def fpMinusInfinity(s)
Definition: z3py.py:10110
def FPVal
Definition: z3py.py:10142
def fpMinusZero(s)
Definition: z3py.py:10129
def fpPlusZero(s)
Definition: z3py.py:10123
def fpPlusInfinity(s)
Definition: z3py.py:10093
def fpNaN(s)
Definition: z3py.py:10076
def is_fp_sort(s)
Definition: z3py.py:9572
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 10135 of file z3py.py.

10135 def fpZero(s, negative):
10136  """Create a Z3 floating-point +0.0 or -0.0 term."""
10137  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
10138  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
10139  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
10140 
10141 
def fpZero(s, negative)
Definition: z3py.py:10135
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 1811 of file z3py.py.

1811 def FreshBool(prefix="b", ctx=None):
1812  """Return a fresh Boolean constant in the given context using the given prefix.
1813 
1814  If `ctx=None`, then the global context is used.
1815 
1816  >>> b1 = FreshBool()
1817  >>> b2 = FreshBool()
1818  >>> eq(b1, b2)
1819  False
1820  """
1821  ctx = _get_ctx(ctx)
1822  return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1823 
1824 
def BoolSort
Definition: z3py.py:1731
def FreshBool
Definition: z3py.py:1811
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 1482 of file z3py.py.

1482 def FreshConst(sort, prefix="c"):
1483  """Create a fresh constant of a specified sort"""
1484  ctx = _get_ctx(sort.ctx)
1485  return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1486 
1487 
def FreshConst
Definition: z3py.py:1482
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 904 of file z3py.py.

904 def FreshFunction(*sig):
905  """Create a new fresh Z3 uninterpreted function with the given sorts.
906  """
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 = (z3.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_fresh_func_decl(ctx.ref(), "f", arity, dom, rng.ast), ctx)
921 
922 
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:740
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:904
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 3333 of file z3py.py.

3333 def FreshInt(prefix="x", ctx=None):
3334  """Return a fresh integer constant in the given context using the given prefix.
3335 
3336  >>> x = FreshInt()
3337  >>> y = FreshInt()
3338  >>> eq(x, y)
3339  False
3340  >>> x.sort()
3341  Int
3342  """
3343  ctx = _get_ctx(ctx)
3344  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3345 
3346 
def IntSort
Definition: z3py.py:3188
def FreshInt
Definition: z3py.py:3333
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 3390 of file z3py.py.

3390 def FreshReal(prefix="b", ctx=None):
3391  """Return a fresh real constant in the given context using the given prefix.
3392 
3393  >>> x = FreshReal()
3394  >>> y = FreshReal()
3395  >>> eq(x, y)
3396  False
3397  >>> x.sort()
3398  Real
3399  """
3400  ctx = _get_ctx(ctx)
3401  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3402 
3403 
def RealSort
Definition: z3py.py:3205
def FreshReal
Definition: z3py.py:3390
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 11091 of file z3py.py.

11091 def Full(s):
11092  """Create the regular expression that accepts the universal language
11093  >>> e = Full(ReSort(SeqSort(IntSort())))
11094  >>> print(e)
11095  Full(ReSort(Seq(Int)))
11096  >>> e1 = Full(ReSort(StringSort()))
11097  >>> print(e1)
11098  Full(ReSort(String))
11099  """
11100  if isinstance(s, ReSortRef):
11101  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
11102  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
11103 
11104 
11105 
def Full(s)
Definition: z3py.py:11091
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 4977 of file z3py.py.

4977 def FullSet(s):
4978  """Create the full set
4979  >>> FullSet(IntSort())
4980  K(Int, True)
4981  """
4982  ctx = s.ctx
4983  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4984 
4985 
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
def FullSet(s)
Definition: z3py.py:4977
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 881 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().

881 def Function(name, *sig):
882  """Create a new Z3 uninterpreted function with the given sorts.
883 
884  >>> f = Function('f', IntSort(), IntSort())
885  >>> f(f(0))
886  f(f(0))
887  """
888  sig = _get_args(sig)
889  if z3_debug():
890  _z3_assert(len(sig) > 0, "At least two arguments expected")
891  arity = len(sig) - 1
892  rng = sig[arity]
893  if z3_debug():
894  _z3_assert(is_sort(rng), "Z3 sort expected")
895  dom = (Sort * arity)()
896  for i in range(arity):
897  if z3_debug():
898  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
899  dom[i] = sig[i].ast
900  ctx = rng.ctx
901  return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
902 
903 
Function Declarations.
Definition: z3py.py:740
def Function(name, sig)
Definition: z3py.py:881
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 6745 of file z3py.py.

6746  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6747  if z3_debug():
6748  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6749  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6750 
Function Declarations.
Definition: z3py.py:740
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:6745
def z3_debug()
Definition: z3py.py:62
def is_as_array(n)
Definition: z3py.py:6740
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 9439 of file z3py.py.

9439 def get_default_fp_sort(ctx=None):
9440  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
9441 
9442 
def get_default_fp_sort
Definition: z3py.py:9439
def FPSort
Definition: z3py.py:10017
def z3py.get_default_rounding_mode (   ctx = None)
Retrieves the global default rounding mode.

Definition at line 9406 of file z3py.py.

9407  """Retrieves the global default rounding mode."""
9408  global _dflt_rounding_mode
9409  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
9410  return RTZ(ctx)
9411  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
9412  return RTN(ctx)
9413  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
9414  return RTP(ctx)
9415  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
9416  return RNE(ctx)
9417  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
9418  return RNA(ctx)
9419 
9420 
def RNE
Definition: z3py.py:9787
def RNA
Definition: z3py.py:9797
def get_default_rounding_mode
Definition: z3py.py:9406
def RTP
Definition: z3py.py:9807
def RTZ
Definition: z3py.py:9827
def RTN
Definition: z3py.py:9817
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 4722 of file z3py.py.

4723  """Return the function declaration associated with a Z3 map array expression.
4724 
4725  >>> f = Function('f', IntSort(), IntSort())
4726  >>> b = Array('b', IntSort(), IntSort())
4727  >>> a = Map(f, b)
4728  >>> eq(f, get_map_func(a))
4729  True
4730  >>> get_map_func(a)
4731  f
4732  >>> get_map_func(a)(0)
4733  f(0)
4734  """
4735  if z3_debug():
4736  _z3_assert(is_map(a), "Z3 array map expression expected.")
4737  return FuncDeclRef(
4739  a.ctx_ref(),
4740  Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0),
4741  ),
4742  ctx=a.ctx,
4743  )
4744 
4745 
Function Declarations.
Definition: z3py.py:740
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:4697
def get_map_func(a)
Definition: z3py.py:4722
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 1353 of file z3py.py.

1354  """Return the de-Bruijn index of the Z3 bounded variable `a`.
1355 
1356  >>> x = Int('x')
1357  >>> y = Int('y')
1358  >>> is_var(x)
1359  False
1360  >>> is_const(x)
1361  True
1362  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1363  >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1364  >>> q = ForAll([x, y], f(x, y) == x + y)
1365  >>> q.body()
1366  f(Var(1), Var(0)) == Var(1) + Var(0)
1367  >>> b = q.body()
1368  >>> b.arg(0)
1369  f(Var(1), Var(0))
1370  >>> v1 = b.arg(0).arg(0)
1371  >>> v2 = b.arg(0).arg(1)
1372  >>> v1
1373  Var(1)
1374  >>> v2
1375  Var(0)
1376  >>> get_var_index(v1)
1377  1
1378  >>> get_var_index(v2)
1379  0
1380  """
1381  if z3_debug():
1382  _z3_assert(is_var(a), "Z3 bound variable expected")
1383  return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1384 
1385 
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:1353
def is_var(a)
Definition: z3py.py:1328
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 8912 of file z3py.py.

8913  """Return a string describing all options available for Z3 `simplify` procedure."""
8914  print(Z3_simplify_get_help(main_ctx().ref()))
8915 
8916 
def main_ctx()
Definition: z3py.py:239
def help_simplify()
Definition: z3py.py:8912
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 1399 of file z3py.py.

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

1399 def If(a, b, c, ctx=None):
1400  """Create a Z3 if-then-else expression.
1401 
1402  >>> x = Int('x')
1403  >>> y = Int('y')
1404  >>> max = If(x > y, x, y)
1405  >>> max
1406  If(x > y, x, y)
1407  >>> simplify(max)
1408  If(x <= y, y, x)
1409  """
1410  if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1411  return Cond(a, b, c, ctx)
1412  else:
1413  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1414  s = BoolSort(ctx)
1415  a = s.cast(a)
1416  b, c = _coerce_exprs(b, c, ctx)
1417  if z3_debug():
1418  _z3_assert(a.ctx == b.ctx, "Context mismatch")
1419  return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1420 
1421 
def BoolSort
Definition: z3py.py:1731
def If
Definition: z3py.py:1399
def Cond
Definition: z3py.py:8870
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 1825 of file z3py.py.

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

1825 def Implies(a, b, ctx=None):
1826  """Create a Z3 implies expression.
1827 
1828  >>> p, q = Bools('p q')
1829  >>> Implies(p, q)
1830  Implies(p, q)
1831  """
1832  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1833  s = BoolSort(ctx)
1834  a = s.cast(a)
1835  b = s.cast(b)
1836  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1837 
1838 
def BoolSort
Definition: z3py.py:1731
def Implies
Definition: z3py.py:1825
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 11175 of file z3py.py.

11175 def IndexOf(s, substr, offset=None):
11176  """Retrieve the index of substring within a string starting at a specified offset.
11177  >>> simplify(IndexOf("abcabc", "bc", 0))
11178  1
11179  >>> simplify(IndexOf("abcabc", "bc", 2))
11180  4
11181  """
11182  if offset is None:
11183  offset = IntVal(0)
11184  ctx = None
11185  if is_expr(offset):
11186  ctx = offset.ctx
11187  ctx = _get_ctx2(s, substr, ctx)
11188  s = _coerce_seq(s, ctx)
11189  substr = _coerce_seq(substr, ctx)
11190  if _is_int(offset):
11191  offset = IntVal(offset, ctx)
11192  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
11193 
11194 
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:1260
def IndexOf
Definition: z3py.py:11175
def IntVal
Definition: z3py.py:3234
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 11288 of file z3py.py.

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

11288 def InRe(s, re):
11289  """Create regular expression membership test
11290  >>> re = Union(Re("a"),Re("b"))
11291  >>> print (simplify(InRe("a", re)))
11292  True
11293  >>> print (simplify(InRe("b", re)))
11294  True
11295  >>> print (simplify(InRe("c", re)))
11296  False
11297  """
11298  s = _coerce_seq(s, re.ctx)
11299  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
11300 
11301 
def InRe(s, re)
Definition: z3py.py:11288
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 3294 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().

3294 def Int(name, ctx=None):
3295  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3296 
3297  >>> x = Int('x')
3298  >>> is_int(x)
3299  True
3300  >>> is_int(x + 1)
3301  True
3302  """
3303  ctx = _get_ctx(ctx)
3304  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3305 
3306 
def IntSort
Definition: z3py.py:3188
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:3294
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 4042 of file z3py.py.

4042 def Int2BV(a, num_bits):
4043  """Return the z3 expression Int2BV(a, num_bits).
4044  It is a bit-vector of width num_bits and represents the
4045  modulo of a by 2^num_bits
4046  """
4047  ctx = a.ctx
4048  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
4049 
4050 
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:4042
def z3py.Intersect (   args)
Create intersection of regular expressions.
>>> re = Intersect(Re("a"), Re("b"), Re("c"))

Definition at line 11322 of file z3py.py.

11322 def Intersect(*args):
11323  """Create intersection of regular expressions.
11324  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
11325  """
11326  args = _get_args(args)
11327  sz = len(args)
11328  if z3_debug():
11329  _z3_assert(sz > 0, "At least one argument expected.")
11330  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11331  if sz == 1:
11332  return args[0]
11333  ctx = args[0].ctx
11334  v = (Ast * sz)()
11335  for i in range(sz):
11336  v[i] = args[i].as_ast()
11337  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
11338 
11339 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Intersect(args)
Definition: z3py.py:11322
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:11284
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 3307 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().

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

3188 def IntSort(ctx=None):
3189  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
3190 
3191  >>> IntSort()
3192  Int
3193  >>> x = Const('x', IntSort())
3194  >>> is_int(x)
3195  True
3196  >>> x.sort() == IntSort()
3197  True
3198  >>> x.sort() == BoolSort()
3199  False
3200  """
3201  ctx = _get_ctx(ctx)
3202  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
3203 
3204 
def IntSort
Definition: z3py.py:3188
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Arithmetic.
Definition: z3py.py:2338
def z3py.IntToStr (   s)
Convert integer expression to string

Definition at line 11230 of file z3py.py.

Referenced by StrToInt().

11230 def IntToStr(s):
11231  """Convert integer expression to string"""
11232  if not is_expr(s):
11233  s = _py2expr(s)
11234  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
11235 
11236 
def IntToStr(s)
Definition: z3py.py:11230
def is_expr(a)
Definition: z3py.py:1260
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 3234 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().

3234 def IntVal(val, ctx=None):
3235  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
3236 
3237  >>> IntVal(1)
3238  1
3239  >>> IntVal("100")
3240  100
3241  """
3242  ctx = _get_ctx(ctx)
3243  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
3244 
3245 
def IntSort
Definition: z3py.py:3188
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:3234
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 3320 of file z3py.py.

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

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

2829  """Return `True` if `a` is an algebraic value of sort Real.
2830 
2831  >>> is_algebraic_value(RealVal("3/5"))
2832  False
2833  >>> n = simplify(Sqrt(2))
2834  >>> n
2835  1.4142135623?
2836  >>> is_algebraic_value(n)
2837  True
2838  """
2839  return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2840 
2841 
def is_arith(a)
Definition: z3py.py:2715
def is_algebraic_value(a)
Definition: z3py.py:2828
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 1661 of file z3py.py.

1661 def is_and(a):
1662  """Return `True` if `a` is a Z3 and expression.
1663 
1664  >>> p, q = Bools('p q')
1665  >>> is_and(And(p, q))
1666  True
1667  >>> is_and(Or(p, q))
1668  False
1669  """
1670  return is_app_of(a, Z3_OP_AND)
1671 
1672 
def is_and(a)
Definition: z3py.py:1661
def is_app_of(a, k)
Definition: z3py.py:1386
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 1283 of file z3py.py.

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

1283 def is_app(a):
1284  """Return `True` if `a` is a Z3 function application.
1285 
1286  Note that, constants are function applications with 0 arguments.
1287 
1288  >>> a = Int('a')
1289  >>> is_app(a)
1290  True
1291  >>> is_app(a + 1)
1292  True
1293  >>> is_app(IntSort())
1294  False
1295  >>> is_app(1)
1296  False
1297  >>> is_app(IntVal(1))
1298  True
1299  >>> x = Int('x')
1300  >>> is_app(ForAll(x, x >= 0))
1301  False
1302  """
1303  if not isinstance(a, ExprRef):
1304  return False
1305  k = _ast_kind(a.ctx, a)
1306  return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1307 
1308 
def is_app(a)
Definition: z3py.py:1283
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 1386 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().

1386 def is_app_of(a, k):
1387  """Return `True` if `a` is an application of the given kind `k`.
1388 
1389  >>> x = Int('x')
1390  >>> n = x + 1
1391  >>> is_app_of(n, Z3_OP_ADD)
1392  True
1393  >>> is_app_of(n, Z3_OP_MUL)
1394  False
1395  """
1396  return is_app(a) and a.decl().kind() == k
1397 
1398 
def is_app(a)
Definition: z3py.py:1283
def is_app_of(a, k)
Definition: z3py.py:1386
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 2715 of file z3py.py.

Referenced by is_algebraic_value().

2715 def is_arith(a):
2716  """Return `True` if `a` is an arithmetical expression.
2717 
2718  >>> x = Int('x')
2719  >>> is_arith(x)
2720  True
2721  >>> is_arith(x + 1)
2722  True
2723  >>> is_arith(1)
2724  False
2725  >>> is_arith(IntVal(1))
2726  True
2727  >>> y = Real('y')
2728  >>> is_arith(y)
2729  True
2730  >>> is_arith(y + 1)
2731  True
2732  """
2733  return isinstance(a, ArithRef)
2734 
2735 
def is_arith(a)
Definition: z3py.py:2715
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 2414 of file z3py.py.

2415  """Return `True` if s is an arithmetical sort (type).
2416 
2417  >>> is_arith_sort(IntSort())
2418  True
2419  >>> is_arith_sort(RealSort())
2420  True
2421  >>> is_arith_sort(BoolSort())
2422  False
2423  >>> n = Int('x') + 1
2424  >>> is_arith_sort(n.sort())
2425  True
2426  """
2427  return isinstance(s, ArithSortRef)
2428 
2429 
def is_arith_sort(s)
Definition: z3py.py:2414
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 4657 of file z3py.py.

Referenced by Ext().

4657 def is_array(a):
4658  """Return `True` if `a` is a Z3 array expression.
4659 
4660  >>> a = Array('a', IntSort(), IntSort())
4661  >>> is_array(a)
4662  True
4663  >>> is_array(Store(a, 0, 1))
4664  True
4665  >>> is_array(a[0])
4666  False
4667  """
4668  return isinstance(a, ArrayRef)
4669 
4670 
def is_array(a)
Definition: z3py.py:4657
def z3py.is_array_sort (   a)

Definition at line 4653 of file z3py.py.

Referenced by Default(), and Ext().

4654  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4655 
4656 
def is_array_sort(a)
Definition: z3py.py:4653
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 6740 of file z3py.py.

Referenced by get_as_array_func().

6741  """Return true if n is a Z3 expression of the form (_ as-array f)."""
6742  return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6743 
6744 
def is_as_array(n)
Definition: z3py.py:6740
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 1611 of file z3py.py.

Referenced by BoolSort(), and prove().

1611 def is_bool(a):
1612  """Return `True` if `a` is a Z3 Boolean expression.
1613 
1614  >>> p = Bool('p')
1615  >>> is_bool(p)
1616  True
1617  >>> q = Bool('q')
1618  >>> is_bool(And(p, q))
1619  True
1620  >>> x = Real('x')
1621  >>> is_bool(x)
1622  False
1623  >>> is_bool(x == 0)
1624  True
1625  """
1626  return isinstance(a, BoolRef)
1627 
1628 
def is_bool(a)
Definition: z3py.py:1611
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 3990 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().

3990 def is_bv(a):
3991  """Return `True` if `a` is a Z3 bit-vector expression.
3992 
3993  >>> b = BitVec('b', 32)
3994  >>> is_bv(b)
3995  True
3996  >>> is_bv(b + 10)
3997  True
3998  >>> is_bv(Int('x'))
3999  False
4000  """
4001  return isinstance(a, BitVecRef)
4002 
4003 
def is_bv(a)
Definition: z3py.py:3990
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 3522 of file z3py.py.

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

3522 def is_bv_sort(s):
3523  """Return True if `s` is a Z3 bit-vector sort.
3524 
3525  >>> is_bv_sort(BitVecSort(32))
3526  True
3527  >>> is_bv_sort(IntSort())
3528  False
3529  """
3530  return isinstance(s, BitVecSortRef)
3531 
3532 
def is_bv_sort(s)
Definition: z3py.py:3522
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 4004 of file z3py.py.

4005  """Return `True` if `a` is a Z3 bit-vector numeral value.
4006 
4007  >>> b = BitVec('b', 32)
4008  >>> is_bv_value(b)
4009  False
4010  >>> b = BitVecVal(10, 32)
4011  >>> b
4012  10
4013  >>> is_bv_value(b)
4014  True
4015  """
4016  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
4017 
4018 
def is_bv_value(a)
Definition: z3py.py:4004
def is_bv(a)
Definition: z3py.py:3990
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 1309 of file z3py.py.

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

1309 def is_const(a):
1310  """Return `True` if `a` is Z3 constant/variable expression.
1311 
1312  >>> a = Int('a')
1313  >>> is_const(a)
1314  True
1315  >>> is_const(a + 1)
1316  False
1317  >>> is_const(1)
1318  False
1319  >>> is_const(IntVal(1))
1320  True
1321  >>> x = Int('x')
1322  >>> is_const(ForAll(x, x >= 0))
1323  False
1324  """
1325  return is_app(a) and a.num_args() == 0
1326 
1327 
def is_app(a)
Definition: z3py.py:1283
def is_const(a)
Definition: z3py.py:1309
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 4671 of file z3py.py.

4672  """Return `True` if `a` is a Z3 constant array.
4673 
4674  >>> a = K(IntSort(), 10)
4675  >>> is_const_array(a)
4676  True
4677  >>> a = Array('a', IntSort(), IntSort())
4678  >>> is_const_array(a)
4679  False
4680  """
4681  return is_app_of(a, Z3_OP_CONST_ARRAY)
4682 
4683 
def is_const_array(a)
Definition: z3py.py:4671
def is_app_of(a, k)
Definition: z3py.py:1386
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 4713 of file z3py.py.

4713 def is_default(a):
4714  """Return `True` if `a` is a Z3 default array expression.
4715  >>> d = Default(K(IntSort(), 10))
4716  >>> is_default(d)
4717  True
4718  """
4719  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4720 
4721 
def is_default(a)
Definition: z3py.py:4713
def is_app_of(a, k)
Definition: z3py.py:1386
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 1719 of file z3py.py.

1720  """Return `True` if `a` is a Z3 distinct expression.
1721 
1722  >>> x, y, z = Ints('x y z')
1723  >>> is_distinct(x == y)
1724  False
1725  >>> is_distinct(Distinct(x, y, z))
1726  True
1727  """
1728  return is_app_of(a, Z3_OP_DISTINCT)
1729 
1730 
def is_distinct(a)
Definition: z3py.py:1719
def is_app_of(a, k)
Definition: z3py.py:1386
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 2878 of file z3py.py.

2878 def is_div(a):
2879  """Return `True` if `a` is an expression of the form b / c.
2880 
2881  >>> x, y = Reals('x y')
2882  >>> is_div(x / y)
2883  True
2884  >>> is_div(x + y)
2885  False
2886  >>> x, y = Ints('x y')
2887  >>> is_div(x / y)
2888  False
2889  >>> is_idiv(x / y)
2890  True
2891  """
2892  return is_app_of(a, Z3_OP_DIV)
2893 
2894 
def is_div(a)
Definition: z3py.py:2878
def is_app_of(a, k)
Definition: z3py.py:1386
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 1709 of file z3py.py.

Referenced by AstRef.__bool__().

1709 def is_eq(a):
1710  """Return `True` if `a` is a Z3 equality expression.
1711 
1712  >>> x, y = Ints('x y')
1713  >>> is_eq(x == y)
1714  True
1715  """
1716  return is_app_of(a, Z3_OP_EQ)
1717 
1718 
def is_eq(a)
Definition: z3py.py:1709
def is_app_of(a, k)
Definition: z3py.py:1386
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 1260 of file z3py.py.

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

1260 def is_expr(a):
1261  """Return `True` if `a` is a Z3 expression.
1262 
1263  >>> a = Int('a')
1264  >>> is_expr(a)
1265  True
1266  >>> is_expr(a + 1)
1267  True
1268  >>> is_expr(IntSort())
1269  False
1270  >>> is_expr(1)
1271  False
1272  >>> is_expr(IntVal(1))
1273  True
1274  >>> x = Int('x')
1275  >>> is_expr(ForAll(x, x >= 0))
1276  True
1277  >>> is_expr(FPVal(1.0))
1278  True
1279  """
1280  return isinstance(a, ExprRef)
1281 
1282 
def is_expr(a)
Definition: z3py.py:1260
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 1647 of file z3py.py.

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

1647 def is_false(a):
1648  """Return `True` if `a` is the Z3 false expression.
1649 
1650  >>> p = Bool('p')
1651  >>> is_false(p)
1652  False
1653  >>> is_false(False)
1654  False
1655  >>> is_false(BoolVal(False))
1656  True
1657  """
1658  return is_app_of(a, Z3_OP_FALSE)
1659 
1660 
def is_app_of(a, k)
Definition: z3py.py:1386
def is_false(a)
Definition: z3py.py:1647
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 7807 of file z3py.py.

Referenced by is_finite_domain_value().

7808  """Return `True` if `a` is a Z3 finite-domain expression.
7809 
7810  >>> s = FiniteDomainSort('S', 100)
7811  >>> b = Const('b', s)
7812  >>> is_finite_domain(b)
7813  True
7814  >>> is_finite_domain(Int('x'))
7815  False
7816  """
7817  return isinstance(a, FiniteDomainRef)
7818 
7819 
def is_finite_domain(a)
Definition: z3py.py:7807
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 7784 of file z3py.py.

Referenced by FiniteDomainVal().

7785  """Return True if `s` is a Z3 finite-domain sort.
7786 
7787  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7788  True
7789  >>> is_finite_domain_sort(IntSort())
7790  False
7791  """
7792  return isinstance(s, FiniteDomainSortRef)
7793 
7794 
def is_finite_domain_sort(s)
Definition: z3py.py:7784
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 7861 of file z3py.py.

7862  """Return `True` if `a` is a Z3 finite-domain value.
7863 
7864  >>> s = FiniteDomainSort('S', 100)
7865  >>> b = Const('b', s)
7866  >>> is_finite_domain_value(b)
7867  False
7868  >>> b = FiniteDomainVal(10, s)
7869  >>> b
7870  10
7871  >>> is_finite_domain_value(b)
7872  True
7873  """
7874  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7875 
7876 
def is_finite_domain_value(a)
Definition: z3py.py:7861
def is_finite_domain(a)
Definition: z3py.py:7807
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 9988 of file z3py.py.

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

9988 def is_fp(a):
9989  """Return `True` if `a` is a Z3 floating-point expression.
9990 
9991  >>> b = FP('b', FPSort(8, 24))
9992  >>> is_fp(b)
9993  True
9994  >>> is_fp(b + 1.0)
9995  True
9996  >>> is_fp(Int('x'))
9997  False
9998  """
9999  return isinstance(a, FPRef)
10000 
10001 
def is_fp(a)
Definition: z3py.py:9988
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 9572 of file z3py.py.

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

9572 def is_fp_sort(s):
9573  """Return True if `s` is a Z3 floating-point sort.
9574 
9575  >>> is_fp_sort(FPSort(8, 24))
9576  True
9577  >>> is_fp_sort(IntSort())
9578  False
9579  """
9580  return isinstance(s, FPSortRef)
9581 
9582 
def is_fp_sort(s)
Definition: z3py.py:9572
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 10002 of file z3py.py.

10003  """Return `True` if `a` is a Z3 floating-point numeral value.
10004 
10005  >>> b = FP('b', FPSort(8, 24))
10006  >>> is_fp_value(b)
10007  False
10008  >>> b = FPVal(1.0, FPSort(8, 24))
10009  >>> b
10010  1
10011  >>> is_fp_value(b)
10012  True
10013  """
10014  return is_fp(a) and _is_numeral(a.ctx, a.ast)
10015 
10016 
def is_fp_value(a)
Definition: z3py.py:10002
def is_fp(a)
Definition: z3py.py:9988
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 9832 of file z3py.py.

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

9832 def is_fprm(a):
9833  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9834 
9835  >>> rm = RNE()
9836  >>> is_fprm(rm)
9837  True
9838  >>> rm = 1.0
9839  >>> is_fprm(rm)
9840  False
9841  """
9842  return isinstance(a, FPRMRef)
9843 
9844 
def is_fprm(a)
Definition: z3py.py:9832
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 9583 of file z3py.py.

9584  """Return True if `s` is a Z3 floating-point rounding mode sort.
9585 
9586  >>> is_fprm_sort(FPSort(8, 24))
9587  False
9588  >>> is_fprm_sort(RNE().sort())
9589  True
9590  """
9591  return isinstance(s, FPRMSortRef)
9592 
9593 # FP Expressions
9594 
9595 
def is_fprm_sort(s)
Definition: z3py.py:9583
def z3py.is_fprm_value (   a)
Return `True` if `a` is a Z3 floating-point rounding mode numeral value.

Definition at line 9845 of file z3py.py.

9846  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9847  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9848 
9849 # FP Numerals
9850 
9851 
def is_fprm_value(a)
Definition: z3py.py:9845
def is_fprm(a)
Definition: z3py.py:9832
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 868 of file z3py.py.

Referenced by prove(), and substitute_funs().

869  """Return `True` if `a` is a Z3 function declaration.
870 
871  >>> f = Function('f', IntSort(), IntSort())
872  >>> is_func_decl(f)
873  True
874  >>> x = Real('x')
875  >>> is_func_decl(x)
876  False
877  """
878  return isinstance(a, FuncDeclRef)
879 
880 
def is_func_decl(a)
Definition: z3py.py:868
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 2943 of file z3py.py.

2943 def is_ge(a):
2944  """Return `True` if `a` is an expression of the form b >= c.
2945 
2946  >>> x, y = Ints('x y')
2947  >>> is_ge(x >= y)
2948  True
2949  >>> is_ge(x == y)
2950  False
2951  """
2952  return is_app_of(a, Z3_OP_GE)
2953 
2954 
def is_ge(a)
Definition: z3py.py:2943
def is_app_of(a, k)
Definition: z3py.py:1386
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 2955 of file z3py.py.

2955 def is_gt(a):
2956  """Return `True` if `a` is an expression of the form b > c.
2957 
2958  >>> x, y = Ints('x y')
2959  >>> is_gt(x > y)
2960  True
2961  >>> is_gt(x == y)
2962  False
2963  """
2964  return is_app_of(a, Z3_OP_GT)
2965 
2966 
def is_gt(a)
Definition: z3py.py:2955
def is_app_of(a, k)
Definition: z3py.py:1386
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 2895 of file z3py.py.

Referenced by is_div().

2895 def is_idiv(a):
2896  """Return `True` if `a` is an expression of the form b div c.
2897 
2898  >>> x, y = Ints('x y')
2899  >>> is_idiv(x / y)
2900  True
2901  >>> is_idiv(x + y)
2902  False
2903  """
2904  return is_app_of(a, Z3_OP_IDIV)
2905 
2906 
def is_idiv(a)
Definition: z3py.py:2895
def is_app_of(a, k)
Definition: z3py.py:1386
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 1685 of file z3py.py.

1685 def is_implies(a):
1686  """Return `True` if `a` is a Z3 implication expression.
1687 
1688  >>> p, q = Bools('p q')
1689  >>> is_implies(Implies(p, q))
1690  True
1691  >>> is_implies(And(p, q))
1692  False
1693  """
1694  return is_app_of(a, Z3_OP_IMPLIES)
1695 
1696 
def is_implies(a)
Definition: z3py.py:1685
def is_app_of(a, k)
Definition: z3py.py:1386
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 2736 of file z3py.py.

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

2736 def is_int(a):
2737  """Return `True` if `a` is an integer expression.
2738 
2739  >>> x = Int('x')
2740  >>> is_int(x + 1)
2741  True
2742  >>> is_int(1)
2743  False
2744  >>> is_int(IntVal(1))
2745  True
2746  >>> y = Real('y')
2747  >>> is_int(y)
2748  False
2749  >>> is_int(y + 1)
2750  False
2751  """
2752  return is_arith(a) and a.is_int()
2753 
2754 
def is_arith(a)
Definition: z3py.py:2715
def is_int(a)
Definition: z3py.py:2736
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 2782 of file z3py.py.

2783  """Return `True` if `a` is an integer value of sort Int.
2784 
2785  >>> is_int_value(IntVal(1))
2786  True
2787  >>> is_int_value(1)
2788  False
2789  >>> is_int_value(Int('x'))
2790  False
2791  >>> n = Int('x') + 1
2792  >>> n
2793  x + 1
2794  >>> n.arg(1)
2795  1
2796  >>> is_int_value(n.arg(1))
2797  True
2798  >>> is_int_value(RealVal("1/3"))
2799  False
2800  >>> is_int_value(RealVal(1))
2801  False
2802  """
2803  return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2804 
2805 
def is_int_value(a)
Definition: z3py.py:2782
def is_arith(a)
Definition: z3py.py:2715
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 2967 of file z3py.py.

2967 def is_is_int(a):
2968  """Return `True` if `a` is an expression of the form IsInt(b).
2969 
2970  >>> x = Real('x')
2971  >>> is_is_int(IsInt(x))
2972  True
2973  >>> is_is_int(x)
2974  False
2975  """
2976  return is_app_of(a, Z3_OP_IS_INT)
2977 
2978 
def is_app_of(a, k)
Definition: z3py.py:1386
def is_is_int(a)
Definition: z3py.py:2967
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 4684 of file z3py.py.

4684 def is_K(a):
4685  """Return `True` if `a` is a Z3 constant array.
4686 
4687  >>> a = K(IntSort(), 10)
4688  >>> is_K(a)
4689  True
4690  >>> a = Array('a', IntSort(), IntSort())
4691  >>> is_K(a)
4692  False
4693  """
4694  return is_app_of(a, Z3_OP_CONST_ARRAY)
4695 
4696 
def is_K(a)
Definition: z3py.py:4684
def is_app_of(a, k)
Definition: z3py.py:1386
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 2919 of file z3py.py.

2919 def is_le(a):
2920  """Return `True` if `a` is an expression of the form b <= c.
2921 
2922  >>> x, y = Ints('x y')
2923  >>> is_le(x <= y)
2924  True
2925  >>> is_le(x < y)
2926  False
2927  """
2928  return is_app_of(a, Z3_OP_LE)
2929 
2930 
def is_le(a)
Definition: z3py.py:2919
def is_app_of(a, k)
Definition: z3py.py:1386
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 2931 of file z3py.py.

2931 def is_lt(a):
2932  """Return `True` if `a` is an expression of the form b < c.
2933 
2934  >>> x, y = Ints('x y')
2935  >>> is_lt(x < y)
2936  True
2937  >>> is_lt(x == y)
2938  False
2939  """
2940  return is_app_of(a, Z3_OP_LT)
2941 
2942 
def is_lt(a)
Definition: z3py.py:2931
def is_app_of(a, k)
Definition: z3py.py:1386
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 4697 of file z3py.py.

Referenced by get_map_func().

4697 def is_map(a):
4698  """Return `True` if `a` is a Z3 map array expression.
4699 
4700  >>> f = Function('f', IntSort(), IntSort())
4701  >>> b = Array('b', IntSort(), IntSort())
4702  >>> a = Map(f, b)
4703  >>> a
4704  Map(f, b)
4705  >>> is_map(a)
4706  True
4707  >>> is_map(b)
4708  False
4709  """
4710  return is_app_of(a, Z3_OP_ARRAY_MAP)
4711 
4712 
def is_map(a)
Definition: z3py.py:4697
def is_app_of(a, k)
Definition: z3py.py:1386
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 2907 of file z3py.py.

2907 def is_mod(a):
2908  """Return `True` if `a` is an expression of the form b % c.
2909 
2910  >>> x, y = Ints('x y')
2911  >>> is_mod(x % y)
2912  True
2913  >>> is_mod(x + y)
2914  False
2915  """
2916  return is_app_of(a, Z3_OP_MOD)
2917 
2918 
def is_mod(a)
Definition: z3py.py:2907
def is_app_of(a, k)
Definition: z3py.py:1386
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 2854 of file z3py.py.

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

1697 def is_not(a):
1698  """Return `True` if `a` is a Z3 not expression.
1699 
1700  >>> p = Bool('p')
1701  >>> is_not(p)
1702  False
1703  >>> is_not(Not(p))
1704  True
1705  """
1706  return is_app_of(a, Z3_OP_NOT)
1707 
1708 
def is_not(a)
Definition: z3py.py:1697
def is_app_of(a, k)
Definition: z3py.py:1386
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 1673 of file z3py.py.

1673 def is_or(a):
1674  """Return `True` if `a` is a Z3 or expression.
1675 
1676  >>> p, q = Bools('p q')
1677  >>> is_or(Or(p, q))
1678  True
1679  >>> is_or(And(p, q))
1680  False
1681  """
1682  return is_app_of(a, Z3_OP_OR)
1683 
1684 
def is_or(a)
Definition: z3py.py:1673
def is_app_of(a, k)
Definition: z3py.py:1386
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 1973 of file z3py.py.

Referenced by MultiPattern().

1973 def is_pattern(a):
1974  """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1975 
1976  >>> f = Function('f', IntSort(), IntSort())
1977  >>> x = Int('x')
1978  >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1979  >>> q
1980  ForAll(x, f(x) == 0)
1981  >>> q.num_patterns()
1982  1
1983  >>> is_pattern(q.pattern(0))
1984  True
1985  >>> q.pattern(0)
1986  f(Var(0))
1987  """
1988  return isinstance(a, PatternRef)
1989 
1990 
def is_pattern(a)
Definition: z3py.py:1973
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 8753 of file z3py.py.

Referenced by eq().

8753 def is_probe(p):
8754  """Return `True` if `p` is a Z3 probe.
8755 
8756  >>> is_probe(Int('x'))
8757  False
8758  >>> is_probe(Probe('memory'))
8759  True
8760  """
8761  return isinstance(p, Probe)
8762 
8763 
def is_probe(p)
Definition: z3py.py:8753
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 2223 of file z3py.py.

Referenced by Exists().

2224  """Return `True` if `a` is a Z3 quantifier.
2225 
2226  >>> f = Function('f', IntSort(), IntSort())
2227  >>> x = Int('x')
2228  >>> q = ForAll(x, f(x) == 0)
2229  >>> is_quantifier(q)
2230  True
2231  >>> is_quantifier(f(x))
2232  False
2233  """
2234  return isinstance(a, QuantifierRef)
2235 
2236 
def is_quantifier(a)
Definition: z3py.py:2223
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 2806 of file z3py.py.

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

2807  """Return `True` if `a` is rational value of sort Real.
2808 
2809  >>> is_rational_value(RealVal(1))
2810  True
2811  >>> is_rational_value(RealVal("3/5"))
2812  True
2813  >>> is_rational_value(IntVal(1))
2814  False
2815  >>> is_rational_value(1)
2816  False
2817  >>> n = Real('x') + 1
2818  >>> n.arg(1)
2819  1
2820  >>> is_rational_value(n.arg(1))
2821  True
2822  >>> is_rational_value(Real('x'))
2823  False
2824  """
2825  return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2826 
2827 
def is_arith(a)
Definition: z3py.py:2715
def is_rational_value(a)
Definition: z3py.py:2806
def z3py.is_re (   s)

Definition at line 11284 of file z3py.py.

Referenced by Concat(), and Intersect().

11284 def is_re(s):
11285  return isinstance(s, ReRef)
11286 
11287 
def is_re(s)
Definition: z3py.py:11284
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 2755 of file z3py.py.

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

2755 def is_real(a):
2756  """Return `True` if `a` is a real expression.
2757 
2758  >>> x = Int('x')
2759  >>> is_real(x + 1)
2760  False
2761  >>> y = Real('y')
2762  >>> is_real(y)
2763  True
2764  >>> is_real(y + 1)
2765  True
2766  >>> is_real(1)
2767  False
2768  >>> is_real(RealVal(1))
2769  True
2770  """
2771  return is_arith(a) and a.is_real()
2772 
2773 
def is_real(a)
Definition: z3py.py:2755
def is_arith(a)
Definition: z3py.py:2715
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 4932 of file z3py.py.

4932 def is_select(a):
4933  """Return `True` if `a` is a Z3 array select application.
4934 
4935  >>> a = Array('a', IntSort(), IntSort())
4936  >>> is_select(a)
4937  False
4938  >>> i = Int('i')
4939  >>> is_select(a[i])
4940  True
4941  """
4942  return is_app_of(a, Z3_OP_SELECT)
4943 
4944 
def is_select(a)
Definition: z3py.py:4932
def is_app_of(a, k)
Definition: z3py.py:1386
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 11010 of file z3py.py.

Referenced by Concat(), and Extract().

11010 def is_seq(a):
11011  """Return `True` if `a` is a Z3 sequence expression.
11012  >>> print (is_seq(Unit(IntVal(0))))
11013  True
11014  >>> print (is_seq(StringVal("abc")))
11015  True
11016  """
11017  return isinstance(a, SeqRef)
11018 
11019 
def is_seq(a)
Definition: z3py.py:11010
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 4945 of file z3py.py.

4945 def is_store(a):
4946  """Return `True` if `a` is a Z3 array store application.
4947 
4948  >>> a = Array('a', IntSort(), IntSort())
4949  >>> is_store(a)
4950  False
4951  >>> is_store(Store(a, 0, 1))
4952  True
4953  """
4954  return is_app_of(a, Z3_OP_STORE)
4955 
def is_store(a)
Definition: z3py.py:4945
def is_app_of(a, k)
Definition: z3py.py:1386
def z3py.is_string (   a)
Return `True` if `a` is a Z3 string expression.
>>> print (is_string(StringVal("ab")))
True

Definition at line 11020 of file z3py.py.

11020 def is_string(a):
11021  """Return `True` if `a` is a Z3 string expression.
11022  >>> print (is_string(StringVal("ab")))
11023  True
11024  """
11025  return isinstance(a, SeqRef) and a.is_string()
11026 
11027 
def is_string(a)
Definition: z3py.py:11020
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 11028 of file z3py.py.

11029  """return 'True' if 'a' is a Z3 string constant expression.
11030  >>> print (is_string_value(StringVal("a")))
11031  True
11032  >>> print (is_string_value(StringVal("a") + StringVal("b")))
11033  False
11034  """
11035  return isinstance(a, SeqRef) and a.is_string_value()
11036 
def is_string_value(a)
Definition: z3py.py:11028
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 2866 of file z3py.py.

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

2994 def is_to_int(a):
2995  """Return `True` if `a` is an expression of the form ToInt(b).
2996 
2997  >>> x = Real('x')
2998  >>> n = ToInt(x)
2999  >>> n
3000  ToInt(x)
3001  >>> is_to_int(n)
3002  True
3003  >>> is_to_int(x)
3004  False
3005  """
3006  return is_app_of(a, Z3_OP_TO_INT)
3007 
3008 
def is_app_of(a, k)
Definition: z3py.py:1386
def is_to_int(a)
Definition: z3py.py:2994
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 2979 of file z3py.py.

2979 def is_to_real(a):
2980  """Return `True` if `a` is an expression of the form ToReal(b).
2981 
2982  >>> x = Int('x')
2983  >>> n = ToReal(x)
2984  >>> n
2985  ToReal(x)
2986  >>> is_to_real(n)
2987  True
2988  >>> is_to_real(x)
2989  False
2990  """
2991  return is_app_of(a, Z3_OP_TO_REAL)
2992 
2993 
def is_to_real(a)
Definition: z3py.py:2979
def is_app_of(a, k)
Definition: z3py.py:1386
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 1629 of file z3py.py.

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

1629 def is_true(a):
1630  """Return `True` if `a` is the Z3 true expression.
1631 
1632  >>> p = Bool('p')
1633  >>> is_true(p)
1634  False
1635  >>> is_true(simplify(p == p))
1636  True
1637  >>> x = Real('x')
1638  >>> is_true(x == 0)
1639  False
1640  >>> # True is a Python Boolean expression
1641  >>> is_true(True)
1642  False
1643  """
1644  return is_app_of(a, Z3_OP_TRUE)
1645 
1646 
def is_true(a)
Definition: z3py.py:1629
def is_app_of(a, k)
Definition: z3py.py:1386
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 1328 of file z3py.py.

Referenced by get_var_index().

1328 def is_var(a):
1329  """Return `True` if `a` is variable.
1330 
1331  Z3 uses de-Bruijn indices for representing bound variables in
1332  quantifiers.
1333 
1334  >>> x = Int('x')
1335  >>> is_var(x)
1336  False
1337  >>> is_const(x)
1338  True
1339  >>> f = Function('f', IntSort(), IntSort())
1340  >>> # Z3 replaces x with bound variables when ForAll is executed.
1341  >>> q = ForAll(x, f(x) == x)
1342  >>> b = q.body()
1343  >>> b
1344  f(Var(0)) == Var(0)
1345  >>> b.arg(1)
1346  Var(0)
1347  >>> is_var(b.arg(1))
1348  True
1349  """
1350  return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1351 
1352 
def is_expr(a)
Definition: z3py.py:1260
def is_var(a)
Definition: z3py.py:1328
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 3440 of file z3py.py.

Referenced by is_is_int().

3440 def IsInt(a):
3441  """ Return the Z3 predicate IsInt(a).
3442 
3443  >>> x = Real('x')
3444  >>> IsInt(x + "1/2")
3445  IsInt(x + 1/2)
3446  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3447  [x = 1/2]
3448  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3449  no solution
3450  """
3451  if z3_debug():
3452  _z3_assert(a.is_real(), "Z3 real expression expected.")
3453  ctx = a.ctx
3454  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3455 
3456 
def IsInt(a)
Definition: z3py.py:3440
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 5055 of file z3py.py.

5055 def IsMember(e, s):
5056  """ Check if e is a member of set s
5057  >>> a = Const('a', SetSort(IntSort()))
5058  >>> IsMember(1, a)
5059  a[1]
5060  """
5061  ctx = _ctx_from_ast_arg_list([s, e])
5062  e = _py2expr(e, ctx)
5063  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
5064 
5065 
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:5055
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 5066 of file z3py.py.

5066 def IsSubset(a, b):
5067  """ Check if a is a subset of b
5068  >>> a = Const('a', SetSort(IntSort()))
5069  >>> b = Const('b', SetSort(IntSort()))
5070  >>> IsSubset(a, b)
5071  subset(a, b)
5072  """
5073  ctx = _ctx_from_ast_arg_list([a, b])
5074  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5075 
5076 
def IsSubset(a, b)
Definition: z3py.py:5066
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 4892 of file z3py.py.

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

4892 def K(dom, v):
4893  """Return a Z3 constant array expression.
4894 
4895  >>> a = K(IntSort(), 10)
4896  >>> a
4897  K(Int, 10)
4898  >>> a.sort()
4899  Array(Int, Int)
4900  >>> i = Int('i')
4901  >>> a[i]
4902  K(Int, 10)[i]
4903  >>> simplify(a[i])
4904  10
4905  """
4906  if z3_debug():
4907  _z3_assert(is_sort(dom), "Z3 sort expected")
4908  ctx = dom.ctx
4909  if not is_expr(v):
4910  v = _py2expr(v, ctx)
4911  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4912 
4913 
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:4892
def is_expr(a)
Definition: z3py.py:1260
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 2311 of file z3py.py.

Referenced by QuantifierRef.is_lambda().

2311 def Lambda(vs, body):
2312  """Create a Z3 lambda expression.
2313 
2314  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2315  >>> mem0 = Array('mem0', IntSort(), IntSort())
2316  >>> lo, hi, e, i = Ints('lo hi e i')
2317  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2318  >>> mem1
2319  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2320  """
2321  ctx = body.ctx
2322  if is_app(vs):
2323  vs = [vs]
2324  num_vars = len(vs)
2325  _vs = (Ast * num_vars)()
2326  for i in range(num_vars):
2327  # TODO: Check if is constant
2328  _vs[i] = vs[i].as_ast()
2329  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2330 
Quantifiers.
Definition: z3py.py:2028
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def is_app(a)
Definition: z3py.py:1283
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:2311
def z3py.LastIndexOf (   s,
  substr 
)
Retrieve the last index of substring within a string

Definition at line 11195 of file z3py.py.

11195 def LastIndexOf(s, substr):
11196  """Retrieve the last index of substring within a string"""
11197  ctx = None
11198  ctx = _get_ctx2(s, substr, ctx)
11199  s = _coerce_seq(s, ctx)
11200  substr = _coerce_seq(substr, ctx)
11201  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
11202 
11203 
def LastIndexOf(s, substr)
Definition: z3py.py:11195
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 11204 of file z3py.py.

11204 def Length(s):
11205  """Obtain the length of a sequence 's'
11206  >>> l = Length(StringVal("abc"))
11207  >>> simplify(l)
11208  3
11209  """
11210  s = _coerce_seq(s)
11211  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
11212 
11213 
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:11204
def z3py.LinearOrder (   a,
  index 
)

Definition at line 11440 of file z3py.py.

11440 def LinearOrder(a, index):
11441  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11442 
11443 
Function Declarations.
Definition: z3py.py:740
def LinearOrder(a, index)
Definition: z3py.py:11440
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 11390 of file z3py.py.

11390 def Loop(re, lo, hi=0):
11391  """Create the regular expression accepting between a lower and upper bound repetitions
11392  >>> re = Loop(Re("a"), 1, 3)
11393  >>> print(simplify(InRe("aa", re)))
11394  True
11395  >>> print(simplify(InRe("aaaa", re)))
11396  False
11397  >>> print(simplify(InRe("", re)))
11398  False
11399  """
11400  if z3_debug():
11401  _z3_assert(is_expr(re), "expression expected")
11402  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
11403 
11404 
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:11390
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
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 4345 of file z3py.py.

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

4345 def LShR(a, b):
4346  """Create the Z3 expression logical right shift.
4347 
4348  Use the operator >> for the arithmetical right shift.
4349 
4350  >>> x, y = BitVecs('x y', 32)
4351  >>> LShR(x, y)
4352  LShR(x, y)
4353  >>> (x >> y).sexpr()
4354  '(bvashr x y)'
4355  >>> LShR(x, y).sexpr()
4356  '(bvlshr x y)'
4357  >>> BitVecVal(4, 3)
4358  4
4359  >>> BitVecVal(4, 3).as_signed_long()
4360  -4
4361  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4362  -2
4363  >>> simplify(BitVecVal(4, 3) >> 1)
4364  6
4365  >>> simplify(LShR(BitVecVal(4, 3), 1))
4366  2
4367  >>> simplify(BitVecVal(2, 3) >> 1)
4368  1
4369  >>> simplify(LShR(BitVecVal(2, 3), 1))
4370  1
4371  """
4372  _check_bv_args(a, b)
4373  a, b = _coerce_exprs(a, b)
4374  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4375 
4376 
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:4345
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 4869 of file z3py.py.

Referenced by get_map_func(), and is_map().

4869 def Map(f, *args):
4870  """Return a Z3 map array expression.
4871 
4872  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4873  >>> a1 = Array('a1', IntSort(), IntSort())
4874  >>> a2 = Array('a2', IntSort(), IntSort())
4875  >>> b = Map(f, a1, a2)
4876  >>> b
4877  Map(f, a1, a2)
4878  >>> prove(b[0] == f(a1[0], a2[0]))
4879  proved
4880  """
4881  args = _get_args(args)
4882  if z3_debug():
4883  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4884  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4885  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4886  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4887  _args, sz = _to_ast_array(args)
4888  ctx = f.ctx
4889  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4890 
4891 
def is_array(a)
Definition: z3py.py:4657
def z3_debug()
Definition: z3py.py:62
def Map(f, args)
Definition: z3py.py:4869
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:868
def z3py.mk_not (   a)

Definition at line 1874 of file z3py.py.

1874 def mk_not(a):
1875  if is_not(a):
1876  return a.arg(0)
1877  else:
1878  return Not(a)
1879 
1880 
def Not
Definition: z3py.py:1855
def mk_not(a)
Definition: z3py.py:1874
def is_not(a)
Definition: z3py.py:1697
def z3py.Model (   ctx = None)

Definition at line 6735 of file z3py.py.

Referenced by Optimize.set_on_model().

6735 def Model(ctx=None):
6736  ctx = _get_ctx(ctx)
6737  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6738 
6739 
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:6735
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 1991 of file z3py.py.

1991 def MultiPattern(*args):
1992  """Create a Z3 multi-pattern using the given expressions `*args`
1993 
1994  >>> f = Function('f', IntSort(), IntSort())
1995  >>> g = Function('g', IntSort(), IntSort())
1996  >>> x = Int('x')
1997  >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1998  >>> q
1999  ForAll(x, f(x) != g(x))
2000  >>> q.num_patterns()
2001  1
2002  >>> is_pattern(q.pattern(0))
2003  True
2004  >>> q.pattern(0)
2005  MultiPattern(f(Var(0)), g(Var(0)))
2006  """
2007  if z3_debug():
2008  _z3_assert(len(args) > 0, "At least one argument expected")
2009  _z3_assert(all([is_expr(a) for a in args]), "Z3 expressions expected")
2010  ctx = args[0].ctx
2011  args, sz = _to_ast_array(args)
2012  return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
2013 
2014 
Patterns.
Definition: z3py.py:1961
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:1991
def is_expr(a)
Definition: z3py.py:1260
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 1855 of file z3py.py.

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

1855 def Not(a, ctx=None):
1856  """Create a Z3 not expression or probe.
1857 
1858  >>> p = Bool('p')
1859  >>> Not(Not(p))
1860  Not(Not(p))
1861  >>> simplify(Not(Not(p)))
1862  p
1863  """
1864  ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1865  if is_probe(a):
1866  # Not is also used to build probes
1867  return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1868  else:
1869  s = BoolSort(ctx)
1870  a = s.cast(a)
1871  return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1872 
1873 
def Not
Definition: z3py.py:1855
def BoolSort
Definition: z3py.py:1731
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:8753
def z3py.on_clause_eh (   ctx,
  p,
  n,
  dep,
  clause 
)

Definition at line 11480 of file z3py.py.

Referenced by on_clause.on_clause().

11480 def on_clause_eh(ctx, p, n, dep, clause):
11481  onc = _my_hacky_class
11482  p = _to_expr_ref(to_Ast(p), onc.ctx)
11483  clause = AstVector(to_AstVectorObj(clause), onc.ctx)
11484  deps = [dep[i] for i in range(n)]
11485  onc.on_clause(p, deps, clause)
11486 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def on_clause_eh(ctx, p, n, dep, clause)
Definition: z3py.py:11480
def to_AstVectorObj(ptr)
Definition: z3py.py:11469
def to_Ast(ptr)
Definition: z3py.py:11459
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 11355 of file z3py.py.

11355 def Option(re):
11356  """Create the regular expression that optionally accepts the argument.
11357  >>> re = Option(Re("a"))
11358  >>> print(simplify(InRe("a", re)))
11359  True
11360  >>> print(simplify(InRe("", re)))
11361  True
11362  >>> print(simplify(InRe("aa", re)))
11363  False
11364  """
11365  if z3_debug():
11366  _z3_assert(is_expr(re), "expression expected")
11367  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
11368 
11369 
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
def Option(re)
Definition: z3py.py:11355
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 1922 of file z3py.py.

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

1922 def Or(*args):
1923  """Create a Z3 or-expression or or-probe.
1924 
1925  >>> p, q, r = Bools('p q r')
1926  >>> Or(p, q, r)
1927  Or(p, q, r)
1928  >>> P = BoolVector('p', 5)
1929  >>> Or(P)
1930  Or(p__0, p__1, p__2, p__3, p__4)
1931  """
1932  last_arg = None
1933  if len(args) > 0:
1934  last_arg = args[len(args) - 1]
1935  if isinstance(last_arg, Context):
1936  ctx = args[len(args) - 1]
1937  args = args[:len(args) - 1]
1938  elif len(args) == 1 and isinstance(args[0], AstVector):
1939  ctx = args[0].ctx
1940  args = [a for a in args[0]]
1941  else:
1942  ctx = None
1943  args = _get_args(args)
1944  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1945  if z3_debug():
1946  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1947  if _has_probe(args):
1948  return _probe_or(args, ctx)
1949  else:
1950  args = _coerce_expr_list(args, ctx)
1951  _args, sz = _to_ast_array(args)
1952  return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1953 
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:1922
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 8446 of file z3py.py.

8446 def OrElse(*ts, **ks):
8447  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
8448 
8449  >>> x = Int('x')
8450  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
8451  >>> # Tactic split-clause fails if there is no clause in the given goal.
8452  >>> t(x == 0)
8453  [[x == 0]]
8454  >>> t(Or(x == 0, x == 1))
8455  [[x == 0], [x == 1]]
8456  """
8457  if z3_debug():
8458  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8459  ctx = ks.get("ctx", None)
8460  num = len(ts)
8461  r = ts[0]
8462  for i in range(num - 1):
8463  r = _or_else(r, ts[i + 1], ctx)
8464  return r
8465 
8466 
def OrElse(ts, ks)
Definition: z3py.py:8446
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 8502 of file z3py.py.

8502 def ParAndThen(t1, t2, ctx=None):
8503  """Alias for ParThen(t1, t2, ctx)."""
8504  return ParThen(t1, t2, ctx)
8505 
8506 
def ParThen
Definition: z3py.py:8486
def ParAndThen
Definition: z3py.py:8502
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 8467 of file z3py.py.

8467 def ParOr(*ts, **ks):
8468  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
8469 
8470  >>> x = Int('x')
8471  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
8472  >>> t(x + 1 == 2)
8473  [[x == 1]]
8474  """
8475  if z3_debug():
8476  _z3_assert(len(ts) >= 2, "At least two arguments expected")
8477  ctx = _get_ctx(ks.get("ctx", None))
8478  ts = [_to_tactic(t, ctx) for t in ts]
8479  sz = len(ts)
8480  _args = (TacticObj * sz)()
8481  for i in range(sz):
8482  _args[i] = ts[i].tactic
8483  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
8484 
8485 
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:8467
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 9382 of file z3py.py.

9382 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
9383  """Parse a file in SMT 2.0 format using the given sorts and decls.
9384 
9385  This function is similar to parse_smt2_string().
9386  """
9387  ctx = _get_ctx(ctx)
9388  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9389  dsz, dnames, ddecls = _dict2darray(decls, ctx)
9390  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9391 
9392 
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:9382
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 9361 of file z3py.py.

Referenced by parse_smt2_file().

9361 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
9362  """Parse a string in SMT 2.0 format using the given sorts and decls.
9363 
9364  The arguments sorts and decls are Python dictionaries used to initialize
9365  the symbol table used for the SMT 2.0 parser.
9366 
9367  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
9368  [x > 0, x < 10]
9369  >>> x, y = Ints('x y')
9370  >>> f = Function('f', IntSort(), IntSort())
9371  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
9372  [x + f(y) > 0]
9373  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
9374  [a > 0]
9375  """
9376  ctx = _get_ctx(ctx)
9377  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
9378  dsz, dnames, ddecls = _dict2darray(decls, ctx)
9379  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
9380 
9381 
def parse_smt2_string
Definition: z3py.py:9361
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 8486 of file z3py.py.

Referenced by ParAndThen().

8486 def ParThen(t1, t2, ctx=None):
8487  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1.
8488  The subgoals are processed in parallel.
8489 
8490  >>> x, y = Ints('x y')
8491  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
8492  >>> t(And(Or(x == 1, x == 2), y == x + 1))
8493  [[x == 1, y == 2], [x == 2, y == 3]]
8494  """
8495  t1 = _to_tactic(t1, ctx)
8496  t2 = _to_tactic(t2, ctx)
8497  if z3_debug():
8498  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
8499  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
8500 
8501 
def ParThen
Definition: z3py.py:8486
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 11436 of file z3py.py.

11436 def PartialOrder(a, index):
11437  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx)
11438 
11439 
Function Declarations.
Definition: z3py.py:740
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:11436
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 9138 of file z3py.py.

9138 def PbEq(args, k, ctx=None):
9139  """Create a Pseudo-Boolean equality k constraint.
9140 
9141  >>> a, b, c = Bools('a b c')
9142  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
9143  """
9144  _z3_check_cint_overflow(k, "k")
9145  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9146  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
9147 
9148 
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:9138
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 9127 of file z3py.py.

9127 def PbGe(args, k):
9128  """Create a Pseudo-Boolean inequality k constraint.
9129 
9130  >>> a, b, c = Bools('a b c')
9131  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
9132  """
9133  _z3_check_cint_overflow(k, "k")
9134  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9135  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
9136 
9137 
def PbGe(args, k)
Definition: z3py.py:9127
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 9116 of file z3py.py.

9116 def PbLe(args, k):
9117  """Create a Pseudo-Boolean inequality k constraint.
9118 
9119  >>> a, b, c = Bools('a b c')
9120  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
9121  """
9122  _z3_check_cint_overflow(k, "k")
9123  ctx, sz, _args, _coeffs, args = _pb_args_coeffs(args)
9124  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
9125 
9126 
def PbLe(args, k)
Definition: z3py.py:9116
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 11448 of file z3py.py.

11448 def PiecewiseLinearOrder(a, index):
11449  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx)
11450 
11451 
Function Declarations.
Definition: z3py.py:740
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:11448
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 11340 of file z3py.py.

11340 def Plus(re):
11341  """Create the regular expression accepting one or more repetitions of argument.
11342  >>> re = Plus(Re("a"))
11343  >>> print(simplify(InRe("aa", re)))
11344  True
11345  >>> print(simplify(InRe("ab", re)))
11346  False
11347  >>> print(simplify(InRe("", re)))
11348  False
11349  """
11350  if z3_debug():
11351  _z3_assert(is_expr(re), "expression expected")
11352  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
11353 
11354 
def Plus(re)
Definition: z3py.py:11340
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
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 11111 of file z3py.py.

11111 def PrefixOf(a, b):
11112  """Check if 'a' is a prefix of 'b'
11113  >>> s1 = PrefixOf("ab", "abc")
11114  >>> simplify(s1)
11115  True
11116  >>> s2 = PrefixOf("bc", "abc")
11117  >>> simplify(s2)
11118  False
11119  """
11120  ctx = _get_ctx2(a, b)
11121  a = _coerce_seq(a, ctx)
11122  b = _coerce_seq(b, ctx)
11123  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11124 
11125 
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:11111
def z3py.probe_description (   name,
  ctx = None 
)
Return a short description for the probe named `name`.

>>> d = probe_description('memory')

Definition at line 8782 of file z3py.py.

Referenced by describe_probes().

8782 def probe_description(name, ctx=None):
8783  """Return a short description for the probe named `name`.
8784 
8785  >>> d = probe_description('memory')
8786  """
8787  ctx = _get_ctx(ctx)
8788  return Z3_probe_get_descr(ctx.ref(), name)
8789 
8790 
def probe_description
Definition: z3py.py:8782
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 8771 of file z3py.py.

Referenced by describe_probes().

8771 def probes(ctx=None):
8772  """Return a list of all available probes in Z3.
8773 
8774  >>> l = probes()
8775  >>> l.count('memory') == 1
8776  True
8777  """
8778  ctx = _get_ctx(ctx)
8779  return [Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref()))]
8780 
8781 
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:8771
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 9023 of file z3py.py.

Referenced by BitVecs().

9023 def Product(*args):
9024  """Create the product of the Z3 expressions.
9025 
9026  >>> a, b, c = Ints('a b c')
9027  >>> Product(a, b, c)
9028  a*b*c
9029  >>> Product([a, b, c])
9030  a*b*c
9031  >>> A = IntVector('a', 5)
9032  >>> Product(A)
9033  a__0*a__1*a__2*a__3*a__4
9034  """
9035  args = _get_args(args)
9036  if len(args) == 0:
9037  return 1
9038  ctx = _ctx_from_ast_arg_list(args)
9039  if ctx is None:
9040  return _reduce(lambda a, b: a * b, args, 1)
9041  args = _coerce_expr_list(args, ctx)
9042  if is_bv(args[0]):
9043  return _reduce(lambda a, b: a * b, args, 1)
9044  else:
9045  _args, sz = _to_ast_array(args)
9046  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
9047 
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:9023
def is_bv(a)
Definition: z3py.py:3990
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 11634 of file z3py.py.

11634 def PropagateFunction(name, *sig):
11635  """Create a function that gets tracked by user propagator.
11636  Every term headed by this function symbol is tracked.
11637  If a term is fixed and the fixed callback is registered a
11638  callback is invoked that the term headed by this function is fixed.
11639  """
11640  sig = _get_args(sig)
11641  if z3_debug():
11642  _z3_assert(len(sig) > 0, "At least two arguments expected")
11643  arity = len(sig) - 1
11644  rng = sig[arity]
11645  if z3_debug():
11646  _z3_assert(is_sort(rng), "Z3 sort expected")
11647  dom = (Sort * arity)()
11648  for i in range(arity):
11649  if z3_debug():
11650  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
11651  dom[i] = sig[i].ast
11652  ctx = rng.ctx
11653  return FuncDeclRef(Z3_solver_propagate_declare(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
11654 
11655 
11656 
Function Declarations.
Definition: z3py.py:740
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def PropagateFunction(name, sig)
Definition: z3py.py:11634
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 9210 of file z3py.py.

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

9210 def prove(claim, show=False, **keywords):
9211  """Try to prove the given claim.
9212 
9213  This is a simple function for creating demonstrations. It tries to prove
9214  `claim` by showing the negation is unsatisfiable.
9215 
9216  >>> p, q = Bools('p q')
9217  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
9218  proved
9219  """
9220  if z3_debug():
9221  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
9222  s = Solver()
9223  s.set(**keywords)
9224  s.add(Not(claim))
9225  if show:
9226  print(s)
9227  r = s.check()
9228  if r == unsat:
9229  print("proved")
9230  elif r == unknown:
9231  print("failed to prove")
9232  print(s.model())
9233  else:
9234  print("counterexample")
9235  print(s.model())
9236 
9237 
def Not
Definition: z3py.py:1855
def prove(claim, show=False, keywords)
Definition: z3py.py:9210
def z3_debug()
Definition: z3py.py:62
def is_bool(a)
Definition: z3py.py:1611
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 3281 of file z3py.py.

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

3281 def Q(a, b, ctx=None):
3282  """Return a Z3 rational a/b.
3283 
3284  If `ctx=None`, then the global context is used.
3285 
3286  >>> Q(3,5)
3287  3/5
3288  >>> Q(3,5).sort()
3289  Real
3290  """
3291  return simplify(RatVal(a, b, ctx=ctx))
3292 
3293 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8887
def Q
Definition: z3py.py:3281
def RatVal
Definition: z3py.py:3265
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 11405 of file z3py.py.

11405 def Range(lo, hi, ctx=None):
11406  """Create the range regular expression over two sequences of length 1
11407  >>> range = Range("a","z")
11408  >>> print(simplify(InRe("b", range)))
11409  True
11410  >>> print(simplify(InRe("bb", range)))
11411  False
11412  """
11413  lo = _coerce_seq(lo, ctx)
11414  hi = _coerce_seq(hi, ctx)
11415  if z3_debug():
11416  _z3_assert(is_expr(lo), "expression expected")
11417  _z3_assert(is_expr(hi), "expression expected")
11418  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
11419 
def Range
Definition: z3py.py:11405
def z3_debug()
Definition: z3py.py:62
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 is_expr(a)
Definition: z3py.py:1260
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 3265 of file z3py.py.

Referenced by Q().

3265 def RatVal(a, b, ctx=None):
3266  """Return a Z3 rational a/b.
3267 
3268  If `ctx=None`, then the global context is used.
3269 
3270  >>> RatVal(3,5)
3271  3/5
3272  >>> RatVal(3,5).sort()
3273  Real
3274  """
3275  if z3_debug():
3276  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3277  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3278  return simplify(RealVal(a, ctx) / RealVal(b, ctx))
3279 
3280 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8887
def z3_debug()
Definition: z3py.py:62
def RealVal
Definition: z3py.py:3246
def RatVal
Definition: z3py.py:3265
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 11249 of file z3py.py.

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

11249 def Re(s, ctx=None):
11250  """The regular expression that accepts sequence 's'
11251  >>> s1 = Re("ab")
11252  >>> s2 = Re(StringVal("ab"))
11253  >>> s3 = Re(Unit(BoolVal(True)))
11254  """
11255  s = _coerce_seq(s, ctx)
11256  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
11257 
11258 
11259 # Regular expressions
11260 
def Re
Definition: z3py.py:11249
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 3347 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().

3347 def Real(name, ctx=None):
3348  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3349 
3350  >>> x = Real('x')
3351  >>> is_real(x)
3352  True
3353  >>> is_real(x + 1)
3354  True
3355  """
3356  ctx = _get_ctx(ctx)
3357  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3358 
3359 
def RealSort
Definition: z3py.py:3205
def Real
Definition: z3py.py:3347
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 3360 of file z3py.py.

Referenced by is_div().

3360 def Reals(names, ctx=None):
3361  """Return a tuple of real constants.
3362 
3363  >>> x, y, z = Reals('x y z')
3364  >>> Sum(x, y, z)
3365  x + y + z
3366  >>> Sum(x, y, z).sort()
3367  Real
3368  """
3369  ctx = _get_ctx(ctx)
3370  if isinstance(names, str):
3371  names = names.split(" ")
3372  return [Real(name, ctx) for name in names]
3373 
3374 
def Real
Definition: z3py.py:3347
def Reals
Definition: z3py.py:3360
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 3205 of file z3py.py.

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

3205 def RealSort(ctx=None):
3206  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
3207 
3208  >>> RealSort()
3209  Real
3210  >>> x = Const('x', RealSort())
3211  >>> is_real(x)
3212  True
3213  >>> is_int(x)
3214  False
3215  >>> x.sort() == RealSort()
3216  True
3217  """
3218  ctx = _get_ctx(ctx)
3219  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
3220 
3221 
def RealSort
Definition: z3py.py:3205
Arithmetic.
Definition: z3py.py:2338
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 3246 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().

3246 def RealVal(val, ctx=None):
3247  """Return a Z3 real value.
3248 
3249  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3250  If `ctx=None`, then the global context is used.
3251 
3252  >>> RealVal(1)
3253  1
3254  >>> RealVal(1).sort()
3255  Real
3256  >>> RealVal("3/5")
3257  3/5
3258  >>> RealVal("1.5")
3259  3/2
3260  """
3261  ctx = _get_ctx(ctx)
3262  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3263 
3264 
def RealSort
Definition: z3py.py:3205
def RealVal
Definition: z3py.py:3246
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 1503 of file z3py.py.

Referenced by RealVarVector().

1503 def RealVar(idx, ctx=None):
1504  """
1505  Create a real free variable. Free variables are used to create quantified formulas.
1506  They are also used to create polynomials.
1507 
1508  >>> RealVar(0)
1509  Var(0)
1510  """
1511  return Var(idx, RealSort(ctx))
1512 
1513 
def RealSort
Definition: z3py.py:3205
def Var(idx, s)
Definition: z3py.py:1488
def RealVar
Definition: z3py.py:1503
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 1514 of file z3py.py.

1514 def RealVarVector(n, ctx=None):
1515  """
1516  Create a list of Real free variables.
1517  The variables have ids: 0, 1, ..., n-1
1518 
1519  >>> x0, x1, x2, x3 = RealVarVector(4)
1520  >>> x2
1521  Var(2)
1522  """
1523  return [RealVar(i, ctx) for i in range(n)]
1524 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def RealVarVector
Definition: z3py.py:1514
def RealVar
Definition: z3py.py:1503
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 3375 of file z3py.py.

3375 def RealVector(prefix, sz, ctx=None):
3376  """Return a list of real constants of size `sz`.
3377 
3378  >>> X = RealVector('x', 3)
3379  >>> X
3380  [x__0, x__1, x__2]
3381  >>> Sum(X)
3382  x__0 + x__1 + x__2
3383  >>> Sum(X).sort()
3384  Real
3385  """
3386  ctx = _get_ctx(ctx)
3387  return [Real("%s__%s" % (prefix, i), ctx) for i in range(sz)]
3388 
3389 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Real
Definition: z3py.py:3347
def RealVector
Definition: z3py.py:3375
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 945 of file z3py.py.

945 def RecAddDefinition(f, args, body):
946  """Set the body of a recursive function.
947  Recursive definitions can be simplified if they are applied to ground
948  arguments.
949  >>> ctx = Context()
950  >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
951  >>> n = Int('n', ctx)
952  >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
953  >>> simplify(fac(5))
954  120
955  >>> s = Solver(ctx=ctx)
956  >>> s.add(fac(n) < 3)
957  >>> s.check()
958  sat
959  >>> s.model().eval(fac(5))
960  120
961  """
962  if is_app(args):
963  args = [args]
964  ctx = body.ctx
965  args = _get_args(args)
966  n = len(args)
967  _args = (Ast * n)()
968  for i in range(n):
969  _args[i] = args[i].ast
970  Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
971 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def is_app(a)
Definition: z3py.py:1283
def RecAddDefinition(f, args, body)
Definition: z3py.py:945
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 927 of file z3py.py.

927 def RecFunction(name, *sig):
928  """Create a new Z3 recursive with the given sorts."""
929  sig = _get_args(sig)
930  if z3_debug():
931  _z3_assert(len(sig) > 0, "At least two arguments expected")
932  arity = len(sig) - 1
933  rng = sig[arity]
934  if z3_debug():
935  _z3_assert(is_sort(rng), "Z3 sort expected")
936  dom = (Sort * arity)()
937  for i in range(arity):
938  if z3_debug():
939  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
940  dom[i] = sig[i].ast
941  ctx = rng.ctx
942  return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
943 
944 
Function Declarations.
Definition: z3py.py:740
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def RecFunction(name, sig)
Definition: z3py.py:927
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 8535 of file z3py.py.

8535 def Repeat(t, max=4294967295, ctx=None):
8536  """Return a tactic that keeps applying `t` until the goal is not modified anymore
8537  or the maximum number of iterations `max` is reached.
8538 
8539  >>> x, y = Ints('x y')
8540  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
8541  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
8542  >>> r = t(c)
8543  >>> for subgoal in r: print(subgoal)
8544  [x == 0, y == 0, x > y]
8545  [x == 0, y == 1, x > y]
8546  [x == 1, y == 0, x > y]
8547  [x == 1, y == 1, x > y]
8548  >>> t = Then(t, Tactic('propagate-values'))
8549  >>> t(c)
8550  [[x == 1, y == 0]]
8551  """
8552  t = _to_tactic(t, ctx)
8553  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
8554 
8555 
def Repeat
Definition: z3py.py:8535
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 4467 of file z3py.py.

4467 def RepeatBitVec(n, a):
4468  """Return an expression representing `n` copies of `a`.
4469 
4470  >>> x = BitVec('x', 8)
4471  >>> n = RepeatBitVec(4, x)
4472  >>> n
4473  RepeatBitVec(4, x)
4474  >>> n.size()
4475  32
4476  >>> v0 = BitVecVal(10, 4)
4477  >>> print("%.x" % v0.as_long())
4478  a
4479  >>> v = simplify(RepeatBitVec(4, v0))
4480  >>> v.size()
4481  16
4482  >>> print("%.x" % v.as_long())
4483  aaaa
4484  """
4485  if z3_debug():
4486  _z3_assert(_is_int(n), "First argument must be an integer")
4487  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4488  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4489 
4490 
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:3990
def RepeatBitVec(n, a)
Definition: z3py.py:4467
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 11160 of file z3py.py.

11160 def Replace(s, src, dst):
11161  """Replace the first occurrence of 'src' by 'dst' in 's'
11162  >>> r = Replace("aaa", "a", "b")
11163  >>> simplify(r)
11164  "baa"
11165  """
11166  ctx = _get_ctx2(dst, s)
11167  if ctx is None and is_expr(src):
11168  ctx = src.ctx
11169  src = _coerce_seq(src, ctx)
11170  dst = _coerce_seq(dst, ctx)
11171  s = _coerce_seq(s, ctx)
11172  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
11173 
11174 
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:11160
def is_expr(a)
Definition: z3py.py:1260
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 11268 of file z3py.py.

Referenced by Empty(), and Full().

11268 def ReSort(s):
11269  if is_ast(s):
11270  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
11271  if s is None or isinstance(s, Context):
11272  ctx = _get_ctx(s)
11273  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
11274  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
11275 
11276 
def ReSort(s)
Definition: z3py.py:11268
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 9797 of file z3py.py.

Referenced by get_default_rounding_mode().

9797 def RNA(ctx=None):
9798  ctx = _get_ctx(ctx)
9799  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9800 
9801 
def RNA
Definition: z3py.py:9797
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 9787 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().

9787 def RNE(ctx=None):
9788  ctx = _get_ctx(ctx)
9789  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9790 
9791 
def RNE
Definition: z3py.py:9787
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 4377 of file z3py.py.

4377 def RotateLeft(a, b):
4378  """Return an expression representing `a` rotated to the left `b` times.
4379 
4380  >>> a, b = BitVecs('a b', 16)
4381  >>> RotateLeft(a, b)
4382  RotateLeft(a, b)
4383  >>> simplify(RotateLeft(a, 0))
4384  a
4385  >>> simplify(RotateLeft(a, 16))
4386  a
4387  """
4388  _check_bv_args(a, b)
4389  a, b = _coerce_exprs(a, b)
4390  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4391 
4392 
def RotateLeft(a, b)
Definition: z3py.py:4377
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 4393 of file z3py.py.

4393 def RotateRight(a, b):
4394  """Return an expression representing `a` rotated to the right `b` times.
4395 
4396  >>> a, b = BitVecs('a b', 16)
4397  >>> RotateRight(a, b)
4398  RotateRight(a, b)
4399  >>> simplify(RotateRight(a, 0))
4400  a
4401  >>> simplify(RotateRight(a, 16))
4402  a
4403  """
4404  _check_bv_args(a, b)
4405  a, b = _coerce_exprs(a, b)
4406  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4407 
4408 
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:4393
def z3py.RoundNearestTiesToAway (   ctx = None)

Definition at line 9792 of file z3py.py.

9793  ctx = _get_ctx(ctx)
9794  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9795 
9796 
def RoundNearestTiesToAway
Definition: z3py.py:9792
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 9782 of file z3py.py.

9783  ctx = _get_ctx(ctx)
9784  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9785 
9786 
def RoundNearestTiesToEven
Definition: z3py.py:9782
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 9812 of file z3py.py.

9812 def RoundTowardNegative(ctx=None):
9813  ctx = _get_ctx(ctx)
9814  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9815 
9816 
def RoundTowardNegative
Definition: z3py.py:9812
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 9802 of file z3py.py.

9802 def RoundTowardPositive(ctx=None):
9803  ctx = _get_ctx(ctx)
9804  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9805 
9806 
def RoundTowardPositive
Definition: z3py.py:9802
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 9822 of file z3py.py.

9822 def RoundTowardZero(ctx=None):
9823  ctx = _get_ctx(ctx)
9824  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9825 
9826 
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:9822
def z3py.RTN (   ctx = None)

Definition at line 9817 of file z3py.py.

Referenced by get_default_rounding_mode().

9817 def RTN(ctx=None):
9818  ctx = _get_ctx(ctx)
9819  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9820 
9821 
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:9817
def z3py.RTP (   ctx = None)

Definition at line 9807 of file z3py.py.

Referenced by get_default_rounding_mode().

9807 def RTP(ctx=None):
9808  ctx = _get_ctx(ctx)
9809  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9810 
9811 
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:9807
def z3py.RTZ (   ctx = None)

Definition at line 9827 of file z3py.py.

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

9827 def RTZ(ctx=None):
9828  ctx = _get_ctx(ctx)
9829  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9830 
9831 
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:9827
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 4853 of file z3py.py.

4853 def Select(a, *args):
4854  """Return a Z3 select array expression.
4855 
4856  >>> a = Array('a', IntSort(), IntSort())
4857  >>> i = Int('i')
4858  >>> Select(a, i)
4859  a[i]
4860  >>> eq(Select(a, i), a[i])
4861  True
4862  """
4863  args = _get_args(args)
4864  if z3_debug():
4865  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4866  return a[args]
4867 
4868 
def is_array_sort(a)
Definition: z3py.py:4653
def Select(a, args)
Definition: z3py.py:4853
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 10881 of file z3py.py.

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

10881 def SeqSort(s):
10882  """Create a sequence sort over elements provided in the argument
10883  >>> s = SeqSort(IntSort())
10884  >>> s == Unit(IntVal(1)).sort()
10885  True
10886  """
10887  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10888 
10889 
def SeqSort(s)
Definition: z3py.py:10881
Strings, Sequences and Regular expressions.
Definition: z3py.py:10841
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 9443 of file z3py.py.

9443 def set_default_fp_sort(ebits, sbits, ctx=None):
9444  global _dflt_fpsort_ebits
9445  global _dflt_fpsort_sbits
9446  _dflt_fpsort_ebits = ebits
9447  _dflt_fpsort_sbits = sbits
9448 
9449 
def set_default_fp_sort
Definition: z3py.py:9443
def z3py.set_default_rounding_mode (   rm,
  ctx = None 
)

Definition at line 9430 of file z3py.py.

9430 def set_default_rounding_mode(rm, ctx=None):
9431  global _dflt_rounding_mode
9432  if is_fprm_value(rm):
9433  _dflt_rounding_mode = rm.decl().kind()
9434  else:
9435  _z3_assert(_dflt_rounding_mode in _ROUNDING_MODES, "illegal rounding mode")
9436  _dflt_rounding_mode = rm
9437 
9438 
def is_fprm_value(a)
Definition: z3py.py:9845
def set_default_rounding_mode
Definition: z3py.py:9430
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 5012 of file z3py.py.

5012 def SetAdd(s, e):
5013  """ Add element e to set s
5014  >>> a = Const('a', SetSort(IntSort()))
5015  >>> SetAdd(a, 1)
5016  Store(a, 1, True)
5017  """
5018  ctx = _ctx_from_ast_arg_list([s, e])
5019  e = _py2expr(e, ctx)
5020  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5021 
5022 
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:5012
def z3py.SetComplement (   s)
The complement of set s
>>> a = Const('a', SetSort(IntSort()))
>>> SetComplement(a)
complement(a)

Definition at line 5034 of file z3py.py.

5035  """ The complement of set s
5036  >>> a = Const('a', SetSort(IntSort()))
5037  >>> SetComplement(a)
5038  complement(a)
5039  """
5040  ctx = s.ctx
5041  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
5042 
5043 
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:5034
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 5023 of file z3py.py.

5023 def SetDel(s, e):
5024  """ Remove element e to set s
5025  >>> a = Const('a', SetSort(IntSort()))
5026  >>> SetDel(a, 1)
5027  Store(a, 1, False)
5028  """
5029  ctx = _ctx_from_ast_arg_list([s, e])
5030  e = _py2expr(e, ctx)
5031  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
5032 
5033 
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:5023
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 5044 of file z3py.py.

5044 def SetDifference(a, b):
5045  """ The set difference of a and b
5046  >>> a = Const('a', SetSort(IntSort()))
5047  >>> b = Const('b', SetSort(IntSort()))
5048  >>> SetDifference(a, b)
5049  setminus(a, b)
5050  """
5051  ctx = _ctx_from_ast_arg_list([a, b])
5052  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
5053 
5054 
def SetDifference(a, b)
Definition: z3py.py:5044
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 4926 of file z3py.py.

4926 def SetHasSize(a, k):
4927  ctx = a.ctx
4928  k = _py2expr(k, ctx)
4929  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4930 
4931 
def SetHasSize(a, k)
Definition: z3py.py:4926
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 4999 of file z3py.py.

4999 def SetIntersect(*args):
5000  """ Take the union of sets
5001  >>> a = Const('a', SetSort(IntSort()))
5002  >>> b = Const('b', SetSort(IntSort()))
5003  >>> SetIntersect(a, b)
5004  intersection(a, b)
5005  """
5006  args = _get_args(args)
5007  ctx = _ctx_from_ast_arg_list(args)
5008  _args, sz = _to_ast_array(args)
5009  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
5010 
5011 
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:4999
def z3py.SetSort (   s)

Sets.

Create a set sort over element sort s

Definition at line 4963 of file z3py.py.

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

4963 def SetSort(s):
4964  """ Create a set sort over element sort s"""
4965  return ArraySort(s, BoolSort())
4966 
4967 
def BoolSort
Definition: z3py.py:1731
def ArraySort(sig)
Definition: z3py.py:4746
def SetSort(s)
Sets.
Definition: z3py.py:4963
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 4986 of file z3py.py.

4986 def SetUnion(*args):
4987  """ Take the union of sets
4988  >>> a = Const('a', SetSort(IntSort()))
4989  >>> b = Const('b', SetSort(IntSort()))
4990  >>> SetUnion(a, b)
4991  union(a, b)
4992  """
4993  args = _get_args(args)
4994  ctx = _ctx_from_ast_arg_list(args)
4995  _args, sz = _to_ast_array(args)
4996  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4997 
4998 
def SetUnion(args)
Definition: z3py.py:4986
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 4409 of file z3py.py.

4409 def SignExt(n, a):
4410  """Return a bit-vector expression with `n` extra sign-bits.
4411 
4412  >>> x = BitVec('x', 16)
4413  >>> n = SignExt(8, x)
4414  >>> n.size()
4415  24
4416  >>> n
4417  SignExt(8, x)
4418  >>> n.sort()
4419  BitVec(24)
4420  >>> v0 = BitVecVal(2, 2)
4421  >>> v0
4422  2
4423  >>> v0.size()
4424  2
4425  >>> v = simplify(SignExt(6, v0))
4426  >>> v
4427  254
4428  >>> v.size()
4429  8
4430  >>> print("%.x" % v.as_long())
4431  fe
4432  """
4433  if z3_debug():
4434  _z3_assert(_is_int(n), "First argument must be an integer")
4435  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4436  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4437 
4438 
def SignExt(n, a)
Definition: z3py.py:4409
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:3990
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 7479 of file z3py.py.

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

7479 def SimpleSolver(ctx=None, logFile=None):
7480  """Return a simple general purpose solver with limited amount of preprocessing.
7481 
7482  >>> s = SimpleSolver()
7483  >>> x = Int('x')
7484  >>> s.add(x > 0)
7485  >>> s.check()
7486  sat
7487  """
7488  ctx = _get_ctx(ctx)
7489  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
7490 
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
def SimpleSolver
Definition: z3py.py:7479
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 8887 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().

8887 def simplify(a, *arguments, **keywords):
8888  """Simplify the expression `a` using the given options.
8889 
8890  This function has many options. Use `help_simplify` to obtain the complete list.
8891 
8892  >>> x = Int('x')
8893  >>> y = Int('y')
8894  >>> simplify(x + 1 + y + x + 1)
8895  2 + 2*x + y
8896  >>> simplify((x + 1)*(y + 1), som=True)
8897  1 + x + y + x*y
8898  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8899  And(Not(x == y), Not(x == 1), Not(y == 1))
8900  >>> simplify(And(x == 0, y == 1), elim_and=True)
8901  Not(Or(Not(x == 0), Not(y == 1)))
8902  """
8903  if z3_debug():
8904  _z3_assert(is_expr(a), "Z3 expression expected")
8905  if len(arguments) > 0 or len(keywords) > 0:
8906  p = args2params(arguments, keywords, a.ctx)
8907  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8908  else:
8909  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8910 
8911 
def simplify(a, arguments, keywords)
Utils.
Definition: z3py.py:8887
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
def args2params
Definition: z3py.py:5512
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:1260
def z3py.simplify_param_descrs ( )
Return the set of parameter descriptions for Z3 `simplify` procedure.

Definition at line 8917 of file z3py.py.

8918  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8920 
8921 
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:8917
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 9149 of file z3py.py.

Referenced by BV2Int(), and IsInt().

9149 def solve(*args, **keywords):
9150  """Solve the constraints `*args`.
9151 
9152  This is a simple function for creating demonstrations. It creates a solver,
9153  configure it using the options in `keywords`, adds the constraints
9154  in `args`, and invokes check.
9155 
9156  >>> a = Int('a')
9157  >>> solve(a > 0, a < 2)
9158  [a = 1]
9159  """
9160  show = keywords.pop("show", False)
9161  s = Solver()
9162  s.set(**keywords)
9163  s.add(*args)
9164  if show:
9165  print(s)
9166  r = s.check()
9167  if r == unsat:
9168  print("no solution")
9169  elif r == unknown:
9170  print("failed to solve")
9171  try:
9172  print(s.model())
9173  except Z3Exception:
9174  return
9175  else:
9176  print(s.model())
9177 
9178 
def solve(args, keywords)
Definition: z3py.py:9149
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 9179 of file z3py.py.

9179 def solve_using(s, *args, **keywords):
9180  """Solve the constraints `*args` using solver `s`.
9181 
9182  This is a simple function for creating demonstrations. It is similar to `solve`,
9183  but it uses the given solver `s`.
9184  It configures solver `s` using the options in `keywords`, adds the constraints
9185  in `args`, and invokes check.
9186  """
9187  show = keywords.pop("show", False)
9188  if z3_debug():
9189  _z3_assert(isinstance(s, Solver), "Solver object expected")
9190  s.set(**keywords)
9191  s.add(*args)
9192  if show:
9193  print("Problem:")
9194  print(s)
9195  r = s.check()
9196  if r == unsat:
9197  print("no solution")
9198  elif r == unknown:
9199  print("failed to solve")
9200  try:
9201  print(s.model())
9202  except Z3Exception:
9203  return
9204  else:
9205  if show:
9206  print("Solution:")
9207  print(s.model())
9208 
9209 
def solve_using(s, args, keywords)
Definition: z3py.py:9179
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 7458 of file z3py.py.

7458 def SolverFor(logic, ctx=None, logFile=None):
7459  """Create a solver customized for the given logic.
7460 
7461  The parameter `logic` is a string. It should be contains
7462  the name of a SMT-LIB logic.
7463  See http://www.smtlib.org/ for the name of all available logics.
7464 
7465  >>> s = SolverFor("QF_LIA")
7466  >>> x = Int('x')
7467  >>> s.add(x > 0)
7468  >>> s.add(x < 2)
7469  >>> s.check()
7470  sat
7471  >>> s.model()
7472  [x = 1]
7473  """
7474  ctx = _get_ctx(ctx)
7475  logic = to_symbol(logic)
7476  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
7477 
7478 
def SolverFor
Definition: z3py.py:7458
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 3457 of file z3py.py.

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

3457 def Sqrt(a, ctx=None):
3458  """ Return a Z3 expression which represents the square root of a.
3459 
3460  >>> x = Real('x')
3461  >>> Sqrt(x)
3462  x**(1/2)
3463  """
3464  if not is_expr(a):
3465  ctx = _get_ctx(ctx)
3466  a = RealVal(a, ctx)
3467  return a ** "1/2"
3468 
3469 
def RealVal
Definition: z3py.py:3246
def is_expr(a)
Definition: z3py.py:1260
def Sqrt
Definition: z3py.py:3457
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 4324 of file z3py.py.

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

4324 def SRem(a, b):
4325  """Create the Z3 expression signed remainder.
4326 
4327  Use the operator % for signed modulus, and URem() for unsigned remainder.
4328 
4329  >>> x = BitVec('x', 32)
4330  >>> y = BitVec('y', 32)
4331  >>> SRem(x, y)
4332  SRem(x, y)
4333  >>> SRem(x, y).sort()
4334  BitVec(32)
4335  >>> (x % y).sexpr()
4336  '(bvsmod x y)'
4337  >>> SRem(x, y).sexpr()
4338  '(bvsrem x y)'
4339  """
4340  _check_bv_args(a, b)
4341  a, b = _coerce_exprs(a, b)
4342  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4343 
4344 
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:4324
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 11375 of file z3py.py.

11375 def Star(re):
11376  """Create the regular expression accepting zero or more repetitions of argument.
11377  >>> re = Star(Re("a"))
11378  >>> print(simplify(InRe("aa", re)))
11379  True
11380  >>> print(simplify(InRe("ab", re)))
11381  False
11382  >>> print(simplify(InRe("", re)))
11383  True
11384  """
11385  if z3_debug():
11386  _z3_assert(is_expr(re), "expression expected")
11387  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
11388 
11389 
def Star(re)
Definition: z3py.py:11375
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
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 4836 of file z3py.py.

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

4836 def Store(a, *args):
4837  """Return a Z3 store array expression.
4838 
4839  >>> a = Array('a', IntSort(), IntSort())
4840  >>> i, v = Ints('i v')
4841  >>> s = Store(a, i, v)
4842  >>> s.sort()
4843  Array(Int, Int)
4844  >>> prove(s[i] == v)
4845  proved
4846  >>> j = Int('j')
4847  >>> prove(Implies(i != j, s[j] == a[j]))
4848  proved
4849  """
4850  return Update(a, args)
4851 
4852 
def Update(a, args)
Definition: z3py.py:4793
def Store(a, args)
Definition: z3py.py:4836
def z3py.StrFromCode (   c)
Convert code to a string

Definition at line 11243 of file z3py.py.

11244  """Convert code to a string"""
11245  if not is_expr(c):
11246  c = _py2expr(c)
11247  return SeqRef(Z3_mk_string_from_code(c.ctx_ref(), c.as_ast()), c.ctx)
11248 
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:11243
def is_expr(a)
Definition: z3py.py:1260
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 11044 of file z3py.py.

11044 def String(name, ctx=None):
11045  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
11046 
11047  >>> x = String('x')
11048  """
11049  ctx = _get_ctx(ctx)
11050  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
11051 
11052 
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:11044
def to_symbol
Definition: z3py.py:124
def StringSort
Definition: z3py.py:10862
def z3py.Strings (   names,
  ctx = None 
)
Return a tuple of String constants. 

Definition at line 11053 of file z3py.py.

Referenced by Contains().

11053 def Strings(names, ctx=None):
11054  """Return a tuple of String constants. """
11055  ctx = _get_ctx(ctx)
11056  if isinstance(names, str):
11057  names = names.split(" ")
11058  return [String(name, ctx) for name in names]
11059 
11060 
def String
Definition: z3py.py:11044
def Strings
Definition: z3py.py:11053
def z3py.StringSort (   ctx = None)
Create a string sort
>>> s = StringSort()
>>> print(s)
String

Definition at line 10862 of file z3py.py.

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

10862 def StringSort(ctx=None):
10863  """Create a string sort
10864  >>> s = StringSort()
10865  >>> print(s)
10866  String
10867  """
10868  ctx = _get_ctx(ctx)
10869  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10870 
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:10841
def StringSort
Definition: z3py.py:10862
def z3py.StringVal (   s,
  ctx = None 
)
create a string expression

Definition at line 11037 of file z3py.py.

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

11037 def StringVal(s, ctx=None):
11038  """create a string expression"""
11039  s = "".join(str(ch) if 32 <= ord(ch) and ord(ch) < 127 else "\\u{%x}" % (ord(ch)) for ch in s)
11040  ctx = _get_ctx(ctx)
11041  return SeqRef(Z3_mk_string(ctx.ref(), s), ctx)
11042 
11043 
def StringVal
Definition: z3py.py:11037
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 11237 of file z3py.py.

11237 def StrToCode(s):
11238  """Convert a unit length string to integer code"""
11239  if not is_expr(s):
11240  s = _py2expr(s)
11241  return ArithRef(Z3_mk_string_to_code(s.ctx_ref(), s.as_ast()), s.ctx)
11242 
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:1260
def StrToCode(s)
Definition: z3py.py:11237
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 11214 of file z3py.py.

11214 def StrToInt(s):
11215  """Convert string expression to integer
11216  >>> a = StrToInt("1")
11217  >>> simplify(1 == a)
11218  True
11219  >>> b = StrToInt("2")
11220  >>> simplify(1 == b)
11221  False
11222  >>> c = StrToInt(IntToStr(2))
11223  >>> simplify(1 == c)
11224  False
11225  """
11226  s = _coerce_seq(s)
11227  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
11228 
11229 
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:11214
def z3py.SubSeq (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 11066 of file z3py.py.

11066 def SubSeq(s, offset, length):
11067  """Extract substring or subsequence starting at offset"""
11068  return Extract(s, offset, length)
11069 
11070 
def SubSeq(s, offset, length)
Definition: z3py.py:11066
def Extract(high, low, a)
Definition: z3py.py:4174
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 8922 of file z3py.py.

8922 def substitute(t, *m):
8923  """Apply substitution m on t, m is a list of pairs of the form (from, to).
8924  Every occurrence in t of from is replaced with to.
8925 
8926  >>> x = Int('x')
8927  >>> y = Int('y')
8928  >>> substitute(x + 1, (x, y + 1))
8929  y + 1 + 1
8930  >>> f = Function('f', IntSort(), IntSort())
8931  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8932  1 + 1
8933  """
8934  if isinstance(m, tuple):
8935  m1 = _get_args(m)
8936  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8937  m = m1
8938  if z3_debug():
8939  _z3_assert(is_expr(t), "Z3 expression expected")
8940  _z3_assert(
8941  all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) for p in m]),
8942  "Z3 invalid substitution, expression pairs expected.")
8943  _z3_assert(
8944  all([p[0].sort().eq(p[1].sort()) for p in m]),
8945  'Z3 invalid substitution, mismatching "from" and "to" sorts.')
8946  num = len(m)
8947  _from = (Ast * num)()
8948  _to = (Ast * num)()
8949  for i in range(num):
8950  _from[i] = m[i][0].as_ast()
8951  _to[i] = m[i][1].as_ast()
8952  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8953 
8954 
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:8922
def eq(a, b)
Definition: z3py.py:472
def z3_debug()
Definition: z3py.py:62
def is_expr(a)
Definition: z3py.py:1260
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 8975 of file z3py.py.

8975 def substitute_funs(t, *m):
8976  """Apply substitution m on t, m is a list of pairs of a function and expression (from, to)
8977  Every occurrence in to of the function from is replaced with the expression to.
8978  The expression to can have free variables, that refer to the arguments of from.
8979  For examples, see
8980  """
8981  if isinstance(m, tuple):
8982  m1 = _get_args(m)
8983  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8984  m = m1
8985  if z3_debug():
8986  _z3_assert(is_expr(t), "Z3 expression expected")
8987  _z3_assert(all([isinstance(p, tuple) and is_func_decl(p[0]) and is_expr(p[1]) for p in m]), "Z3 invalid substitution, function pairs expected.")
8988  num = len(m)
8989  _from = (FuncDecl * num)()
8990  _to = (Ast * num)()
8991  for i in range(num):
8992  _from[i] = m[i][0].as_func_decl()
8993  _to[i] = m[i][1].as_ast()
8994  return _to_expr_ref(Z3_substitute_funs(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8995 
8996 
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:1260
def substitute_funs(t, m)
Definition: z3py.py:8975
def is_func_decl(a)
Definition: z3py.py:868
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 functions 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 8955 of file z3py.py.

8955 def substitute_vars(t, *m):
8956  """Substitute the free variables in t with the expression in m.
8957 
8958  >>> v0 = Var(0, IntSort())
8959  >>> v1 = Var(1, IntSort())
8960  >>> x = Int('x')
8961  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8962  >>> # replace v0 with x+1 and v1 with x
8963  >>> substitute_vars(f(v0, v1), x + 1, x)
8964  f(x + 1, x)
8965  """
8966  if z3_debug():
8967  _z3_assert(is_expr(t), "Z3 expression expected")
8968  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8969  num = len(m)
8970  _to = (Ast * num)()
8971  for i in range(num):
8972  _to[i] = m[i].as_ast()
8973  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8974 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def substitute_vars(t, m)
Definition: z3py.py:8955
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:1260
def z3py.SubString (   s,
  offset,
  length 
)
Extract substring or subsequence starting at offset

Definition at line 11061 of file z3py.py.

11061 def SubString(s, offset, length):
11062  """Extract substring or subsequence starting at offset"""
11063  return Extract(s, offset, length)
11064 
11065 
def SubString(s, offset, length)
Definition: z3py.py:11061
def Extract(high, low, a)
Definition: z3py.py:4174
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 11126 of file z3py.py.

11126 def SuffixOf(a, b):
11127  """Check if 'a' is a suffix of 'b'
11128  >>> s1 = SuffixOf("ab", "abc")
11129  >>> simplify(s1)
11130  False
11131  >>> s2 = SuffixOf("bc", "abc")
11132  >>> simplify(s2)
11133  True
11134  """
11135  ctx = _get_ctx2(a, b)
11136  a = _coerce_seq(a, ctx)
11137  b = _coerce_seq(b, ctx)
11138  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
11139 
11140 
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:11126
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 8997 of file z3py.py.

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

8997 def Sum(*args):
8998  """Create the sum of the Z3 expressions.
8999 
9000  >>> a, b, c = Ints('a b c')
9001  >>> Sum(a, b, c)
9002  a + b + c
9003  >>> Sum([a, b, c])
9004  a + b + c
9005  >>> A = IntVector('a', 5)
9006  >>> Sum(A)
9007  a__0 + a__1 + a__2 + a__3 + a__4
9008  """
9009  args = _get_args(args)
9010  if len(args) == 0:
9011  return 0
9012  ctx = _ctx_from_ast_arg_list(args)
9013  if ctx is None:
9014  return _reduce(lambda a, b: a + b, args, 0)
9015  args = _coerce_expr_list(args, ctx)
9016  if is_bv(args[0]):
9017  return _reduce(lambda a, b: a + b, args, 0)
9018  else:
9019  _args, sz = _to_ast_array(args)
9020  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
9021 
9022 
def Sum(args)
Definition: z3py.py:8997
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:3990
def z3py.tactic_description (   name,
  ctx = None 
)
Return a short description for the tactic named `name`.

>>> d = tactic_description('simplify')

Definition at line 8576 of file z3py.py.

Referenced by describe_tactics().

8576 def tactic_description(name, ctx=None):
8577  """Return a short description for the tactic named `name`.
8578 
8579  >>> d = tactic_description('simplify')
8580  """
8581  ctx = _get_ctx(ctx)
8582  return Z3_tactic_get_descr(ctx.ref(), name)
8583 
8584 
def tactic_description
Definition: z3py.py:8576
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 8565 of file z3py.py.

Referenced by describe_tactics().

8565 def tactics(ctx=None):
8566  """Return a list of all available tactics in Z3.
8567 
8568  >>> l = tactics()
8569  >>> l.count('simplify') == 1
8570  True
8571  """
8572  ctx = _get_ctx(ctx)
8573  return [Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref()))]
8574 
8575 
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:8565
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 8433 of file z3py.py.

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

8433 def Then(*ts, **ks):
8434  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
8435 
8436  >>> x, y = Ints('x y')
8437  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
8438  >>> t(And(x == 0, y > x + 1))
8439  [[Not(y <= 1)]]
8440  >>> t(And(x == 0, y > x + 1)).as_expr()
8441  Not(y <= 1)
8442  """
8443  return AndThen(*ts, **ks)
8444 
8445 
def Then(ts, ks)
Definition: z3py.py:8433
def AndThen(ts, ks)
Definition: z3py.py:8413
def z3py.to_Ast (   ptr)

Definition at line 11459 of file z3py.py.

Referenced by on_clause_eh().

11459 def to_Ast(ptr,):
11460  ast = Ast(ptr)
11461  super(ctypes.c_void_p, ast).__init__(ptr)
11462  return ast
11463 
def to_Ast(ptr)
Definition: z3py.py:11459
def z3py.to_AstVectorObj (   ptr)

Definition at line 11469 of file z3py.py.

Referenced by on_clause_eh().

11470  v = AstVectorObj(ptr)
11471  super(ctypes.c_void_p, v).__init__(ptr)
11472  return v
11473 
11474 # NB. my-hacky-class only works for a single instance of OnClause
11475 # it should be replaced with a proper correlation between OnClause
11476 # and object references that can be passed over the FFI.
11477 # for UserPropagator we use a global dictionary, which isn't great code.
11478 
def to_AstVectorObj(ptr)
Definition: z3py.py:11469
def z3py.to_ContextObj (   ptr)

Definition at line 11464 of file z3py.py.

11464 def to_ContextObj(ptr,):
11465  ctx = ContextObj(ptr)
11466  super(ctypes.c_void_p, ctx).__init__(ptr)
11467  return ctx
11468 
def to_ContextObj(ptr)
Definition: z3py.py:11464
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(), DeclareTypeVar(), 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 3422 of file z3py.py.

Referenced by is_to_int().

3422 def ToInt(a):
3423  """ Return the Z3 expression ToInt(a).
3424 
3425  >>> x = Real('x')
3426  >>> x.sort()
3427  Real
3428  >>> n = ToInt(x)
3429  >>> n
3430  ToInt(x)
3431  >>> n.sort()
3432  Int
3433  """
3434  if z3_debug():
3435  _z3_assert(a.is_real(), "Z3 real expression expected.")
3436  ctx = a.ctx
3437  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3438 
3439 
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:3422
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 3404 of file z3py.py.

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

3404 def ToReal(a):
3405  """ Return the Z3 expression ToReal(a).
3406 
3407  >>> x = Int('x')
3408  >>> x.sort()
3409  Int
3410  >>> n = ToReal(x)
3411  >>> n
3412  ToReal(x)
3413  >>> n.sort()
3414  Real
3415  """
3416  if z3_debug():
3417  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3418  ctx = a.ctx
3419  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3420 
3421 
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:3404
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 11452 of file z3py.py.

11453  """Given a binary relation R, such that the two arguments have the same sort
11454  create the transitive closure relation R+.
11455  The transitive closure R+ is a new relation.
11456  """
11457  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
11458 
def TransitiveClosure(f)
Definition: z3py.py:11452
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:740
def z3py.TreeOrder (   a,
  index 
)

Definition at line 11444 of file z3py.py.

11444 def TreeOrder(a, index):
11445  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx)
11446 
11447 
Function Declarations.
Definition: z3py.py:740
def TreeOrder(a, index)
Definition: z3py.py:11444
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 8556 of file z3py.py.

8556 def TryFor(t, ms, ctx=None):
8557  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
8558 
8559  If `t` does not terminate in `ms` milliseconds, then it fails.
8560  """
8561  t = _to_tactic(t, ctx)
8562  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
8563 
8564 
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:8556
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 5409 of file z3py.py.

5409 def TupleSort(name, sorts, ctx=None):
5410  """Create a named tuple sort base on a set of underlying sorts
5411  Example:
5412  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5413  """
5414  tuple = Datatype(name, ctx)
5415  projects = [("project%d" % i, sorts[i]) for i in range(len(sorts))]
5416  tuple.declare(name, *projects)
5417  tuple = tuple.create()
5418  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5419 
5420 
def TupleSort
Definition: z3py.py:5409
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 4282 of file z3py.py.

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

4282 def UDiv(a, b):
4283  """Create the Z3 expression (unsigned) division `self / other`.
4284 
4285  Use the operator / for signed division.
4286 
4287  >>> x = BitVec('x', 32)
4288  >>> y = BitVec('y', 32)
4289  >>> UDiv(x, y)
4290  UDiv(x, y)
4291  >>> UDiv(x, y).sort()
4292  BitVec(32)
4293  >>> (x / y).sexpr()
4294  '(bvsdiv x y)'
4295  >>> UDiv(x, y).sexpr()
4296  '(bvudiv x y)'
4297  """
4298  _check_bv_args(a, b)
4299  a, b = _coerce_exprs(a, b)
4300  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4301 
4302 
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:4282
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 4246 of file z3py.py.

Referenced by BitVecRef.__ge__().

4246 def UGE(a, b):
4247  """Create the Z3 expression (unsigned) `other >= self`.
4248 
4249  Use the operator >= for signed greater than or equal to.
4250 
4251  >>> x, y = BitVecs('x y', 32)
4252  >>> UGE(x, y)
4253  UGE(x, y)
4254  >>> (x >= y).sexpr()
4255  '(bvsge x y)'
4256  >>> UGE(x, y).sexpr()
4257  '(bvuge x y)'
4258  """
4259  _check_bv_args(a, b)
4260  a, b = _coerce_exprs(a, b)
4261  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4262 
4263 
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:4246
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 4264 of file z3py.py.

Referenced by BitVecRef.__gt__().

4264 def UGT(a, b):
4265  """Create the Z3 expression (unsigned) `other > self`.
4266 
4267  Use the operator > for signed greater than.
4268 
4269  >>> x, y = BitVecs('x y', 32)
4270  >>> UGT(x, y)
4271  UGT(x, y)
4272  >>> (x > y).sexpr()
4273  '(bvsgt x y)'
4274  >>> UGT(x, y).sexpr()
4275  '(bvugt x y)'
4276  """
4277  _check_bv_args(a, b)
4278  a, b = _coerce_exprs(a, b)
4279  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4280 
4281 
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:4264
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 4210 of file z3py.py.

Referenced by BitVecRef.__le__().

4210 def ULE(a, b):
4211  """Create the Z3 expression (unsigned) `other <= self`.
4212 
4213  Use the operator <= for signed less than or equal to.
4214 
4215  >>> x, y = BitVecs('x y', 32)
4216  >>> ULE(x, y)
4217  ULE(x, y)
4218  >>> (x <= y).sexpr()
4219  '(bvsle x y)'
4220  >>> ULE(x, y).sexpr()
4221  '(bvule x y)'
4222  """
4223  _check_bv_args(a, b)
4224  a, b = _coerce_exprs(a, b)
4225  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4226 
4227 
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:4210
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 4228 of file z3py.py.

Referenced by BitVecRef.__lt__().

4228 def ULT(a, b):
4229  """Create the Z3 expression (unsigned) `other < self`.
4230 
4231  Use the operator < for signed less than.
4232 
4233  >>> x, y = BitVecs('x y', 32)
4234  >>> ULT(x, y)
4235  ULT(x, y)
4236  >>> (x < y).sexpr()
4237  '(bvslt x y)'
4238  >>> ULT(x, y).sexpr()
4239  '(bvult x y)'
4240  """
4241  _check_bv_args(a, b)
4242  a, b = _coerce_exprs(a, b)
4243  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4244 
4245 
def ULT(a, b)
Definition: z3py.py:4228
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 11302 of file z3py.py.

Referenced by InRe().

11302 def Union(*args):
11303  """Create union of regular expressions.
11304  >>> re = Union(Re("a"), Re("b"), Re("c"))
11305  >>> print (simplify(InRe("d", re)))
11306  False
11307  """
11308  args = _get_args(args)
11309  sz = len(args)
11310  if z3_debug():
11311  _z3_assert(sz > 0, "At least one argument expected.")
11312  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
11313  if sz == 1:
11314  return args[0]
11315  ctx = args[0].ctx
11316  v = (Ast * sz)()
11317  for i in range(sz):
11318  v[i] = args[i].as_ast()
11319  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
11320 
11321 
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
def Union(args)
Definition: z3py.py:11302
def is_re(s)
Definition: z3py.py:11284
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 11106 of file z3py.py.

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

11106 def Unit(a):
11107  """Create a singleton sequence"""
11108  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
11109 
11110 
def Unit(a)
Definition: z3py.py:11106
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 4793 of file z3py.py.

Referenced by Store().

4793 def Update(a, *args):
4794  """Return a Z3 store array expression.
4795 
4796  >>> a = Array('a', IntSort(), IntSort())
4797  >>> i, v = Ints('i v')
4798  >>> s = Update(a, i, v)
4799  >>> s.sort()
4800  Array(Int, Int)
4801  >>> prove(s[i] == v)
4802  proved
4803  >>> j = Int('j')
4804  >>> prove(Implies(i != j, s[j] == a[j]))
4805  proved
4806  """
4807  if z3_debug():
4808  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4809  args = _get_args(args)
4810  ctx = a.ctx
4811  if len(args) <= 1:
4812  raise Z3Exception("array update requires index and value arguments")
4813  if len(args) == 2:
4814  i = args[0]
4815  v = args[1]
4816  i = a.sort().domain().cast(i)
4817  v = a.sort().range().cast(v)
4818  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4819  v = a.sort().range().cast(args[-1])
4820  idxs = [a.sort().domain_n(i).cast(args[i]) for i in range(len(args)-1)]
4821  _args, sz = _to_ast_array(idxs)
4822  return _to_expr_ref(Z3_mk_store_n(ctx.ref(), a.as_ast(), sz, _args, v.as_ast()), ctx)
4823 
4824 
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:4793
def is_array_sort(a)
Definition: z3py.py:4653
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 4303 of file z3py.py.

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

4303 def URem(a, b):
4304  """Create the Z3 expression (unsigned) remainder `self % other`.
4305 
4306  Use the operator % for signed modulus, and SRem() for signed remainder.
4307 
4308  >>> x = BitVec('x', 32)
4309  >>> y = BitVec('y', 32)
4310  >>> URem(x, y)
4311  URem(x, y)
4312  >>> URem(x, y).sort()
4313  BitVec(32)
4314  >>> (x % y).sexpr()
4315  '(bvsmod x y)'
4316  >>> URem(x, y).sexpr()
4317  '(bvurem x y)'
4318  """
4319  _check_bv_args(a, b)
4320  a, b = _coerce_exprs(a, b)
4321  return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4322 
4323 
def URem(a, b)
Definition: z3py.py:4303
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 11580 of file z3py.py.

11580 def user_prop_created(ctx, cb, id):
11581  prop = _prop_closures.get(ctx)
11582  old_cb = prop.cb
11583  prop.cb = cb
11584  id = _to_expr_ref(to_Ast(id), prop.ctx())
11585  prop.created(id)
11586  prop.cb = old_cb
11587 
11588 
def user_prop_created(ctx, cb, id)
Definition: z3py.py:11580
def to_Ast(ptr)
Definition: z3py.py:11459
def z3py.user_prop_decide (   ctx,
  cb,
  t,
  idx,
  phase 
)

Definition at line 11614 of file z3py.py.

11614 def user_prop_decide(ctx, cb, t, idx, phase):
11615  prop = _prop_closures.get(ctx)
11616  old_cb = prop.cb
11617  prop.cb = cb
11618  t = _to_expr_ref(to_Ast(t_ref), prop.ctx())
11619  prop.decide(t, idx, phase)
11620  prop.cb = old_cb
11621 
11622 
def user_prop_decide(ctx, cb, t, idx, phase)
Definition: z3py.py:11614
def to_Ast(ptr)
Definition: z3py.py:11459
def z3py.user_prop_diseq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11605 of file z3py.py.

11605 def user_prop_diseq(ctx, cb, x, y):
11606  prop = _prop_closures.get(ctx)
11607  old_cb = prop.cb
11608  prop.cb = cb
11609  x = _to_expr_ref(to_Ast(x), prop.ctx())
11610  y = _to_expr_ref(to_Ast(y), prop.ctx())
11611  prop.diseq(x, y)
11612  prop.cb = old_cb
11613 
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:11605
def to_Ast(ptr)
Definition: z3py.py:11459
def z3py.user_prop_eq (   ctx,
  cb,
  x,
  y 
)

Definition at line 11596 of file z3py.py.

11596 def user_prop_eq(ctx, cb, x, y):
11597  prop = _prop_closures.get(ctx)
11598  old_cb = prop.cb
11599  prop.cb = cb
11600  x = _to_expr_ref(to_Ast(x), prop.ctx())
11601  y = _to_expr_ref(to_Ast(y), prop.ctx())
11602  prop.eq(x, y)
11603  prop.cb = old_cb
11604 
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:11596
def to_Ast(ptr)
Definition: z3py.py:11459
def z3py.user_prop_final (   ctx,
  cb 
)

Definition at line 11589 of file z3py.py.

11589 def user_prop_final(ctx, cb):
11590  prop = _prop_closures.get(ctx)
11591  old_cb = prop.cb
11592  prop.cb = cb
11593  prop.final()
11594  prop.cb = old_cb
11595 
def user_prop_final(ctx, cb)
Definition: z3py.py:11589
def z3py.user_prop_fixed (   ctx,
  cb,
  id,
  value 
)

Definition at line 11571 of file z3py.py.

11571 def user_prop_fixed(ctx, cb, id, value):
11572  prop = _prop_closures.get(ctx)
11573  old_cb = prop.cb
11574  prop.cb = cb
11575  id = _to_expr_ref(to_Ast(id), prop.ctx())
11576  value = _to_expr_ref(to_Ast(value), prop.ctx())
11577  prop.fixed(id, value)
11578  prop.cb = old_cb
11579 
def to_Ast(ptr)
Definition: z3py.py:11459
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:11571
def z3py.user_prop_fresh (   ctx,
  _new_ctx 
)

Definition at line 11557 of file z3py.py.

11557 def user_prop_fresh(ctx, _new_ctx):
11558  _prop_closures.set_threaded()
11559  prop = _prop_closures.get(ctx)
11560  nctx = Context()
11561  Z3_del_context(nctx.ctx)
11562  new_ctx = to_ContextObj(_new_ctx)
11563  nctx.ctx = new_ctx
11564  nctx.eh = Z3_set_error_handler(new_ctx, z3_error_handler)
11565  nctx.owner = False
11566  new_prop = prop.fresh(nctx)
11567  _prop_closures.set(new_prop.id, new_prop)
11568  return new_prop.id
11569 
11570 
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:11557
def to_ContextObj(ptr)
Definition: z3py.py:11464
def z3py.user_prop_pop (   ctx,
  cb,
  num_scopes 
)

Definition at line 11551 of file z3py.py.

11551 def user_prop_pop(ctx, cb, num_scopes):
11552  prop = _prop_closures.get(ctx)
11553  prop.cb = cb
11554  prop.pop(num_scopes)
11555 
11556 
def user_prop_pop(ctx, cb, num_scopes)
Definition: z3py.py:11551
def z3py.user_prop_push (   ctx,
  cb 
)

Definition at line 11545 of file z3py.py.

11545 def user_prop_push(ctx, cb):
11546  prop = _prop_closures.get(ctx)
11547  prop.cb = cb
11548  prop.push()
11549 
11550 
def user_prop_push(ctx, cb)
Definition: z3py.py:11545
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 1488 of file z3py.py.

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

1488 def Var(idx, s):
1489  """Create a Z3 free variable. Free variables are used to create quantified formulas.
1490  A free variable with index n is bound when it occurs within the scope of n+1 quantified
1491  declarations.
1492 
1493  >>> Var(0, IntSort())
1494  Var(0)
1495  >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1496  False
1497  """
1498  if z3_debug():
1499  _z3_assert(is_sort(s), "Z3 sort expected")
1500  return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1501 
1502 
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:1488
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 8850 of file z3py.py.

8850 def When(p, t, ctx=None):
8851  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true.
8852  Otherwise, it returns the input goal unmodified.
8853 
8854  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8855  >>> x, y = Ints('x y')
8856  >>> g = Goal()
8857  >>> g.add(x > 0)
8858  >>> g.add(y > 0)
8859  >>> t(g)
8860  [[x > 0, y > 0]]
8861  >>> g.add(x == y + 1)
8862  >>> t(g)
8863  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8864  """
8865  p = _to_probe(p, ctx)
8866  t = _to_tactic(t, ctx)
8867  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8868 
8869 
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:8850
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 8507 of file z3py.py.

Referenced by Goal.prec().

8507 def With(t, *args, **keys):
8508  """Return a tactic that applies tactic `t` using the given configuration options.
8509 
8510  >>> x, y = Ints('x y')
8511  >>> t = With(Tactic('simplify'), som=True)
8512  >>> t((x + 1)*(y + 2) == 0)
8513  [[2*x + y + x*y == -2]]
8514  """
8515  ctx = keys.pop("ctx", None)
8516  t = _to_tactic(t, ctx)
8517  p = args2params(args, keys, t.ctx)
8518  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8519 
8520 
def args2params
Definition: z3py.py:5512
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:8507
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 8521 of file z3py.py.

8521 def WithParams(t, p):
8522  """Return a tactic that applies tactic `t` using the given configuration options.
8523 
8524  >>> x, y = Ints('x y')
8525  >>> p = ParamsRef()
8526  >>> p.set("som", True)
8527  >>> t = WithParams(Tactic('simplify'), p)
8528  >>> t((x + 1)*(y + 2) == 0)
8529  [[2*x + y + x*y == -2]]
8530  """
8531  t = _to_tactic(t, None)
8532  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
8533 
8534 
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:8521
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 1839 of file z3py.py.

Referenced by BoolRef.__xor__().

1839 def Xor(a, b, ctx=None):
1840  """Create a Z3 Xor expression.
1841 
1842  >>> p, q = Bools('p q')
1843  >>> Xor(p, q)
1844  Xor(p, q)
1845  >>> simplify(Xor(p, q))
1846  Not(p == q)
1847  """
1848  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1849  s = BoolSort(ctx)
1850  a = s.cast(a)
1851  b = s.cast(b)
1852  return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1853 
1854 
def BoolSort
Definition: z3py.py:1731
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:1839
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 4439 of file z3py.py.

4439 def ZeroExt(n, a):
4440  """Return a bit-vector expression with `n` extra zero-bits.
4441 
4442  >>> x = BitVec('x', 16)
4443  >>> n = ZeroExt(8, x)
4444  >>> n.size()
4445  24
4446  >>> n
4447  ZeroExt(8, x)
4448  >>> n.sort()
4449  BitVec(24)
4450  >>> v0 = BitVecVal(2, 2)
4451  >>> v0
4452  2
4453  >>> v0.size()
4454  2
4455  >>> v = simplify(ZeroExt(6, v0))
4456  >>> v
4457  2
4458  >>> v.size()
4459  8
4460  """
4461  if z3_debug():
4462  _z3_assert(_is_int(n), "First argument must be an integer")
4463  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4464  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4465 
4466 
def ZeroExt(n, a)
Definition: z3py.py:4439
def z3_debug()
Definition: z3py.py:62
def is_bv(a)
Definition: z3py.py:3990
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 9402 of file z3py.py.

int _dflt_fpsort_sbits = 53

Definition at line 9403 of file z3py.py.

_dflt_rounding_mode = Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN

Floating-Point Arithmetic.

Definition at line 9401 of file z3py.py.

_main_ctx = None

Definition at line 236 of file z3py.py.

_my_hacky_class = None

Definition at line 11479 of file z3py.py.

tuple _on_clause_eh = Z3_on_clause_eh(on_clause_eh)

Definition at line 11487 of file z3py.py.

tuple _on_model_eh = on_model_eh_type(_global_on_model)

Definition at line 7923 of file z3py.py.

dictionary _on_models = {}

Definition at line 7915 of file z3py.py.

_prop_closures = None

Definition at line 11536 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 9421 of file z3py.py.

tuple _user_prop_created = Z3_created_eh(user_prop_created)

Definition at line 11627 of file z3py.py.

tuple _user_prop_decide = Z3_decide_eh(user_prop_decide)

Definition at line 11631 of file z3py.py.

tuple _user_prop_diseq = Z3_eq_eh(user_prop_diseq)

Definition at line 11630 of file z3py.py.

tuple _user_prop_eq = Z3_eq_eh(user_prop_eq)

Definition at line 11629 of file z3py.py.

tuple _user_prop_final = Z3_final_eh(user_prop_final)

Definition at line 11628 of file z3py.py.

tuple _user_prop_fixed = Z3_fixed_eh(user_prop_fixed)

Definition at line 11626 of file z3py.py.

tuple _user_prop_fresh = Z3_fresh_eh(user_prop_fresh)

Definition at line 11625 of file z3py.py.

tuple _user_prop_pop = Z3_pop_eh(user_prop_pop)

Definition at line 11624 of file z3py.py.

tuple _user_prop_push = Z3_push_eh(user_prop_push)

Definition at line 11623 of file z3py.py.

tuple sat = CheckSatResult(Z3_L_TRUE)

Definition at line 6938 of file z3py.py.

tuple unknown = CheckSatResult(Z3_L_UNDEF)

Definition at line 6940 of file z3py.py.

tuple unsat = CheckSatResult(Z3_L_FALSE)

Definition at line 6939 of file z3py.py.

Z3_DEBUG = __debug__

Definition at line 59 of file z3py.py.