C# Class Microsoft.Z3.Context

Create a probe that evaluates to "true" when the value p1 and p2 evaluate to "true".

Create a tactic that applies t1 to a Goal and then t2 to every subgoal produced by t1.

Convert a benchmark into an SMT-LIB formatted string.

Create a tactic that applies t1 to a given goal if the probe p evaluates to true and t2 otherwise.

Create a probe that always evaluates to val.

Constructor.

Constructor.

The following parameters can be set: - proof (Boolean) Enable proof generation - debug_ref_count (Boolean) Enable debug support for Z3_ast reference counting - trace (Boolean) Tracing support for VCC - trace_file_name (String) Trace out file for VCC traces - timeout (unsigned) default timeout (in milliseconds) used for solvers - well_sorted_check type checker - auto_config use heuristics to automatically select solver and configure it - model model generation for solvers, this parameter can be overwritten when creating a solver - model_validate validate models produced by solvers - unsat_core unsat-core generation for solvers, this parameter can be overwritten when creating a solver Note that in previous versions of Z3, this constructor was also used to set global and module parameters. For this purpose we should now use Global.SetParameter

Disposes of the context.

Create a probe that evaluates to "true" when the value returned by p1 is equal to the value returned by p2

Create a tactic always fails.

Create a tactic that fails if the probe p evaluates to false.

Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) or trivially unsatisfiable (i.e., contains `false').

Create a probe that evaluates to "true" when the value returned by p1 is greater than or equal the value returned by p2

Create a probe that evaluates to "true" when the value returned by p1 is greater than the value returned by p2

Interrupt the execution of a Z3 procedure.

This procedure can be used to interrupt: solvers, simplifiers and tactics.

Create a probe that evaluates to "true" when the value returned by p1 is less than or equal the value returned by p2

Create a probe that evaluates to "true" when the value returned by p1 is less than the value returned by p2

Create an expression representing t[0] + t[1] + ....

Create an expression representing t[0] and t[1] and ....

Create a new function application.

Create an array constant.

Create an array constant.

Create a new array sort.

Create a bit-vector numeral.

Create a bit-vector numeral.

Create a bit-vector numeral.

Create a bit-vector numeral.

Create a bit-vector numeral.

Create an integer from the bit-vector argument t.

If \c is_signed is false, then the bit-vector \c t1 is treated as unsigned. So the result is non-negative and in the range [0..2^N-1], where N are the number of bits in t. If \c is_signed is true, \c t1 is treated as a signed bit-vector. NB. This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. The argument must be of bit-vector sort.

Bitwise conjunction.

The arguments must have a bit-vector sort.

Arithmetic shift right

It is like logical shift right except that the most significant bits of the result always copy the most significant bit of the second argument. NB. The semantics of shift operations varies between environments. This definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. The arguments must have a bit-vector sort.

Two's complement addition.

The arguments must have the same bit-vector sort.

Create a predicate that checks that the bit-wise addition does not overflow.

The arguments must be of bit-vector sort.

Create a predicate that checks that the bit-wise addition does not underflow.

The arguments must be of bit-vector sort.

Creates a bit-vector constant.

Creates a bit-vector constant.

Logical shift right

It is equivalent to unsigned division by 2^x where \c x is the value of t2. NB. The semantics of shift operations varies between environments. This definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. The arguments must have a bit-vector sort.

Two's complement multiplication.

The arguments must have the same bit-vector sort.

Create a predicate that checks that the bit-wise multiplication does not overflow.

The arguments must be of bit-vector sort.

Create a predicate that checks that the bit-wise multiplication does not underflow.

The arguments must be of bit-vector sort.

Bitwise NAND.

The arguments must have a bit-vector sort.

Bitwise NOR.

The arguments must have a bit-vector sort.

Standard two's complement unary minus.

The arguments must have a bit-vector sort.

Create a predicate that checks that the bit-wise negation does not overflow.

The arguments must be of bit-vector sort.

Bitwise negation.

The argument must have a bit-vector sort.

Bitwise disjunction.

The arguments must have a bit-vector sort.

Take conjunction of bits in a vector, return vector of length 1.

The argument must have a bit-vector sort.

Take disjunction of bits in a vector, return vector of length 1.

The argument must have a bit-vector sort.

Rotate Left.

Rotate bits of t1 to the left t2 times. The arguments must have the same bit-vector sort.

Rotate Left.

Rotate bits of \c t to the left \c i times. The argument t must have a bit-vector sort.

Rotate Right.

Rotate bits of t1 to the rightt2 times. The arguments must have the same bit-vector sort.

Rotate Right.

Rotate bits of \c t to the right \c i times. The argument t must have a bit-vector sort.

Signed division.

It is defined in the following way: - The \c floor of t1/t2 if \c t2 is different from zero, and t1*t2 >= 0. - The \c ceiling of t1/t2 if \c t2 is different from zero, and t1*t2 < 0. If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.

Create a predicate that checks that the bit-wise signed division does not overflow.

The arguments must be of bit-vector sort.

Two's complement signed greater than or equal to.

The arguments must have the same bit-vector sort.

Two's complement signed greater-than.

The arguments must have the same bit-vector sort.

Shift left.

It is equivalent to multiplication by 2^x where \c x is the value of t2. NB. The semantics of shift operations varies between environments. This definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. The arguments must have a bit-vector sort.

Two's complement signed less-than or equal to.

The arguments must have the same bit-vector sort.

Two's complement signed less-than

The arguments must have the same bit-vector sort.

Two's complement signed remainder (sign follows divisor).

If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.

Signed remainder.

It is defined as t1 - (t1 /s t2) * t2, where /s represents signed division. The most significant bit (sign) of the result is equal to the most significant bit of \c t1. If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.

Two's complement subtraction.

The arguments must have the same bit-vector sort.

Create a predicate that checks that the bit-wise subtraction does not overflow.

The arguments must be of bit-vector sort.

Create a predicate that checks that the bit-wise subtraction does not underflow.

The arguments must be of bit-vector sort.

Unsigned division.

It is defined as the floor of t1/t2 if \c t2 is different from zero. If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.

Unsigned greater than or equal to.

The arguments must have the same bit-vector sort.

Unsigned greater-than.

The arguments must have the same bit-vector sort.

Unsigned less-than or equal to.

The arguments must have the same bit-vector sort.

Unsigned less-than

The arguments must have the same bit-vector sort.

Unsigned remainder.

It is defined as t1 - (t1 /u t2) * t2, where /u represents unsigned division. If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.

Bitwise XNOR.

The arguments must have a bit-vector sort.

Bitwise XOR.

The arguments must have a bit-vector sort.

Create a new bit-vector sort.

Creates a Boolean value.

Create a Boolean constant.

Create a Boolean constant.

Create a new Boolean sort.

Creates a new bound variable.

Bit-vector concatenation.

The arguments must have a bit-vector sort.

Creates a fresh constant from the FuncDecl f.

Creates a new Constant of sort range and named name.

Creates a new Constant of sort range and named name.

Create a constant array.

The resulting term is an array, such that a selecton an arbitrary index produces the value v. MkArraySort MkSelect

Creates a new constant function declaration.

Creates a new constant function declaration.

Create a datatype constructor.

Create a datatype constructor.

Create a new datatype sort.

Create a new datatype sort.

Create mutually recursive datatypes.

Create mutually recursive data-types.

Creates a distinct term.

Create an expression representing t1 / t2.

Create an empty set.

Create a new enumeration sort.

Create a new enumeration sort.

Creates the equality x = y.

Create an existential Quantifier.

Create an existential Quantifier.

Bit-vector extraction.

Extract the bits high down to low from a bitvector of size m to yield a new bitvector of size n, where n = high - low + 1. The argument t must have a bit-vector sort.

The false Term.

Create a new finite domain sort. The result is a sort

Create a new finite domain sort. The result is a sort Elements of the sort are created using MkNumeral(ulong, Sort), and the elements range from 0 to size-1.

Create a Fixedpoint context.

Create a universal Quantifier.

Create a universal Quantifier.

Creates a forall formula, where weight is the weight, patterns is an array of patterns, sorts is an array with the sorts of the bound variables, names is an array with the 'names' of the bound variables, and body is the body of the quantifier. Quantifiers are associated with weights indicating the importance of using the quantifier during instantiation.

Creates a fresh Constant of sort range and a name prefixed with prefix.

Creates a fresh constant function declaration with a name prefixed with prefix.

Creates a fresh function declaration with a name prefixed with prefix.

Create the full set.

Creates a new function declaration.

Creates a new function declaration.

Create an expression representing t1 >= t2

Creates a new Goal.

Note that the Context must have been created with proof generation support if proofs is set to true here.

Create an expression representing t1 > t2

Create an expression representing an if-then-else: ite(t1, t2, t3).

Create an expression representing t1 iff t2.

Create an expression representing t1 -> t2.

Create an integer numeral.

Create an integer numeral.

Create an integer numeral.

Create an integer numeral.

Create an integer numeral.

Create an n bit bit-vector from the integer argument t.

NB. This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. The argument must be of integer sort.

Coerce an integer to a real.

There is also a converse operation exposed. It follows the semantics prescribed by the SMT-LIB standard. You can take the floor of a real by creating an auxiliary integer Term k and and asserting MakeInt2Real(k) <= t1 < MkInt2Real(k)+1. The argument must be of integer sort.

Creates an integer constant.

Creates an integer constant.

Create a new integer sort.

Creates an expression that checks whether a real number is an integer.

Create an expression representing t1 <= t2

Create a new list sort.

Create a new list sort.

Create an expression representing t1 < t2

Maps f on the argument arrays.

Eeach element of args must be of an array sort [domain_i -> range_i]. The function declaration f must have type range_1 .. range_n -> range. v must have sort range. The sort of the result is [domain_i -> range]. MkArraySort MkSelect MkStore

Create an expression representing t1 mod t2.

The arguments must have int type.

Create an expression representing t[0] * t[1] * ....

Mk an expression representing not(a).

Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than MakeNumeral since it is not necessary to parse a string.

Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than MakeNumeral since it is not necessary to parse a string.

Create a Term of a given sort.

Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than MakeNumeral since it is not necessary to parse a string.

Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than MakeNumeral since it is not necessary to parse a string.

Create an expression representing t[0] or t[1] or ....

Creates a new ParameterSet.

Create a quantifier pattern.

Create an expression representing t1 ^ t2.

Creates a new Probe.

Create a Quantifier.

Create a Quantifier.

Create a real numeral.

Create a real from a fraction.

Create a real numeral.

Create a real numeral.

Create a real numeral.

Create a real numeral.

Coerce a real to an integer.

The semantics of this function follows the SMT-LIB standard for the function to_int. The argument must be of real sort.

Creates a real constant.

Creates a real constant.

Create a real sort.

Create an expression representing t1 rem t2.

The arguments must have int type.

Bit-vector repetition.

The argument t must have a bit-vector sort.

Array read.

The argument a is the array and i is the index of the array that gets read. The node a must have an array sort [domain -> range], and i must have the sort domain. The sort of the result is range. MkArraySort MkStore

Add an element to the set.

Take the complement of a set.

Remove an element from a set.

Take the difference between two sets.

Take the intersection of a list of sets.

Check for set membership.

Create a set type.

Check for subsetness of sets.

Take the union of a list of sets.

Bit-vector sign extension.

Sign-extends the given bit-vector to the (signed) equivalent bitvector of size m+i, where \c m is the size of the given bit-vector. The argument t must have a bit-vector sort.

Creates a new (incremental) solver.

Creates a new (incremental) solver.

This solver also uses a set of builtin tactics for handling the first check-sat command, and check-sat commands that take more than a given number of milliseconds to be solved.

Creates a solver that is implemented using the given tactic.

The solver supports the commands Push and Pop, but it will always solve each check from scratch.

Creates a new (incremental) solver.

Array update.

The node a must have an array sort [domain -> range], i must have sort domain, v must have sort range. The sort of the result is [domain -> range]. The semantics of this function is given by the theory of arrays described in the SMT-LIB standard. See http://smtlib.org for more details. The result of this function is an array that is equal to a (with respect to select) on all indices except for i, where it maps to v (and the select of a with respect to i may be a different value). MkArraySort MkSelect

Create an expression representing t[0] - t[1] - ....

Creates a new symbol using an integer.

Not all integers can be passed to this function. The legal range of unsigned integers is 0 to 2^30-1.

Create a symbol using a string.

Creates a new Tactic.

Access the array default value.

Produces the default range value, for arrays that can be represented as finite maps with a default range value.

The true Term.

Create a new tuple sort.

Create an expression representing -t.

Create a new uninterpreted sort.

Create a new uninterpreted sort.

Create an expression representing t1 xor t2.

Bit-vector zero extension.

Extend the given bit-vector with zeros to the (unsigned) equivalent bitvector of size m+i, where \c m is the size of the given bit-vector. The argument t must have a bit-vector sort.

Create a probe that evaluates to "true" when the value p does not evaluate to "true".

Create a probe that evaluates to "true" when the value p1 or p2 evaluate to "true".

Create a tactic that first applies t1 to a Goal and if it fails then returns the result of t2 applied to the Goal.

Create a tactic that applies t1 to a given goal and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.

Create a tactic that applies the given tactics in parallel.

Parse the given file using the SMT-LIB2 parser.

Parse the given string using the SMT-LIB2 parser.

Parse the given file using the SMT-LIB parser.

Parse the given string using the SMT-LIB parser.

The symbol table of the parser can be initialized using the given sorts and declarations. The symbols in the arrays sortNames and declNames don't need to match the names of the sorts and declarations in the arrays sorts and decls. This is a useful feature since we can use arbitrary names to reference sorts and declarations.

Returns a string containing a description of the probe with the given name.

Create a tactic that keeps applying t until the goal is not modified anymore or the maximum number of iterations max is reached.

Return a string describing all available parameters to Expr.Simplify.

Create a tactic that just returns the given goal.

Returns a string containing a description of the tactic with the given name.

Create a tactic that applies t1 to a Goal and then t2 to every subgoal produced by t1.

Shorthand for AndThen.

Enable/disable printing of warning messages to the console.

Note that this function is static and effects the behaviour of all contexts globally.

Create a tactic that applies t to a goal for ms milliseconds.

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

Unwraps an AST.

This function is used for transitions between native and managed objects. It returns the native pointer to the AST. Note that AST objects are reference counted and unwrapping an AST disables automatic reference counting, i.e., all references to the IntPtr that is returned must be handled externally and through native calls (see e.g., Native.Z3_inc_ref).

Update a mutable configuration parameter.

The list of all configuration parameters can be obtained using the Z3 executable: z3.exe -p Only a few configuration parameters are mutable once the context is created. An exception is thrown when trying to modify an immutable parameter.

Create a tactic that applies t using the given set of parameters p.

Create a tactic that applies t to a given goal if the probe p evaluates to true.

If p evaluates to false, then the new tactic behaves like the skip tactic.

Create a tactic that applies t using the given set of parameters p.

Alias for UsingParams

Wraps an AST.

This function is used for transitions between native and managed objects. Note that nativeObject must be a native object obtained from Z3 (e.g., through UnwrapAST) and that it must have a correct reference count (see e.g., Native.Z3_inc_ref.

Create an array of symbols.