C# 클래스 Microsoft.Z3.Context

상속: IDisposable

파일 보기 프로젝트 열기: sslab-gatech/juxta 1 사용 예제들

Private Properties

프로퍼티	타입	설명
CheckContextMatch	void
InitContext	void
MkSymbols	Microsoft.Z3.Symbol[]
NativeErrorHandler	void
ObjectInvariant	void

공개 메소드들

메소드	설명
And ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value p1 and p2 evaluate to "true".
AndThen ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic	Create a tactic that applies t1 to a Goal and then t2 to every subgoal produced by t1.
BenchmarkToSMTString ( string name, string logic, string status, string attributes, BoolExpr assumptions, BoolExpr formula ) : string	Convert a benchmark into an SMT-LIB formatted string.
Cond ( Probe p, Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic	Create a tactic that applies t1 to a given goal if the probe p evaluates to true and t2 otherwise.
ConstProbe ( double val ) : Probe	Create a probe that always evaluates to val.
Context ( ) : System	Constructor.
Context ( string>.Dictionary settings ) : System	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
Dispose ( ) : void	Disposes of the context.
Eq ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value returned by p1 is equal to the value returned by p2
Fail ( ) : Microsoft.Z3.Tactic	Create a tactic always fails.
FailIf ( Probe p ) : Microsoft.Z3.Tactic	Create a tactic that fails if the probe p evaluates to false.
FailIfNotDecided ( ) : Microsoft.Z3.Tactic	Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) or trivially unsatisfiable (i.e., contains `false').
Ge ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value returned by p1 is greater than or equal the value returned by p2
Gt ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value returned by p1 is greater than the value returned by p2
Interrupt ( ) : void	Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers, simplifiers and tactics.
Le ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value returned by p1 is less than or equal the value returned by p2
Lt ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value returned by p1 is less than the value returned by p2
MkAdd ( ) : ArithExpr	Create an expression representing `t[0] + t[1] + ...`.
MkAnd ( ) : BoolExpr	Create an expression representing `t[0] and t[1] and ...`.
MkApp ( FuncDecl f ) : Expr	Create a new function application.
MkArrayConst ( Symbol name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArrayExpr	Create an array constant.
MkArrayConst ( string name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArrayExpr	Create an array constant.
MkArraySort ( Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArraySort	Create a new array sort.
MkBV ( int v, uint size ) : BitVecNum	Create a bit-vector numeral.
MkBV ( long v, uint size ) : BitVecNum	Create a bit-vector numeral.
MkBV ( string v, uint size ) : BitVecNum	Create a bit-vector numeral.
MkBV ( uint v, uint size ) : BitVecNum	Create a bit-vector numeral.
MkBV ( ulong v, uint size ) : BitVecNum	Create a bit-vector numeral.
MkBV2Int ( BitVecExpr t, bool signed ) : IntExpr	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.
MkBVAND ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise conjunction. The arguments must have a bit-vector sort.
MkBVASHR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVAdd ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Two's complement addition. The arguments must have the same bit-vector sort.
MkBVAddNoOverflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr	Create a predicate that checks that the bit-wise addition does not overflow. The arguments must be of bit-vector sort.
MkBVAddNoUnderflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Create a predicate that checks that the bit-wise addition does not underflow. The arguments must be of bit-vector sort.
MkBVConst ( Symbol name, uint size ) : BitVecExpr	Creates a bit-vector constant.
MkBVConst ( string name, uint size ) : BitVecExpr	Creates a bit-vector constant.
MkBVLSHR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVMul ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Two's complement multiplication. The arguments must have the same bit-vector sort.
MkBVMulNoOverflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr	Create a predicate that checks that the bit-wise multiplication does not overflow. The arguments must be of bit-vector sort.
MkBVMulNoUnderflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Create a predicate that checks that the bit-wise multiplication does not underflow. The arguments must be of bit-vector sort.
MkBVNAND ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise NAND. The arguments must have a bit-vector sort.
MkBVNOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise NOR. The arguments must have a bit-vector sort.
MkBVNeg ( BitVecExpr t ) : BitVecExpr	Standard two's complement unary minus. The arguments must have a bit-vector sort.
MkBVNegNoOverflow ( BitVecExpr t ) : BoolExpr	Create a predicate that checks that the bit-wise negation does not overflow. The arguments must be of bit-vector sort.
MkBVNot ( BitVecExpr t ) : BitVecExpr	Bitwise negation. The argument must have a bit-vector sort.
MkBVOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise disjunction. The arguments must have a bit-vector sort.
MkBVRedAND ( BitVecExpr t ) : BitVecExpr	Take conjunction of bits in a vector, return vector of length 1. The argument must have a bit-vector sort.
MkBVRedOR ( BitVecExpr t ) : BitVecExpr	Take disjunction of bits in a vector, return vector of length 1. The argument must have a bit-vector sort.
MkBVRotateLeft ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Rotate Left. Rotate bits of t1 to the left t2 times. The arguments must have the same bit-vector sort.
MkBVRotateLeft ( uint i, BitVecExpr t ) : BitVecExpr	Rotate Left. Rotate bits of \c t to the left \c i times. The argument t must have a bit-vector sort.
MkBVRotateRight ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Rotate Right. Rotate bits of t1 to the rightt2 times. The arguments must have the same bit-vector sort.
MkBVRotateRight ( uint i, BitVecExpr t ) : BitVecExpr	Rotate Right. Rotate bits of \c t to the right \c i times. The argument t must have a bit-vector sort.
MkBVSDiv ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Signed division. It is defined in the following way: - The \c floor of `t1/t2` if \c t2 is different from zero, and `t1t2 >= 0`. - The \c ceiling of `t1/t2` if \c t2 is different from zero, and `t1t2 < 0`. If `t2` is zero, then the result is undefined. The arguments must have the same bit-vector sort.
MkBVSDivNoOverflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Create a predicate that checks that the bit-wise signed division does not overflow. The arguments must be of bit-vector sort.
MkBVSGE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Two's complement signed greater than or equal to. The arguments must have the same bit-vector sort.
MkBVSGT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Two's complement signed greater-than. The arguments must have the same bit-vector sort.
MkBVSHL ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVSLE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Two's complement signed less-than or equal to. The arguments must have the same bit-vector sort.
MkBVSLT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Two's complement signed less-than The arguments must have the same bit-vector sort.
MkBVSMod ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVSRem ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVSub ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Two's complement subtraction. The arguments must have the same bit-vector sort.
MkBVSubNoOverflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Create a predicate that checks that the bit-wise subtraction does not overflow. The arguments must be of bit-vector sort.
MkBVSubNoUnderflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr	Create a predicate that checks that the bit-wise subtraction does not underflow. The arguments must be of bit-vector sort.
MkBVUDiv ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVUGE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Unsigned greater than or equal to. The arguments must have the same bit-vector sort.
MkBVUGT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Unsigned greater-than. The arguments must have the same bit-vector sort.
MkBVULE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Unsigned less-than or equal to. The arguments must have the same bit-vector sort.
MkBVULT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr	Unsigned less-than The arguments must have the same bit-vector sort.
MkBVURem ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	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.
MkBVXNOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise XNOR. The arguments must have a bit-vector sort.
MkBVXOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bitwise XOR. The arguments must have a bit-vector sort.
MkBitVecSort ( uint size ) : BitVecSort	Create a new bit-vector sort.
MkBool ( bool value ) : BoolExpr	Creates a Boolean value.
MkBoolConst ( Symbol name ) : BoolExpr	Create a Boolean constant.
MkBoolConst ( string name ) : BoolExpr	Create a Boolean constant.
MkBoolSort ( ) : BoolSort	Create a new Boolean sort.
MkBound ( uint index, Microsoft.Z3.Sort ty ) : Expr	Creates a new bound variable.
MkConcat ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr	Bit-vector concatenation. The arguments must have a bit-vector sort.
MkConst ( FuncDecl f ) : Expr	Creates a fresh constant from the FuncDecl f.
MkConst ( Symbol name, Microsoft.Z3.Sort range ) : Expr	Creates a new Constant of sort range and named name.
MkConst ( string name, Microsoft.Z3.Sort range ) : Expr	Creates a new Constant of sort range and named name.
MkConstArray ( Microsoft.Z3.Sort domain, Expr v ) : ArrayExpr	Create a constant array. The resulting term is an array, such that a `select`on an arbitrary index produces the value `v`. MkArraySort MkSelect
MkConstDecl ( Symbol name, Microsoft.Z3.Sort range ) : FuncDecl	Creates a new constant function declaration.
MkConstDecl ( string name, Microsoft.Z3.Sort range ) : FuncDecl	Creates a new constant function declaration.
MkConstructor ( Symbol name, Symbol recognizer, Symbol fieldNames = null, Microsoft.Z3.Sort sorts = null, uint sortRefs = null ) : Microsoft.Z3.Constructor	Create a datatype constructor.
MkConstructor ( string name, string recognizer, string fieldNames = null, Microsoft.Z3.Sort sorts = null, uint sortRefs = null ) : Microsoft.Z3.Constructor	Create a datatype constructor.
MkDatatypeSort ( Symbol name, Microsoft.Z3.Constructor constructors ) : DatatypeSort	Create a new datatype sort.
MkDatatypeSort ( string name, Microsoft.Z3.Constructor constructors ) : DatatypeSort	Create a new datatype sort.
MkDatatypeSorts ( Symbol names, Microsoft.Z3.Constructor c ) : Microsoft.Z3.DatatypeSort[]	Create mutually recursive datatypes.
MkDatatypeSorts ( string names, Microsoft.Z3.Constructor c ) : Microsoft.Z3.DatatypeSort[]	Create mutually recursive data-types.
MkDistinct ( ) : BoolExpr	Creates a `distinct` term.
MkDiv ( ArithExpr t1, ArithExpr t2 ) : ArithExpr	Create an expression representing `t1 / t2`.
MkEmptySet ( Microsoft.Z3.Sort domain ) : Expr	Create an empty set.
MkEnumSort ( Symbol name ) : EnumSort	Create a new enumeration sort.
MkEnumSort ( string name ) : EnumSort	Create a new enumeration sort.
MkEq ( Expr x, Expr y ) : BoolExpr	Creates the equality x = y.
MkExists ( Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier	Create an existential Quantifier.
MkExists ( Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier	Create an existential Quantifier.
MkExtract ( uint high, uint low, BitVecExpr t ) : BitVecExpr	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.
MkFalse ( ) : BoolExpr	The false Term.
MkFiniteDomainSort ( Symbol name, ulong size ) : FiniteDomainSort	Create a new finite domain sort. The result is a sort
MkFiniteDomainSort ( string name, ulong size ) : FiniteDomainSort	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`.
MkFixedpoint ( ) : Fixedpoint	Create a Fixedpoint context.
MkForall ( Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier	Create a universal Quantifier.
MkForall ( Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : 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.
MkFreshConst ( string prefix, Microsoft.Z3.Sort range ) : Expr	Creates a fresh Constant of sort range and a name prefixed with prefix.
MkFreshConstDecl ( string prefix, Microsoft.Z3.Sort range ) : FuncDecl	Creates a fresh constant function declaration with a name prefixed with prefix.
MkFreshFuncDecl ( string prefix, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl	Creates a fresh function declaration with a name prefixed with prefix.
MkFullSet ( Microsoft.Z3.Sort domain ) : Expr	Create the full set.
MkFuncDecl ( Symbol name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl	Creates a new function declaration.
MkFuncDecl ( string name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl	Creates a new function declaration.
MkGe ( ArithExpr t1, ArithExpr t2 ) : BoolExpr	Create an expression representing `t1 >= t2`
MkGoal ( bool models = true, bool unsatCores = false, bool proofs = false ) : Goal	Creates a new Goal. Note that the Context must have been created with proof generation support if proofs is set to true here.
MkGt ( ArithExpr t1, ArithExpr t2 ) : BoolExpr	Create an expression representing `t1 > t2`
MkITE ( BoolExpr t1, Expr t2, Expr t3 ) : Expr	Create an expression representing an if-then-else: `ite(t1, t2, t3)`.
MkIff ( BoolExpr t1, BoolExpr t2 ) : BoolExpr	Create an expression representing `t1 iff t2`.
MkImplies ( BoolExpr t1, BoolExpr t2 ) : BoolExpr	Create an expression representing `t1 -> t2`.
MkInt ( int v ) : IntNum	Create an integer numeral.
MkInt ( long v ) : IntNum	Create an integer numeral.
MkInt ( string v ) : IntNum	Create an integer numeral.
MkInt ( uint v ) : IntNum	Create an integer numeral.
MkInt ( ulong v ) : IntNum	Create an integer numeral.
MkInt2BV ( uint n, IntExpr t ) : BitVecExpr	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.
MkInt2Real ( IntExpr t ) : RealExpr	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.
MkIntConst ( Symbol name ) : IntExpr	Creates an integer constant.
MkIntConst ( string name ) : IntExpr	Creates an integer constant.
MkIntSort ( ) : IntSort	Create a new integer sort.
MkIsInteger ( RealExpr t ) : BoolExpr	Creates an expression that checks whether a real number is an integer.
MkLe ( ArithExpr t1, ArithExpr t2 ) : BoolExpr	Create an expression representing `t1 <= t2`
MkListSort ( Symbol name, Microsoft.Z3.Sort elemSort ) : ListSort	Create a new list sort.
MkListSort ( string name, Microsoft.Z3.Sort elemSort ) : ListSort	Create a new list sort.
MkLt ( ArithExpr t1, ArithExpr t2 ) : BoolExpr	Create an expression representing `t1 < t2`
MkMap ( FuncDecl f ) : ArrayExpr	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
MkMod ( IntExpr t1, IntExpr t2 ) : IntExpr	Create an expression representing `t1 mod t2`. The arguments must have int type.
MkMul ( ) : ArithExpr	Create an expression representing `t[0] * t[1] * ...`.
MkNot ( BoolExpr a ) : BoolExpr	Mk an expression representing `not(a)`.
MkNumeral ( int v, Microsoft.Z3.Sort ty ) : Expr	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.
MkNumeral ( long v, Microsoft.Z3.Sort ty ) : Expr	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.
MkNumeral ( string v, Microsoft.Z3.Sort ty ) : Expr	Create a Term of a given sort.
MkNumeral ( uint v, Microsoft.Z3.Sort ty ) : Expr	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.
MkNumeral ( ulong v, Microsoft.Z3.Sort ty ) : Expr	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.
MkOr ( ) : BoolExpr	Create an expression representing `t[0] or t[1] or ...`.
MkParams ( ) : Params	Creates a new ParameterSet.
MkPattern ( ) : Pattern	Create a quantifier pattern.
MkPower ( ArithExpr t1, ArithExpr t2 ) : ArithExpr	Create an expression representing `t1 ^ t2`.
MkProbe ( string name ) : Probe	Creates a new Probe.
MkQuantifier ( bool universal, Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier	Create a Quantifier.
MkQuantifier ( bool universal, Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier	Create a Quantifier.
MkReal ( int v ) : RatNum	Create a real numeral.
MkReal ( int num, int den ) : RatNum	Create a real from a fraction.
MkReal ( long v ) : RatNum	Create a real numeral.
MkReal ( string v ) : RatNum	Create a real numeral.
MkReal ( uint v ) : RatNum	Create a real numeral.
MkReal ( ulong v ) : RatNum	Create a real numeral.
MkReal2Int ( RealExpr t ) : IntExpr	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.
MkRealConst ( Symbol name ) : RealExpr	Creates a real constant.
MkRealConst ( string name ) : RealExpr	Creates a real constant.
MkRealSort ( ) : RealSort	Create a real sort.
MkRem ( IntExpr t1, IntExpr t2 ) : IntExpr	Create an expression representing `t1 rem t2`. The arguments must have int type.
MkRepeat ( uint i, BitVecExpr t ) : BitVecExpr	Bit-vector repetition. The argument t must have a bit-vector sort.
MkSelect ( ArrayExpr a, Expr i ) : Expr	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
MkSetAdd ( Expr set, Expr element ) : Expr	Add an element to the set.
MkSetComplement ( Expr arg ) : Expr	Take the complement of a set.
MkSetDel ( Expr set, Expr element ) : Expr	Remove an element from a set.
MkSetDifference ( Expr arg1, Expr arg2 ) : Expr	Take the difference between two sets.
MkSetIntersection ( ) : Expr	Take the intersection of a list of sets.
MkSetMembership ( Expr elem, Expr set ) : Expr	Check for set membership.
MkSetSort ( Microsoft.Z3.Sort ty ) : SetSort	Create a set type.
MkSetSubset ( Expr arg1, Expr arg2 ) : Expr	Check for subsetness of sets.
MkSetUnion ( ) : Expr	Take the union of a list of sets.
MkSignExt ( uint i, BitVecExpr t ) : BitVecExpr	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.
MkSimpleSolver ( ) : Solver	Creates a new (incremental) solver.
MkSolver ( Symbol logic = null ) : 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.
MkSolver ( Microsoft.Z3.Tactic t ) : Solver	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.
MkSolver ( string logic ) : Solver	Creates a new (incremental) solver.
MkStore ( ArrayExpr a, Expr i, Expr v ) : ArrayExpr	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
MkSub ( ) : ArithExpr	Create an expression representing `t[0] - t[1] - ...`.
MkSymbol ( int i ) : IntSymbol	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.
MkSymbol ( string name ) : StringSymbol	Create a symbol using a string.
MkTactic ( string name ) : Microsoft.Z3.Tactic	Creates a new Tactic.
MkTermArray ( ArrayExpr array ) : Expr	Access the array default value. Produces the default range value, for arrays that can be represented as finite maps with a default range value.
MkTrue ( ) : BoolExpr	The true Term.
MkTupleSort ( Symbol name, Symbol fieldNames, Microsoft.Z3.Sort fieldSorts ) : TupleSort	Create a new tuple sort.
MkUnaryMinus ( ArithExpr t ) : ArithExpr	Create an expression representing `-t`.
MkUninterpretedSort ( Symbol s ) : UninterpretedSort	Create a new uninterpreted sort.
MkUninterpretedSort ( string str ) : UninterpretedSort	Create a new uninterpreted sort.
MkXor ( BoolExpr t1, BoolExpr t2 ) : BoolExpr	Create an expression representing `t1 xor t2`.
MkZeroExt ( uint i, BitVecExpr t ) : BitVecExpr	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.
Not ( Probe p ) : Probe	Create a probe that evaluates to "true" when the value p does not evaluate to "true".
Or ( Probe p1, Probe p2 ) : Probe	Create a probe that evaluates to "true" when the value p1 or p2 evaluate to "true".
OrElse ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic	Create a tactic that first applies t1 to a Goal and if it fails then returns the result of t2 applied to the Goal.
ParAndThen ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic	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.
ParOr ( ) : Microsoft.Z3.Tactic	Create a tactic that applies the given tactics in parallel.
ParseSMTLIB2File ( string fileName, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : BoolExpr	Parse the given file using the SMT-LIB2 parser.
ParseSMTLIB2String ( string str, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : BoolExpr	Parse the given string using the SMT-LIB2 parser.
ParseSMTLIBFile ( string fileName, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : void	Parse the given file using the SMT-LIB parser.
ParseSMTLIBString ( string str, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : void	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.
ProbeDescription ( string name ) : string	Returns a string containing a description of the probe with the given name.
Repeat ( Microsoft.Z3.Tactic t, uint max = uint.MaxValue ) : Microsoft.Z3.Tactic	Create a tactic that keeps applying t until the goal is not modified anymore or the maximum number of iterations max is reached.
SimplifyHelp ( ) : string	Return a string describing all available parameters to `Expr.Simplify`.
Skip ( ) : Microsoft.Z3.Tactic	Create a tactic that just returns the given goal.
TacticDescription ( string name ) : string	Returns a string containing a description of the tactic with the given name.
Then ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic	Create a tactic that applies t1 to a Goal and then t2 to every subgoal produced by t1. Shorthand for `AndThen`.
ToggleWarningMessages ( bool enabled ) : void	Enable/disable printing of warning messages to the console. Note that this function is static and effects the behaviour of all contexts globally.
TryFor ( Microsoft.Z3.Tactic t, uint ms ) : Microsoft.Z3.Tactic	Create a tactic that applies t to a goal for ms milliseconds. If t does not terminate within ms milliseconds, then it fails.
UnwrapAST ( AST a ) : IntPtr	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).
UpdateParamValue ( string id, string value ) : void	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.
UsingParams ( Microsoft.Z3.Tactic t, Params p ) : Microsoft.Z3.Tactic	Create a tactic that applies t using the given set of parameters p.
When ( Probe p, Microsoft.Z3.Tactic t ) : Microsoft.Z3.Tactic	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.
With ( Microsoft.Z3.Tactic t, Params p ) : Microsoft.Z3.Tactic	Create a tactic that applies t using the given set of parameters p. Alias for `UsingParams`
WrapAST ( IntPtr nativeObject ) : AST	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.

비공개 메소드들

메소드	설명
CheckContextMatch ( Z3Object other ) : void
InitContext ( ) : void
MkSymbols ( string names ) : Microsoft.Z3.Symbol[]	Create an array of symbols.
NativeErrorHandler ( IntPtr ctx, Z3_error_code errorCode ) : void
ObjectInvariant ( ) : void

메소드 상세

And() 공개 메소드

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

public And ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

AndThen() 공개 메소드

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

public AndThen ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic
t1	Microsoft.Z3.Tactic
t2	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

BenchmarkToSMTString() 공개 메소드

Convert a benchmark into an SMT-LIB formatted string.

public BenchmarkToSMTString ( string name, string logic, string status, string attributes, BoolExpr assumptions, BoolExpr formula ) : string
name	string	Name of the benchmark. The argument is optional.
logic	string	The benchmark logic.
status	string	The status string (sat, unsat, or unknown)
attributes	string	Other attributes, such as source, difficulty or category.
assumptions	BoolExpr	Auxiliary assumptions.
formula	BoolExpr	Formula to be checked for consistency in conjunction with assumptions.
리턴	string

Cond() 공개 메소드

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

public Cond ( Probe p, Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic
p	Probe
t1	Microsoft.Z3.Tactic
t2	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

ConstProbe() 공개 메소드

Create a probe that always evaluates to val.

public ConstProbe ( double val ) : Probe
val	double
리턴	Probe

Context() 공개 메소드

Constructor.

public Context ( ) : System
리턴	System

Context() 공개 메소드

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

public Context ( string>.Dictionary settings ) : System
settings	string>.Dictionary
리턴	System

Dispose() 공개 메소드

Disposes of the context.

public Dispose ( ) : void
리턴	void

Eq() 공개 메소드

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

public Eq ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

Fail() 공개 메소드

Create a tactic always fails.

public Fail ( ) : Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

FailIf() 공개 메소드

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

public FailIf ( Probe p ) : Microsoft.Z3.Tactic
p	Probe
리턴	Microsoft.Z3.Tactic

FailIfNotDecided() 공개 메소드

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

public FailIfNotDecided ( ) : Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

Ge() 공개 메소드

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

public Ge ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

Gt() 공개 메소드

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

public Gt ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

Interrupt() 공개 메소드

Interrupt the execution of a Z3 procedure.

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

public Interrupt ( ) : void
리턴	void

Le() 공개 메소드

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

public Le ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

Lt() 공개 메소드

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

public Lt ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

MkAdd() 공개 메소드

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

public MkAdd ( ) : ArithExpr
리턴	ArithExpr

MkAnd() 공개 메소드

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

public MkAnd ( ) : BoolExpr
리턴	BoolExpr

MkApp() 공개 메소드

Create a new function application.

public MkApp ( FuncDecl f ) : Expr
f	FuncDecl
리턴	Expr

MkArrayConst() 공개 메소드

Create an array constant.

public MkArrayConst ( Symbol name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArrayExpr
name	Symbol
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	ArrayExpr

MkArrayConst() 공개 메소드

Create an array constant.

public MkArrayConst ( string name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArrayExpr
name	string
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	ArrayExpr

MkArraySort() 공개 메소드

Create a new array sort.

public MkArraySort ( Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : ArraySort
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	ArraySort

MkBV() 공개 메소드

Create a bit-vector numeral.

public MkBV ( int v, uint size ) : BitVecNum
v	int	value of the numeral.
size	uint	the size of the bit-vector
리턴	BitVecNum

MkBV() 공개 메소드

Create a bit-vector numeral.

public MkBV ( long v, uint size ) : BitVecNum
v	long	value of the numeral.
size	uint	the size of the bit-vector
리턴	BitVecNum

MkBV() 공개 메소드

Create a bit-vector numeral.

public MkBV ( string v, uint size ) : BitVecNum
v	string	A string representing the value in decimal notation.
size	uint	the size of the bit-vector
리턴	BitVecNum

MkBV() 공개 메소드

Create a bit-vector numeral.

public MkBV ( uint v, uint size ) : BitVecNum
v	uint	value of the numeral.
size	uint	the size of the bit-vector
리턴	BitVecNum

MkBV() 공개 메소드

Create a bit-vector numeral.

public MkBV ( ulong v, uint size ) : BitVecNum
v	ulong	value of the numeral.
size	uint	the size of the bit-vector
리턴	BitVecNum

MkBV2Int() 공개 메소드

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.

public MkBV2Int ( BitVecExpr t, bool signed ) : IntExpr
t	BitVecExpr
signed	bool
리턴	IntExpr

MkBVAND() 공개 메소드

Bitwise conjunction.

The arguments must have a bit-vector sort.

public MkBVAND ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVASHR() 공개 메소드

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.

public MkBVASHR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVAdd() 공개 메소드

Two's complement addition.

The arguments must have the same bit-vector sort.

public MkBVAdd ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVAddNoOverflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVAddNoOverflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
isSigned	bool
리턴	BoolExpr

MkBVAddNoUnderflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVAddNoUnderflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVConst() 공개 메소드

Creates a bit-vector constant.

public MkBVConst ( Symbol name, uint size ) : BitVecExpr
name	Symbol
size	uint
리턴	BitVecExpr

MkBVConst() 공개 메소드

Creates a bit-vector constant.

public MkBVConst ( string name, uint size ) : BitVecExpr
name	string
size	uint
리턴	BitVecExpr

MkBVLSHR() 공개 메소드

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.

public MkBVLSHR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVMul() 공개 메소드

Two's complement multiplication.

The arguments must have the same bit-vector sort.

public MkBVMul ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVMulNoOverflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVMulNoOverflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
isSigned	bool
리턴	BoolExpr

MkBVMulNoUnderflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVMulNoUnderflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVNAND() 공개 메소드

Bitwise NAND.

The arguments must have a bit-vector sort.

public MkBVNAND ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVNOR() 공개 메소드

Bitwise NOR.

The arguments must have a bit-vector sort.

public MkBVNOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVNeg() 공개 메소드

Standard two's complement unary minus.

The arguments must have a bit-vector sort.

public MkBVNeg ( BitVecExpr t ) : BitVecExpr
t	BitVecExpr
리턴	BitVecExpr

MkBVNegNoOverflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVNegNoOverflow ( BitVecExpr t ) : BoolExpr
t	BitVecExpr
리턴	BoolExpr

MkBVNot() 공개 메소드

Bitwise negation.

The argument must have a bit-vector sort.

public MkBVNot ( BitVecExpr t ) : BitVecExpr
t	BitVecExpr
리턴	BitVecExpr

MkBVOR() 공개 메소드

Bitwise disjunction.

The arguments must have a bit-vector sort.

public MkBVOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVRedAND() 공개 메소드

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

The argument must have a bit-vector sort.

public MkBVRedAND ( BitVecExpr t ) : BitVecExpr
t	BitVecExpr
리턴	BitVecExpr

MkBVRedOR() 공개 메소드

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

The argument must have a bit-vector sort.

public MkBVRedOR ( BitVecExpr t ) : BitVecExpr
t	BitVecExpr
리턴	BitVecExpr

MkBVRotateLeft() 공개 메소드

Rotate Left.

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

public MkBVRotateLeft ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVRotateLeft() 공개 메소드

Rotate Left.

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

public MkBVRotateLeft ( uint i, BitVecExpr t ) : BitVecExpr
i	uint
t	BitVecExpr
리턴	BitVecExpr

MkBVRotateRight() 공개 메소드

Rotate Right.

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

public MkBVRotateRight ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVRotateRight() 공개 메소드

Rotate Right.

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

public MkBVRotateRight ( uint i, BitVecExpr t ) : BitVecExpr
i	uint
t	BitVecExpr
리턴	BitVecExpr

MkBVSDiv() 공개 메소드

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.

public MkBVSDiv ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVSDivNoOverflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVSDivNoOverflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSGE() 공개 메소드

Two's complement signed greater than or equal to.

The arguments must have the same bit-vector sort.

public MkBVSGE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSGT() 공개 메소드

Two's complement signed greater-than.

The arguments must have the same bit-vector sort.

public MkBVSGT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSHL() 공개 메소드

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.

public MkBVSHL ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVSLE() 공개 메소드

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

The arguments must have the same bit-vector sort.

public MkBVSLE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSLT() 공개 메소드

Two's complement signed less-than

The arguments must have the same bit-vector sort.

public MkBVSLT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSMod() 공개 메소드

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.

public MkBVSMod ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVSRem() 공개 메소드

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.

public MkBVSRem ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVSub() 공개 메소드

Two's complement subtraction.

The arguments must have the same bit-vector sort.

public MkBVSub ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVSubNoOverflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVSubNoOverflow ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVSubNoUnderflow() 공개 메소드

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

The arguments must be of bit-vector sort.

public MkBVSubNoUnderflow ( BitVecExpr t1, BitVecExpr t2, bool isSigned ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
isSigned	bool
리턴	BoolExpr

MkBVUDiv() 공개 메소드

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.

public MkBVUDiv ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVUGE() 공개 메소드

Unsigned greater than or equal to.

The arguments must have the same bit-vector sort.

public MkBVUGE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVUGT() 공개 메소드

Unsigned greater-than.

The arguments must have the same bit-vector sort.

public MkBVUGT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVULE() 공개 메소드

Unsigned less-than or equal to.

The arguments must have the same bit-vector sort.

public MkBVULE ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVULT() 공개 메소드

Unsigned less-than

The arguments must have the same bit-vector sort.

public MkBVULT ( BitVecExpr t1, BitVecExpr t2 ) : BoolExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BoolExpr

MkBVURem() 공개 메소드

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.

public MkBVURem ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVXNOR() 공개 메소드

Bitwise XNOR.

The arguments must have a bit-vector sort.

public MkBVXNOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBVXOR() 공개 메소드

Bitwise XOR.

The arguments must have a bit-vector sort.

public MkBVXOR ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkBitVecSort() 공개 메소드

Create a new bit-vector sort.

public MkBitVecSort ( uint size ) : BitVecSort
size	uint
리턴	BitVecSort

MkBool() 공개 메소드

Creates a Boolean value.

public MkBool ( bool value ) : BoolExpr
value	bool
리턴	BoolExpr

MkBoolConst() 공개 메소드

Create a Boolean constant.

public MkBoolConst ( Symbol name ) : BoolExpr
name	Symbol
리턴	BoolExpr

MkBoolConst() 공개 메소드

Create a Boolean constant.

public MkBoolConst ( string name ) : BoolExpr
name	string
리턴	BoolExpr

MkBoolSort() 공개 메소드

Create a new Boolean sort.

public MkBoolSort ( ) : BoolSort
리턴	BoolSort

MkBound() 공개 메소드

Creates a new bound variable.

public MkBound ( uint index, Microsoft.Z3.Sort ty ) : Expr
index	uint	The de-Bruijn index of the variable
ty	Microsoft.Z3.Sort	The sort of the variable
리턴	Expr

MkConcat() 공개 메소드

Bit-vector concatenation.

The arguments must have a bit-vector sort.

public MkConcat ( BitVecExpr t1, BitVecExpr t2 ) : BitVecExpr
t1	BitVecExpr
t2	BitVecExpr
리턴	BitVecExpr

MkConst() 공개 메소드

Creates a fresh constant from the FuncDecl f.

public MkConst ( FuncDecl f ) : Expr
f	FuncDecl	A decl of a 0-arity function
리턴	Expr

MkConst() 공개 메소드

Creates a new Constant of sort range and named name.

public MkConst ( Symbol name, Microsoft.Z3.Sort range ) : Expr
name	Symbol
range	Microsoft.Z3.Sort
리턴	Expr

MkConst() 공개 메소드

Creates a new Constant of sort range and named name.

public MkConst ( string name, Microsoft.Z3.Sort range ) : Expr
name	string
range	Microsoft.Z3.Sort
리턴	Expr

MkConstArray() 공개 메소드

Create a constant array.

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

public MkConstArray ( Microsoft.Z3.Sort domain, Expr v ) : ArrayExpr
domain	Microsoft.Z3.Sort
v	Expr
리턴	ArrayExpr

MkConstDecl() 공개 메소드

Creates a new constant function declaration.

public MkConstDecl ( Symbol name, Microsoft.Z3.Sort range ) : FuncDecl
name	Symbol
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkConstDecl() 공개 메소드

Creates a new constant function declaration.

public MkConstDecl ( string name, Microsoft.Z3.Sort range ) : FuncDecl
name	string
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkConstructor() 공개 메소드

Create a datatype constructor.

public MkConstructor ( Symbol name, Symbol recognizer, Symbol fieldNames = null, Microsoft.Z3.Sort sorts = null, uint sortRefs = null ) : Microsoft.Z3.Constructor
name	Symbol	constructor name
recognizer	Symbol	name of recognizer function.
fieldNames	Symbol	names of the constructor fields.
sorts	Microsoft.Z3.Sort	field sorts, 0 if the field sort refers to a recursive sort.
sortRefs	uint	reference to datatype sort that is an argument to the constructor; /// if the corresponding sort reference is 0, then the value in sort_refs should be an index /// referring to one of the recursive datatypes that is declared.
리턴	Microsoft.Z3.Constructor

MkConstructor() 공개 메소드

Create a datatype constructor.

public MkConstructor ( string name, string recognizer, string fieldNames = null, Microsoft.Z3.Sort sorts = null, uint sortRefs = null ) : Microsoft.Z3.Constructor
name	string
recognizer	string
fieldNames	string
sorts	Microsoft.Z3.Sort
sortRefs	uint
리턴	Microsoft.Z3.Constructor

MkDatatypeSort() 공개 메소드

Create a new datatype sort.

public MkDatatypeSort ( Symbol name, Microsoft.Z3.Constructor constructors ) : DatatypeSort
name	Symbol
constructors	Microsoft.Z3.Constructor
리턴	DatatypeSort

MkDatatypeSort() 공개 메소드

Create a new datatype sort.

public MkDatatypeSort ( string name, Microsoft.Z3.Constructor constructors ) : DatatypeSort
name	string
constructors	Microsoft.Z3.Constructor
리턴	DatatypeSort

MkDatatypeSorts() 공개 메소드

Create mutually recursive datatypes.

public MkDatatypeSorts ( Symbol names, Microsoft.Z3.Constructor c ) : Microsoft.Z3.DatatypeSort[]
names	Symbol	names of datatype sorts
c	Microsoft.Z3.Constructor	list of constructors, one list per sort.
리턴	Microsoft.Z3.DatatypeSort[]

MkDatatypeSorts() 공개 메소드

Create mutually recursive data-types.

public MkDatatypeSorts ( string names, Microsoft.Z3.Constructor c ) : Microsoft.Z3.DatatypeSort[]
names	string
c	Microsoft.Z3.Constructor
리턴	Microsoft.Z3.DatatypeSort[]

MkDistinct() 공개 메소드

Creates a distinct term.

public MkDistinct ( ) : BoolExpr
리턴	BoolExpr

MkDiv() 공개 메소드

Create an expression representing t1 / t2.

public MkDiv ( ArithExpr t1, ArithExpr t2 ) : ArithExpr
t1	ArithExpr
t2	ArithExpr
리턴	ArithExpr

MkEmptySet() 공개 메소드

Create an empty set.

public MkEmptySet ( Microsoft.Z3.Sort domain ) : Expr
domain	Microsoft.Z3.Sort
리턴	Expr

MkEnumSort() 공개 메소드

Create a new enumeration sort.

public MkEnumSort ( Symbol name ) : EnumSort
name	Symbol
리턴	EnumSort

MkEnumSort() 공개 메소드

Create a new enumeration sort.

public MkEnumSort ( string name ) : EnumSort
name	string
리턴	EnumSort

MkEq() 공개 메소드

Creates the equality x = y.

public MkEq ( Expr x, Expr y ) : BoolExpr
x	Expr
y	Expr
리턴	BoolExpr

MkExists() 공개 메소드

Create an existential Quantifier.

public MkExists ( Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
boundConstants	Expr
body	Expr
weight	uint
patterns	Pattern
noPatterns	Expr
quantifierID	Symbol
skolemID	Symbol
리턴	Quantifier

MkExists() 공개 메소드

Create an existential Quantifier.

public MkExists ( Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
sorts	Microsoft.Z3.Sort
names	Symbol
body	Expr
weight	uint
patterns	Pattern
noPatterns	Expr
quantifierID	Symbol
skolemID	Symbol
리턴	Quantifier

MkExtract() 공개 메소드

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.

public MkExtract ( uint high, uint low, BitVecExpr t ) : BitVecExpr
high	uint
low	uint
t	BitVecExpr
리턴	BitVecExpr

MkFalse() 공개 메소드

The false Term.

public MkFalse ( ) : BoolExpr
리턴	BoolExpr

MkFiniteDomainSort() 공개 메소드

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

public MkFiniteDomainSort ( Symbol name, ulong size ) : FiniteDomainSort
name	Symbol	The name used to identify the sort
size	ulong	The size of the sort
리턴	FiniteDomainSort

MkFiniteDomainSort() 공개 메소드

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.

public MkFiniteDomainSort ( string name, ulong size ) : FiniteDomainSort
name	string	The name used to identify the sort
size	ulong	The size of the sort
리턴	FiniteDomainSort

MkFixedpoint() 공개 메소드

Create a Fixedpoint context.

public MkFixedpoint ( ) : Fixedpoint
리턴	Fixedpoint

MkForall() 공개 메소드

Create a universal Quantifier.

public MkForall ( Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
boundConstants	Expr
body	Expr
weight	uint
patterns	Pattern
noPatterns	Expr
quantifierID	Symbol
skolemID	Symbol
리턴	Quantifier

MkForall() 공개 메소드

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.

public MkForall ( Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
sorts	Microsoft.Z3.Sort	the sorts of the bound variables.
names	Symbol	names of the bound variables
body	Expr	the body of the quantifier.
weight	uint	quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0.
patterns	Pattern	array containing the patterns created using MkPattern.
noPatterns	Expr	array containing the anti-patterns created using MkPattern.
quantifierID	Symbol	optional symbol to track quantifier.
skolemID	Symbol	optional symbol to track skolem constants.
리턴	Quantifier

MkFreshConst() 공개 메소드

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

public MkFreshConst ( string prefix, Microsoft.Z3.Sort range ) : Expr
prefix	string
range	Microsoft.Z3.Sort
리턴	Expr

MkFreshConstDecl() 공개 메소드

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

public MkFreshConstDecl ( string prefix, Microsoft.Z3.Sort range ) : FuncDecl
prefix	string
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkFreshFuncDecl() 공개 메소드

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

public MkFreshFuncDecl ( string prefix, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl
prefix	string
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkFullSet() 공개 메소드

Create the full set.

public MkFullSet ( Microsoft.Z3.Sort domain ) : Expr
domain	Microsoft.Z3.Sort
리턴	Expr

MkFuncDecl() 공개 메소드

Creates a new function declaration.

public MkFuncDecl ( Symbol name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl
name	Symbol
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkFuncDecl() 공개 메소드

Creates a new function declaration.

public MkFuncDecl ( string name, Microsoft.Z3.Sort domain, Microsoft.Z3.Sort range ) : FuncDecl
name	string
domain	Microsoft.Z3.Sort
range	Microsoft.Z3.Sort
리턴	FuncDecl

MkGe() 공개 메소드

Create an expression representing t1 >= t2

public MkGe ( ArithExpr t1, ArithExpr t2 ) : BoolExpr
t1	ArithExpr
t2	ArithExpr
리턴	BoolExpr

MkGoal() 공개 메소드

Creates a new Goal.

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

public MkGoal ( bool models = true, bool unsatCores = false, bool proofs = false ) : Goal
models	bool	Indicates whether model generation should be enabled.
unsatCores	bool	Indicates whether unsat core generation should be enabled.
proofs	bool	Indicates whether proof generation should be enabled.
리턴	Goal

MkGt() 공개 메소드

Create an expression representing t1 > t2

public MkGt ( ArithExpr t1, ArithExpr t2 ) : BoolExpr
t1	ArithExpr
t2	ArithExpr
리턴	BoolExpr

MkITE() 공개 메소드

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

public MkITE ( BoolExpr t1, Expr t2, Expr t3 ) : Expr
t1	BoolExpr	An expression with Boolean sort
t2	Expr	An expression
t3	Expr	An expression with the same sort as
리턴	Expr

MkIff() 공개 메소드

Create an expression representing t1 iff t2.

public MkIff ( BoolExpr t1, BoolExpr t2 ) : BoolExpr
t1	BoolExpr
t2	BoolExpr
리턴	BoolExpr

MkImplies() 공개 메소드

Create an expression representing t1 -> t2.

public MkImplies ( BoolExpr t1, BoolExpr t2 ) : BoolExpr
t1	BoolExpr
t2	BoolExpr
리턴	BoolExpr

MkInt() 공개 메소드

Create an integer numeral.

public MkInt ( int v ) : IntNum
v	int	value of the numeral.
리턴	IntNum

MkInt() 공개 메소드

Create an integer numeral.

public MkInt ( long v ) : IntNum
v	long	value of the numeral.
리턴	IntNum

MkInt() 공개 메소드

Create an integer numeral.

public MkInt ( string v ) : IntNum
v	string	A string representing the Term value in decimal notation.
리턴	IntNum

MkInt() 공개 메소드

Create an integer numeral.

public MkInt ( uint v ) : IntNum
v	uint	value of the numeral.
리턴	IntNum

MkInt() 공개 메소드

Create an integer numeral.

public MkInt ( ulong v ) : IntNum
v	ulong	value of the numeral.
리턴	IntNum

MkInt2BV() 공개 메소드

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.

public MkInt2BV ( uint n, IntExpr t ) : BitVecExpr
n	uint
t	IntExpr
리턴	BitVecExpr

MkInt2Real() 공개 메소드

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.

public MkInt2Real ( IntExpr t ) : RealExpr
t	IntExpr
리턴	RealExpr

MkIntConst() 공개 메소드

Creates an integer constant.

public MkIntConst ( Symbol name ) : IntExpr
name	Symbol
리턴	IntExpr

MkIntConst() 공개 메소드

Creates an integer constant.

public MkIntConst ( string name ) : IntExpr
name	string
리턴	IntExpr

MkIntSort() 공개 메소드

Create a new integer sort.

public MkIntSort ( ) : IntSort
리턴	IntSort

MkIsInteger() 공개 메소드

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

public MkIsInteger ( RealExpr t ) : BoolExpr
t	RealExpr
리턴	BoolExpr

MkLe() 공개 메소드

Create an expression representing t1 <= t2

public MkLe ( ArithExpr t1, ArithExpr t2 ) : BoolExpr
t1	ArithExpr
t2	ArithExpr
리턴	BoolExpr

MkListSort() 공개 메소드

Create a new list sort.

public MkListSort ( Symbol name, Microsoft.Z3.Sort elemSort ) : ListSort
name	Symbol
elemSort	Microsoft.Z3.Sort
리턴	ListSort

MkListSort() 공개 메소드

Create a new list sort.

public MkListSort ( string name, Microsoft.Z3.Sort elemSort ) : ListSort
name	string
elemSort	Microsoft.Z3.Sort
리턴	ListSort

MkLt() 공개 메소드

Create an expression representing t1 < t2

public MkLt ( ArithExpr t1, ArithExpr t2 ) : BoolExpr
t1	ArithExpr
t2	ArithExpr
리턴	BoolExpr

MkMap() 공개 메소드

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

public MkMap ( FuncDecl f ) : ArrayExpr
f	FuncDecl
리턴	ArrayExpr

MkMod() 공개 메소드

Create an expression representing t1 mod t2.

The arguments must have int type.

public MkMod ( IntExpr t1, IntExpr t2 ) : IntExpr
t1	IntExpr
t2	IntExpr
리턴	IntExpr

MkMul() 공개 메소드

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

public MkMul ( ) : ArithExpr
리턴	ArithExpr

MkNot() 공개 메소드

Mk an expression representing not(a).

public MkNot ( BoolExpr a ) : BoolExpr
a	BoolExpr
리턴	BoolExpr

MkNumeral() 공개 메소드

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.

public MkNumeral ( int v, Microsoft.Z3.Sort ty ) : Expr
v	int	Value of the numeral
ty	Microsoft.Z3.Sort	Sort of the numeral
리턴	Expr

MkNumeral() 공개 메소드

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.

public MkNumeral ( long v, Microsoft.Z3.Sort ty ) : Expr
v	long	Value of the numeral
ty	Microsoft.Z3.Sort	Sort of the numeral
리턴	Expr

MkNumeral() 공개 메소드

Create a Term of a given sort.

public MkNumeral ( string v, Microsoft.Z3.Sort ty ) : Expr
v	string	A string representing the Term value in decimal notation. If the given sort is a real, then the Term can be a rational, that is, a string of the form [num]* / [num]*.
ty	Microsoft.Z3.Sort	The sort of the numeral. In the current implementation, the given sort can be an int, real, or bit-vectors of arbitrary size.
리턴	Expr

MkNumeral() 공개 메소드

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.

public MkNumeral ( uint v, Microsoft.Z3.Sort ty ) : Expr
v	uint	Value of the numeral
ty	Microsoft.Z3.Sort	Sort of the numeral
리턴	Expr

MkNumeral() 공개 메소드

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.

public MkNumeral ( ulong v, Microsoft.Z3.Sort ty ) : Expr
v	ulong	Value of the numeral
ty	Microsoft.Z3.Sort	Sort of the numeral
리턴	Expr

MkOr() 공개 메소드

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

public MkOr ( ) : BoolExpr
리턴	BoolExpr

MkParams() 공개 메소드

Creates a new ParameterSet.

public MkParams ( ) : Params
리턴	Params

MkPattern() 공개 메소드

Create a quantifier pattern.

public MkPattern ( ) : Pattern
리턴	Pattern

MkPower() 공개 메소드

Create an expression representing t1 ^ t2.

public MkPower ( ArithExpr t1, ArithExpr t2 ) : ArithExpr
t1	ArithExpr
t2	ArithExpr
리턴	ArithExpr

MkProbe() 공개 메소드

Creates a new Probe.

public MkProbe ( string name ) : Probe
name	string
리턴	Probe

MkQuantifier() 공개 메소드

Create a Quantifier.

public MkQuantifier ( bool universal, Expr boundConstants, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
universal	bool
boundConstants	Expr
body	Expr
weight	uint
patterns	Pattern
noPatterns	Expr
quantifierID	Symbol
skolemID	Symbol
리턴	Quantifier

MkQuantifier() 공개 메소드

Create a Quantifier.

public MkQuantifier ( bool universal, Microsoft.Z3.Sort sorts, Symbol names, Expr body, uint weight = 1, Pattern patterns = null, Expr noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null ) : Quantifier
universal	bool
sorts	Microsoft.Z3.Sort
names	Symbol
body	Expr
weight	uint
patterns	Pattern
noPatterns	Expr
quantifierID	Symbol
skolemID	Symbol
리턴	Quantifier

MkReal() 공개 메소드

Create a real numeral.

public MkReal ( int v ) : RatNum
v	int	value of the numeral.
리턴	RatNum

MkReal() 공개 메소드

Create a real from a fraction.

public MkReal ( int num, int den ) : RatNum
num	int	numerator of rational.
den	int	denominator of rational.
리턴	RatNum

MkReal() 공개 메소드

Create a real numeral.

public MkReal ( long v ) : RatNum
v	long	value of the numeral.
리턴	RatNum

MkReal() 공개 메소드

Create a real numeral.

public MkReal ( string v ) : RatNum
v	string	A string representing the Term value in decimal notation.
리턴	RatNum

MkReal() 공개 메소드

Create a real numeral.

public MkReal ( uint v ) : RatNum
v	uint	value of the numeral.
리턴	RatNum

MkReal() 공개 메소드

Create a real numeral.

public MkReal ( ulong v ) : RatNum
v	ulong	value of the numeral.
리턴	RatNum

MkReal2Int() 공개 메소드

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.

public MkReal2Int ( RealExpr t ) : IntExpr
t	RealExpr
리턴	IntExpr

MkRealConst() 공개 메소드

Creates a real constant.

public MkRealConst ( Symbol name ) : RealExpr
name	Symbol
리턴	RealExpr

MkRealConst() 공개 메소드

Creates a real constant.

public MkRealConst ( string name ) : RealExpr
name	string
리턴	RealExpr

MkRealSort() 공개 메소드

Create a real sort.

public MkRealSort ( ) : RealSort
리턴	RealSort

MkRem() 공개 메소드

Create an expression representing t1 rem t2.

The arguments must have int type.

public MkRem ( IntExpr t1, IntExpr t2 ) : IntExpr
t1	IntExpr
t2	IntExpr
리턴	IntExpr

MkRepeat() 공개 메소드

Bit-vector repetition.

The argument t must have a bit-vector sort.

public MkRepeat ( uint i, BitVecExpr t ) : BitVecExpr
i	uint
t	BitVecExpr
리턴	BitVecExpr

MkSelect() 공개 메소드

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

public MkSelect ( ArrayExpr a, Expr i ) : Expr
a	ArrayExpr
i	Expr
리턴	Expr

MkSetAdd() 공개 메소드

Add an element to the set.

public MkSetAdd ( Expr set, Expr element ) : Expr
set	Expr
element	Expr
리턴	Expr

MkSetComplement() 공개 메소드

Take the complement of a set.

public MkSetComplement ( Expr arg ) : Expr
arg	Expr
리턴	Expr

MkSetDel() 공개 메소드

Remove an element from a set.

public MkSetDel ( Expr set, Expr element ) : Expr
set	Expr
element	Expr
리턴	Expr

MkSetDifference() 공개 메소드

Take the difference between two sets.

public MkSetDifference ( Expr arg1, Expr arg2 ) : Expr
arg1	Expr
arg2	Expr
리턴	Expr

MkSetIntersection() 공개 메소드

Take the intersection of a list of sets.

public MkSetIntersection ( ) : Expr
리턴	Expr

MkSetMembership() 공개 메소드

Check for set membership.

public MkSetMembership ( Expr elem, Expr set ) : Expr
elem	Expr
set	Expr
리턴	Expr

MkSetSort() 공개 메소드

Create a set type.

public MkSetSort ( Microsoft.Z3.Sort ty ) : SetSort
ty	Microsoft.Z3.Sort
리턴	SetSort

MkSetSubset() 공개 메소드

Check for subsetness of sets.

public MkSetSubset ( Expr arg1, Expr arg2 ) : Expr
arg1	Expr
arg2	Expr
리턴	Expr

MkSetUnion() 공개 메소드

Take the union of a list of sets.

public MkSetUnion ( ) : Expr
리턴	Expr

MkSignExt() 공개 메소드

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.

public MkSignExt ( uint i, BitVecExpr t ) : BitVecExpr
i	uint
t	BitVecExpr
리턴	BitVecExpr

MkSimpleSolver() 공개 메소드

Creates a new (incremental) solver.

public MkSimpleSolver ( ) : Solver
리턴	Solver

MkSolver() 공개 메소드

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.

public MkSolver ( Symbol logic = null ) : Solver
logic	Symbol
리턴	Solver

MkSolver() 공개 메소드

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.

public MkSolver ( Microsoft.Z3.Tactic t ) : Solver
t	Microsoft.Z3.Tactic
리턴	Solver

MkSolver() 공개 메소드

Creates a new (incremental) solver.

public MkSolver ( string logic ) : Solver
logic	string
리턴	Solver

MkStore() 공개 메소드

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

public MkStore ( ArrayExpr a, Expr i, Expr v ) : ArrayExpr
a	ArrayExpr
i	Expr
v	Expr
리턴	ArrayExpr

MkSub() 공개 메소드

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

public MkSub ( ) : ArithExpr
리턴	ArithExpr

MkSymbol() 공개 메소드

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.

public MkSymbol ( int i ) : IntSymbol
i	int
리턴	IntSymbol

MkSymbol() 공개 메소드

Create a symbol using a string.

public MkSymbol ( string name ) : StringSymbol
name	string
리턴	StringSymbol

MkTactic() 공개 메소드

Creates a new Tactic.

public MkTactic ( string name ) : Microsoft.Z3.Tactic
name	string
리턴	Microsoft.Z3.Tactic

MkTermArray() 공개 메소드

Access the array default value.

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

public MkTermArray ( ArrayExpr array ) : Expr
array	ArrayExpr
리턴	Expr

MkTrue() 공개 메소드

The true Term.

public MkTrue ( ) : BoolExpr
리턴	BoolExpr

MkTupleSort() 공개 메소드

Create a new tuple sort.

public MkTupleSort ( Symbol name, Symbol fieldNames, Microsoft.Z3.Sort fieldSorts ) : TupleSort
name	Symbol
fieldNames	Symbol
fieldSorts	Microsoft.Z3.Sort
리턴	TupleSort

MkUnaryMinus() 공개 메소드

Create an expression representing -t.

public MkUnaryMinus ( ArithExpr t ) : ArithExpr
t	ArithExpr
리턴	ArithExpr

MkUninterpretedSort() 공개 메소드

Create a new uninterpreted sort.

public MkUninterpretedSort ( Symbol s ) : UninterpretedSort
s	Symbol
리턴	UninterpretedSort

MkUninterpretedSort() 공개 메소드

Create a new uninterpreted sort.

public MkUninterpretedSort ( string str ) : UninterpretedSort
str	string
리턴	UninterpretedSort

MkXor() 공개 메소드

Create an expression representing t1 xor t2.

public MkXor ( BoolExpr t1, BoolExpr t2 ) : BoolExpr
t1	BoolExpr
t2	BoolExpr
리턴	BoolExpr

MkZeroExt() 공개 메소드

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.

public MkZeroExt ( uint i, BitVecExpr t ) : BitVecExpr
i	uint
t	BitVecExpr
리턴	BitVecExpr

Not() 공개 메소드

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

public Not ( Probe p ) : Probe
p	Probe
리턴	Probe

Or() 공개 메소드

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

public Or ( Probe p1, Probe p2 ) : Probe
p1	Probe
p2	Probe
리턴	Probe

OrElse() 공개 메소드

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

public OrElse ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic
t1	Microsoft.Z3.Tactic
t2	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

ParAndThen() 공개 메소드

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.

public ParAndThen ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic
t1	Microsoft.Z3.Tactic
t2	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

ParOr() 공개 메소드

Create a tactic that applies the given tactics in parallel.

public ParOr ( ) : Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

ParseSMTLIB2File() 공개 메소드

Parse the given file using the SMT-LIB2 parser.

public ParseSMTLIB2File ( string fileName, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : BoolExpr
fileName	string
sortNames	Symbol
sorts	Microsoft.Z3.Sort
declNames	Symbol
decls	FuncDecl
리턴	BoolExpr

ParseSMTLIB2String() 공개 메소드

Parse the given string using the SMT-LIB2 parser.

public ParseSMTLIB2String ( string str, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : BoolExpr
str	string
sortNames	Symbol
sorts	Microsoft.Z3.Sort
declNames	Symbol
decls	FuncDecl
리턴	BoolExpr

ParseSMTLIBFile() 공개 메소드

Parse the given file using the SMT-LIB parser.

public ParseSMTLIBFile ( string fileName, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : void
fileName	string
sortNames	Symbol
sorts	Microsoft.Z3.Sort
declNames	Symbol
decls	FuncDecl
리턴	void

ParseSMTLIBString() 공개 메소드

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.

public ParseSMTLIBString ( string str, Symbol sortNames = null, Microsoft.Z3.Sort sorts = null, Symbol declNames = null, FuncDecl decls = null ) : void
str	string
sortNames	Symbol
sorts	Microsoft.Z3.Sort
declNames	Symbol
decls	FuncDecl
리턴	void

ProbeDescription() 공개 메소드

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

public ProbeDescription ( string name ) : string
name	string
리턴	string

Repeat() 공개 메소드

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

public Repeat ( Microsoft.Z3.Tactic t, uint max = uint.MaxValue ) : Microsoft.Z3.Tactic
t	Microsoft.Z3.Tactic
max	uint
리턴	Microsoft.Z3.Tactic

SimplifyHelp() 공개 메소드

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

public SimplifyHelp ( ) : string
리턴	string

Skip() 공개 메소드

Create a tactic that just returns the given goal.

public Skip ( ) : Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

TacticDescription() 공개 메소드

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

public TacticDescription ( string name ) : string
name	string
리턴	string

Then() 공개 메소드

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

Shorthand for AndThen.

public Then ( Microsoft.Z3.Tactic t1, Microsoft.Z3.Tactic t2 ) : Microsoft.Z3.Tactic
t1	Microsoft.Z3.Tactic
t2	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

ToggleWarningMessages() 공개 정적인 메소드

Enable/disable printing of warning messages to the console.

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

public static ToggleWarningMessages ( bool enabled ) : void
enabled	bool
리턴	void

TryFor() 공개 메소드

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

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

public TryFor ( Microsoft.Z3.Tactic t, uint ms ) : Microsoft.Z3.Tactic
t	Microsoft.Z3.Tactic
ms	uint
리턴	Microsoft.Z3.Tactic

UnwrapAST() 공개 메소드

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).

public UnwrapAST ( AST a ) : IntPtr
a	AST	The AST to unwrap.
리턴	System.IntPtr

UpdateParamValue() 공개 메소드

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.

public UpdateParamValue ( string id, string value ) : void
id	string
value	string
리턴	void

UsingParams() 공개 메소드

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

public UsingParams ( Microsoft.Z3.Tactic t, Params p ) : Microsoft.Z3.Tactic
t	Microsoft.Z3.Tactic
p	Params
리턴	Microsoft.Z3.Tactic

When() 공개 메소드

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.

public When ( Probe p, Microsoft.Z3.Tactic t ) : Microsoft.Z3.Tactic
p	Probe
t	Microsoft.Z3.Tactic
리턴	Microsoft.Z3.Tactic

With() 공개 메소드

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

Alias for UsingParams

public With ( Microsoft.Z3.Tactic t, Params p ) : Microsoft.Z3.Tactic
t	Microsoft.Z3.Tactic
p	Params
리턴	Microsoft.Z3.Tactic

WrapAST() 공개 메소드

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.

public WrapAST ( IntPtr nativeObject ) : AST
nativeObject	System.IntPtr	The native pointer to wrap.
리턴	AST