Context

java.lang.Object
- com.microsoft.z3.IDisposable
- - com.microsoft.z3.Context

Direct Known Subclasses:

InterpolationContext
```
public class Context
extends IDisposable
```
The main interaction with Z3 happens via the Context.

Field Summary

Fields
Modifier and Type Field and Description

protected static java.lang.Object creation_lock

protected long m_ctx

protected java.util.concurrent.atomic.AtomicInteger m_refCount

Fields
Modifier and Type	Field and Description
`protected static java.lang.Object`	`creation_lock`
`protected long`	`m_ctx`
`protected java.util.concurrent.atomic.AtomicInteger`	`m_refCount`

Constructor Summary

Constructors
Constructor and Description

Context()
Constructor.

Context(java.util.Map<java.lang.String,java.lang.String> settings)
Constructor.

Constructors
Constructor and Description
`Context()` Constructor.
`Context(java.util.Map<java.lang.String,java.lang.String> settings)` Constructor.

Method Summary

Methods
Modifier and Type	Method and Description
`Probe`	`and(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value `p1` and `p2` evaluate to "true".
`Tactic`	`andThen(Tactic t1, Tactic t2, Tactic... ts)` Create a tactic that applies `t1` to a Goal and then `t2"/> to every subgoal produced by <paramref name="t1`.
`java.lang.String`	`benchmarkToSMTString(java.lang.String name, java.lang.String logic, java.lang.String status, java.lang.String attributes, BoolExpr[] assumptions, BoolExpr formula)` Convert a benchmark into an SMT-LIB formatted string.
`Tactic`	`cond(Probe p, Tactic t1, Tactic t2)` Create a tactic that applies `t1` to a given goal if the probe `p"/> evaluates to true and <paramref name="t2` otherwise.
`Probe`	`constProbe(double val)` Create a probe that always evaluates to `val`.
`void`	`dispose()` Disposes of the context.
`Probe`	`eq(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value returned by `p1` is equal to the value returned by `p2`
`Tactic`	`fail()` Create a tactic always fails.
`Tactic`	`failIf(Probe p)` Create a tactic that fails if the probe `p` evaluates to false.
`Tactic`	`failIfNotDecided()` Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) or trivially unsatisfiable (i.e., contains `false').
`protected void`	`finalize()` Finalizer.
`Probe`	`ge(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value returned by `p1` is greater than or equal the value returned by `p2`
`IDecRefQueue`	`getApplyResultDRQ()`
`IDecRefQueue`	`getASTDRQ()`
`IDecRefQueue`	`getASTMapDRQ()`
`IDecRefQueue`	`getASTVectorDRQ()`
`BoolSort`	`getBoolSort()` Retrieves the Boolean sort of the context.
`IDecRefQueue`	`getFixedpointDRQ()`
`IDecRefQueue`	`getFuncEntryDRQ()`
`IDecRefQueue`	`getFuncInterpDRQ()`
`IDecRefQueue`	`getGoalDRQ()`
`IntSort`	`getIntSort()` Retrieves the Integer sort of the context.
`IDecRefQueue`	`getModelDRQ()`
`int`	`getNumProbes()` The number of supported Probes.
`int`	`getNumSMTLIBAssumptions()` The number of SMTLIB assumptions parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`int`	`getNumSMTLIBDecls()` The number of SMTLIB declarations parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`int`	`getNumSMTLIBFormulas()` The number of SMTLIB formulas parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`int`	`getNumSMTLIBSorts()` The number of SMTLIB sorts parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`int`	`getNumTactics()` The number of supported tactics.
`IDecRefQueue`	`getOptimizeDRQ()`
`IDecRefQueue`	`getParamDescrsDRQ()`
`IDecRefQueue`	`getParamsDRQ()`
`java.lang.String`	`getProbeDescription(java.lang.String name)` Returns a string containing a description of the probe with the given name.
`IDecRefQueue`	`getProbeDRQ()`
`java.lang.String[]`	`getProbeNames()` The names of all supported Probes.
`RealSort`	`getRealSort()` Retrieves the Real sort of the context.
`ParamDescrs`	`getSimplifyParameterDescriptions()` Retrieves parameter descriptions for simplifier.
`BoolExpr[]`	`getSMTLIBAssumptions()` The assumptions parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`FuncDecl[]`	`getSMTLIBDecls()` The declarations parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`BoolExpr[]`	`getSMTLIBFormulas()` The formulas parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`Sort[]`	`getSMTLIBSorts()` The declarations parsed by the last call to `ParseSMTLIBString` or `ParseSMTLIBFile`.
`IDecRefQueue`	`getSolverDRQ()`
`IDecRefQueue`	`getStatisticsDRQ()`
`SeqSort`	`getStringSort()` Retrieves the Integer sort of the context.
`java.lang.String`	`getTacticDescription(java.lang.String name)` Returns a string containing a description of the tactic with the given name.
`IDecRefQueue`	`getTacticDRQ()`
`java.lang.String[]`	`getTacticNames()` The names of all supported tactics.
`Probe`	`gt(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value returned by `p1` is greater than the value returned by `p2`
`void`	`interrupt()` Interrupt the execution of a Z3 procedure.
`Probe`	`le(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value returned by `p1` is less than or equal the value returned by `p2`
`Probe`	`lt(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value returned by `p1` is less than the value returned by `p2`
`ArithExpr`	`mkAdd(ArithExpr... t)` Create an expression representing `t[0] + t[1] + ...`.
`BoolExpr`	`mkAnd(BoolExpr... t)` Create an expression representing `t[0] and t[1] and ...`.
`Expr`	`mkApp(FuncDecl f, Expr... args)` Create a new function application.
`ArrayExpr`	`mkArrayConst(java.lang.String name, Sort domain, Sort range)` Create an array constant.
`ArrayExpr`	`mkArrayConst(Symbol name, Sort domain, Sort range)` Create an array constant.
`Expr`	`mkArrayExt(ArrayExpr arg1, ArrayExpr arg2)` Create Extentionality index.
`ArraySort`	`mkArraySort(Sort domain, Sort range)` Create a new array sort.
`SeqExpr`	`MkAt(SeqExpr s, IntExpr index)` Retrieve sequence of length one at index.
`BitVecSort`	`mkBitVecSort(int size)` Create a new bit-vector sort.
`BoolExpr`	`mkBool(boolean value)` Creates a Boolean value.
`BoolExpr`	`mkBoolConst(java.lang.String name)` Create a Boolean constant.
`BoolExpr`	`mkBoolConst(Symbol name)` Create a Boolean constant.
`BoolSort`	`mkBoolSort()` Create a new Boolean sort.
`Expr`	`mkBound(int index, Sort ty)` Creates a new bound variable.
`BitVecNum`	`mkBV(int v, int size)` Create a bit-vector numeral.
`BitVecNum`	`mkBV(long v, int size)` Create a bit-vector numeral.
`BitVecNum`	`mkBV(java.lang.String v, int size)` Create a bit-vector numeral.
`IntExpr`	`mkBV2Int(BitVecExpr t, boolean signed)` Create an integer from the bit-vector argument `t`.
`BitVecExpr`	`mkBVAdd(BitVecExpr t1, BitVecExpr t2)` Two's complement addition.
`BoolExpr`	`mkBVAddNoOverflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned)` Create a predicate that checks that the bit-wise addition does not overflow.
`BoolExpr`	`mkBVAddNoUnderflow(BitVecExpr t1, BitVecExpr t2)` Create a predicate that checks that the bit-wise addition does not underflow.
`BitVecExpr`	`mkBVAND(BitVecExpr t1, BitVecExpr t2)` Bitwise conjunction.
`BitVecExpr`	`mkBVASHR(BitVecExpr t1, BitVecExpr t2)` Arithmetic shift right Remarks: 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.
`BitVecExpr`	`mkBVConst(java.lang.String name, int size)` Creates a bit-vector constant.
`BitVecExpr`	`mkBVConst(Symbol name, int size)` Creates a bit-vector constant.
`BitVecExpr`	`mkBVLSHR(BitVecExpr t1, BitVecExpr t2)` Logical shift right Remarks: It is equivalent to unsigned division by `2^x` where \c x is the value of `t2`.
`BitVecExpr`	`mkBVMul(BitVecExpr t1, BitVecExpr t2)` Two's complement multiplication.
`BoolExpr`	`mkBVMulNoOverflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned)` Create a predicate that checks that the bit-wise multiplication does not overflow.
`BoolExpr`	`mkBVMulNoUnderflow(BitVecExpr t1, BitVecExpr t2)` Create a predicate that checks that the bit-wise multiplication does not underflow.
`BitVecExpr`	`mkBVNAND(BitVecExpr t1, BitVecExpr t2)` Bitwise NAND.
`BitVecExpr`	`mkBVNeg(BitVecExpr t)` Standard two's complement unary minus.
`BoolExpr`	`mkBVNegNoOverflow(BitVecExpr t)` Create a predicate that checks that the bit-wise negation does not overflow.
`BitVecExpr`	`mkBVNOR(BitVecExpr t1, BitVecExpr t2)` Bitwise NOR.
`BitVecExpr`	`mkBVNot(BitVecExpr t)` Bitwise negation.
`BitVecExpr`	`mkBVOR(BitVecExpr t1, BitVecExpr t2)` Bitwise disjunction.
`BitVecExpr`	`mkBVRedAND(BitVecExpr t)` Take conjunction of bits in a vector, return vector of length 1.
`BitVecExpr`	`mkBVRedOR(BitVecExpr t)` Take disjunction of bits in a vector, return vector of length 1.
`BitVecExpr`	`mkBVRotateLeft(BitVecExpr t1, BitVecExpr t2)` Rotate Left.
`BitVecExpr`	`mkBVRotateLeft(int i, BitVecExpr t)` Rotate Left.
`BitVecExpr`	`mkBVRotateRight(BitVecExpr t1, BitVecExpr t2)` Rotate Right.
`BitVecExpr`	`mkBVRotateRight(int i, BitVecExpr t)` Rotate Right.
`BitVecExpr`	`mkBVSDiv(BitVecExpr t1, BitVecExpr t2)` Signed division.
`BoolExpr`	`mkBVSDivNoOverflow(BitVecExpr t1, BitVecExpr t2)` Create a predicate that checks that the bit-wise signed division does not overflow.
`BoolExpr`	`mkBVSGE(BitVecExpr t1, BitVecExpr t2)` Two's complement signed greater than or equal to.
`BoolExpr`	`mkBVSGT(BitVecExpr t1, BitVecExpr t2)` Two's complement signed greater-than.
`BitVecExpr`	`mkBVSHL(BitVecExpr t1, BitVecExpr t2)` Shift left.
`BoolExpr`	`mkBVSLE(BitVecExpr t1, BitVecExpr t2)` Two's complement signed less-than or equal to.
`BoolExpr`	`mkBVSLT(BitVecExpr t1, BitVecExpr t2)` Two's complement signed less-than Remarks: The arguments must have the same bit-vector sort.
`BitVecExpr`	`mkBVSMod(BitVecExpr t1, BitVecExpr t2)` Two's complement signed remainder (sign follows divisor).
`BitVecExpr`	`mkBVSRem(BitVecExpr t1, BitVecExpr t2)` Signed remainder.
`BitVecExpr`	`mkBVSub(BitVecExpr t1, BitVecExpr t2)` Two's complement subtraction.
`BoolExpr`	`mkBVSubNoOverflow(BitVecExpr t1, BitVecExpr t2)` Create a predicate that checks that the bit-wise subtraction does not overflow.
`BoolExpr`	`mkBVSubNoUnderflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned)` Create a predicate that checks that the bit-wise subtraction does not underflow.
`BitVecExpr`	`mkBVUDiv(BitVecExpr t1, BitVecExpr t2)` Unsigned division.
`BoolExpr`	`mkBVUGE(BitVecExpr t1, BitVecExpr t2)` Unsigned greater than or equal to.
`BoolExpr`	`mkBVUGT(BitVecExpr t1, BitVecExpr t2)` Unsigned greater-than.
`BoolExpr`	`mkBVULE(BitVecExpr t1, BitVecExpr t2)` Unsigned less-than or equal to.
`BoolExpr`	`mkBVULT(BitVecExpr t1, BitVecExpr t2)` Unsigned less-than Remarks: The arguments must have the same bit-vector sort.
`BitVecExpr`	`mkBVURem(BitVecExpr t1, BitVecExpr t2)` Unsigned remainder.
`BitVecExpr`	`mkBVXNOR(BitVecExpr t1, BitVecExpr t2)` Bitwise XNOR.
`BitVecExpr`	`mkBVXOR(BitVecExpr t1, BitVecExpr t2)` Bitwise XOR.
`BitVecExpr`	`mkConcat(BitVecExpr t1, BitVecExpr t2)` Bit-vector concatenation.
`ReExpr`	`MkConcat(ReExpr... t)` Create the concatenation of regular languages.
`SeqExpr`	`MkConcat(SeqExpr... t)` Concatentate sequences.
`Expr`	`mkConst(FuncDecl f)` Creates a fresh constant from the FuncDecl `f`.
`Expr`	`mkConst(java.lang.String name, Sort range)` Creates a new Constant of sort `range` and named `name`.
`Expr`	`mkConst(Symbol name, Sort range)` Creates a new Constant of sort `range` and named `name`.
`ArrayExpr`	`mkConstArray(Sort domain, Expr v)` Create a constant array.
`FuncDecl`	`mkConstDecl(java.lang.String name, Sort range)` Creates a new constant function declaration.
`FuncDecl`	`mkConstDecl(Symbol name, Sort range)` Creates a new constant function declaration.
`Constructor`	`mkConstructor(java.lang.String name, java.lang.String recognizer, java.lang.String[] fieldNames, Sort[] sorts, int[] sortRefs)` Create a datatype constructor.
`Constructor`	`mkConstructor(Symbol name, Symbol recognizer, Symbol[] fieldNames, Sort[] sorts, int[] sortRefs)` Create a datatype constructor.
`BoolExpr`	`MkContains(SeqExpr s1, SeqExpr s2)` Check for sequence containment of s2 in s1.
`DatatypeSort`	`mkDatatypeSort(java.lang.String name, Constructor[] constructors)` Create a new datatype sort.
`DatatypeSort`	`mkDatatypeSort(Symbol name, Constructor[] constructors)` Create a new datatype sort.
`DatatypeSort[]`	`mkDatatypeSorts(java.lang.String[] names, Constructor[][] c)` Create mutually recursive data-types.
`DatatypeSort[]`	`mkDatatypeSorts(Symbol[] names, Constructor[][] c)` Create mutually recursive datatypes.
`BoolExpr`	`mkDistinct(Expr... args)` Creates a `distinct` term.
`ArithExpr`	`mkDiv(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 / t2`.
`SeqExpr`	`MkEmptySeq(Sort s)` Create the empty sequence.
`ArrayExpr`	`mkEmptySet(Sort domain)` Create an empty set.
`EnumSort`	`mkEnumSort(java.lang.String name, java.lang.String... enumNames)` Create a new enumeration sort.
`EnumSort`	`mkEnumSort(Symbol name, Symbol... enumNames)` Create a new enumeration sort.
`BoolExpr`	`mkEq(Expr x, Expr y)` Creates the equality `x"/> = <paramref name="y`.
`Quantifier`	`mkExists(Expr[] boundConstants, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Creates an existential quantifier using a list of constants that will form the set of bound variables.
`Quantifier`	`mkExists(Sort[] sorts, Symbol[] names, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Creates an existential quantifier using de-Brujin indexed variables.
`BitVecExpr`	`mkExtract(int high, int low, BitVecExpr t)` Bit-vector extraction.
`SeqExpr`	`MkExtract(SeqExpr s, IntExpr offset, IntExpr length)` Extract subsequence.
`BoolExpr`	`mkFalse()` The false Term.
`FiniteDomainSort`	`mkFiniteDomainSort(java.lang.String name, long size)` Create a new finite domain sort.
`FiniteDomainSort`	`mkFiniteDomainSort(Symbol name, long size)` Create a new finite domain sort.
`Fixedpoint`	`mkFixedpoint()` Create a Fixedpoint context.
`Quantifier`	`mkForall(Expr[] boundConstants, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Creates a universal quantifier using a list of constants that will form the set of bound variables.
`Quantifier`	`mkForall(Sort[] sorts, Symbol[] names, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Create a universal Quantifier.
`FPExpr`	`mkFP(BitVecExpr sgn, BitVecExpr sig, BitVecExpr exp)` Create an expression of FloatingPoint sort from three bit-vector expressions.
`FPNum`	`mkFP(boolean sgn, int exp, int sig, FPSort s)` Create a numeral of FloatingPoint sort from a sign bit and two integers.
`FPNum`	`mkFP(boolean sgn, long exp, long sig, FPSort s)` Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers.
`FPNum`	`mkFP(double v, FPSort s)` Create a numeral of FloatingPoint sort from a float.
`FPNum`	`mkFP(float v, FPSort s)` Create a numeral of FloatingPoint sort from a float.
`FPNum`	`mkFP(int v, FPSort s)` Create a numeral of FloatingPoint sort from an int.
`FPExpr`	`mkFPAbs(FPExpr t)` Floating-point absolute value
`FPExpr`	`mkFPAdd(FPRMExpr rm, FPExpr t1, FPExpr t2)` Floating-point addition
`FPExpr`	`mkFPDiv(FPRMExpr rm, FPExpr t1, FPExpr t2)` Floating-point division
`BoolExpr`	`mkFPEq(FPExpr t1, FPExpr t2)` Floating-point equality.
`FPExpr`	`mkFPFMA(FPRMExpr rm, FPExpr t1, FPExpr t2, FPExpr t3)` Floating-point fused multiply-add
`BoolExpr`	`mkFPGEq(FPExpr t1, FPExpr t2)` Floating-point greater than or equal.
`BoolExpr`	`mkFPGt(FPExpr t1, FPExpr t2)` Floating-point greater than.
`FPNum`	`mkFPInf(FPSort s, boolean negative)` Create a floating-point infinity of sort s.
`BoolExpr`	`mkFPIsInfinite(FPExpr t)` Predicate indicating whether t is a floating-point number representing +oo or -oo.
`BoolExpr`	`mkFPIsNaN(FPExpr t)` Predicate indicating whether t is a NaN.
`BoolExpr`	`mkFPIsNegative(FPExpr t)` Predicate indicating whether t is a negative floating-point number.
`BoolExpr`	`mkFPIsNormal(FPExpr t)` Predicate indicating whether t is a normal floating-point number.\
`BoolExpr`	`mkFPIsPositive(FPExpr t)` Predicate indicating whether t is a positive floating-point number.
`BoolExpr`	`mkFPIsSubnormal(FPExpr t)` Predicate indicating whether t is a subnormal floating-point number.\
`BoolExpr`	`mkFPIsZero(FPExpr t)` Predicate indicating whether t is a floating-point number with zero value, i.e., +0 or -0.
`BoolExpr`	`mkFPLEq(FPExpr t1, FPExpr t2)` Floating-point less than or equal.
`BoolExpr`	`mkFPLt(FPExpr t1, FPExpr t2)` Floating-point less than.
`FPExpr`	`mkFPMax(FPExpr t1, FPExpr t2)` Maximum of floating-point numbers.
`FPExpr`	`mkFPMin(FPExpr t1, FPExpr t2)` Minimum of floating-point numbers.
`FPExpr`	`mkFPMul(FPRMExpr rm, FPExpr t1, FPExpr t2)` Floating-point multiplication
`FPNum`	`mkFPNaN(FPSort s)` Create a NaN of sort s.
`FPExpr`	`mkFPNeg(FPExpr t)` Floating-point negation
`FPNum`	`mkFPNumeral(boolean sgn, int exp, int sig, FPSort s)` Create a numeral of FloatingPoint sort from a sign bit and two integers.
`FPNum`	`mkFPNumeral(boolean sgn, long exp, long sig, FPSort s)` Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers.
`FPNum`	`mkFPNumeral(double v, FPSort s)` Create a numeral of FloatingPoint sort from a float.
`FPNum`	`mkFPNumeral(float v, FPSort s)` Create a numeral of FloatingPoint sort from a float.
`FPNum`	`mkFPNumeral(int v, FPSort s)` Create a numeral of FloatingPoint sort from an int.
`FPExpr`	`mkFPRem(FPExpr t1, FPExpr t2)` Floating-point remainder
`FPRMNum`	`mkFPRNA()` Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
`FPRMNum`	`mkFPRNE()` Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
`FPRMSort`	`mkFPRoundingModeSort()` Create the floating-point RoundingMode sort.
`FPRMNum`	`mkFPRoundNearestTiesToAway()` Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
`FPRMExpr`	`mkFPRoundNearestTiesToEven()` Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
`FPExpr`	`mkFPRoundToIntegral(FPRMExpr rm, FPExpr t)` Floating-point roundToIntegral.
`FPRMNum`	`mkFPRoundTowardNegative()` Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode.
`FPRMNum`	`mkFPRoundTowardPositive()` Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode.
`FPRMNum`	`mkFPRoundTowardZero()` Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode.
`FPRMNum`	`mkFPRTN()` Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode.
`FPRMNum`	`mkFPRTP()` Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode.
`FPRMNum`	`mkFPRTZ()` Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode.
`FPSort`	`mkFPSort(int ebits, int sbits)` Create a FloatingPoint sort.
`FPSort`	`mkFPSort128()` Create the quadruple-precision (128-bit) FloatingPoint sort.
`FPSort`	`mkFPSort16()` Create the half-precision (16-bit) FloatingPoint sort.
`FPSort`	`mkFPSort32()` Create the single-precision (32-bit) FloatingPoint sort.
`FPSort`	`mkFPSort64()` Create the double-precision (64-bit) FloatingPoint sort.
`FPSort`	`mkFPSortDouble()` Create the double-precision (64-bit) FloatingPoint sort.
`FPSort`	`mkFPSortHalf()` Create the half-precision (16-bit) FloatingPoint sort.
`FPSort`	`mkFPSortQuadruple()` Create the quadruple-precision (128-bit) FloatingPoint sort.
`FPSort`	`mkFPSortSingle()` Create the single-precision (32-bit) FloatingPoint sort.
`FPExpr`	`mkFPSqrt(FPRMExpr rm, FPExpr t)` Floating-point square root
`FPExpr`	`mkFPSub(FPRMExpr rm, FPExpr t1, FPExpr t2)` Floating-point subtraction
`BitVecExpr`	`mkFPToBV(FPRMExpr rm, FPExpr t, int sz, boolean signed)` Conversion of a floating-point term into a bit-vector.
`FPExpr`	`mkFPToFP(BitVecExpr bv, FPSort s)` Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.
`FPExpr`	`mkFPToFP(FPRMExpr rm, BitVecExpr t, FPSort s, boolean signed)` Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort.
`FPExpr`	`mkFPToFP(FPRMExpr rm, FPExpr t, FPSort s)` Conversion of a FloatingPoint term into another term of different FloatingPoint sort.
`BitVecExpr`	`mkFPToFP(FPRMExpr rm, IntExpr exp, RealExpr sig, FPSort s)` Conversion of a real-sorted significand and an integer-sorted exponent into a term of FloatingPoint sort.
`FPExpr`	`mkFPToFP(FPRMExpr rm, RealExpr t, FPSort s)` Conversion of a term of real sort into a term of FloatingPoint sort.
`FPExpr`	`mkFPToFP(FPSort s, FPRMExpr rm, FPExpr t)` Conversion of a floating-point number to another FloatingPoint sort s.
`BitVecExpr`	`mkFPToIEEEBV(FPExpr t)` Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
`RealExpr`	`mkFPToReal(FPExpr t)` Conversion of a floating-point term into a real-numbered term.
`FPNum`	`mkFPZero(FPSort s, boolean negative)` Create a floating-point zero of sort s.
`Expr`	`mkFreshConst(java.lang.String prefix, Sort range)` Creates a fresh Constant of sort `range` and a name prefixed with `prefix`.
`FuncDecl`	`mkFreshConstDecl(java.lang.String prefix, Sort range)` Creates a fresh constant function declaration with a name prefixed with `prefix"`.
`FuncDecl`	`mkFreshFuncDecl(java.lang.String prefix, Sort[] domain, Sort range)` Creates a fresh function declaration with a name prefixed with `prefix`.
`ArrayExpr`	`mkFullSet(Sort domain)` Create the full set.
`FuncDecl`	`mkFuncDecl(java.lang.String name, Sort[] domain, Sort range)` Creates a new function declaration.
`FuncDecl`	`mkFuncDecl(java.lang.String name, Sort domain, Sort range)` Creates a new function declaration.
`FuncDecl`	`mkFuncDecl(Symbol name, Sort[] domain, Sort range)` Creates a new function declaration.
`FuncDecl`	`mkFuncDecl(Symbol name, Sort domain, Sort range)` Creates a new function declaration.
`BoolExpr`	`mkGe(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 >= t2`
`Goal`	`mkGoal(boolean models, boolean unsatCores, boolean proofs)` Creates a new Goal.
`BoolExpr`	`mkGt(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 > t2`
`BoolExpr`	`mkIff(BoolExpr t1, BoolExpr t2)` Create an expression representing `t1 iff t2`.
`BoolExpr`	`mkImplies(BoolExpr t1, BoolExpr t2)` Create an expression representing `t1 -> t2`.
`IntExpr`	`MkIndexOf(SeqExpr s, SeqExpr substr, ArithExpr offset)` Extract index of sub-string starting at offset.
`BoolExpr`	`MkInRe(SeqExpr s, ReExpr re)` Check for regular expression membership.
`IntNum`	`mkInt(int v)` Create an integer numeral.
`IntNum`	`mkInt(long v)` Create an integer numeral.
`IntNum`	`mkInt(java.lang.String v)` Create an integer numeral.
`BitVecExpr`	`mkInt2BV(int n, IntExpr t)` Create an `n` bit bit-vector from the integer argument `t`.
`RealExpr`	`mkInt2Real(IntExpr t)` Coerce an integer to a real.
`IntExpr`	`mkIntConst(java.lang.String name)` Creates an integer constant.
`IntExpr`	`mkIntConst(Symbol name)` Creates an integer constant.
`IntSort`	`mkIntSort()` Create a new integer sort.
`BoolExpr`	`mkIsInteger(RealExpr t)` Creates an expression that checks whether a real number is an integer.
`Expr`	`mkITE(BoolExpr t1, Expr t2, Expr t3)` Create an expression representing an if-then-else: `ite(t1, t2, t3)`.
`BoolExpr`	`mkLe(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 <= t2`
`IntExpr`	`MkLength(SeqExpr s)` Retrieve the length of a given sequence.
`ListSort`	`mkListSort(java.lang.String name, Sort elemSort)` Create a new list sort.
`ListSort`	`mkListSort(Symbol name, Sort elemSort)` Create a new list sort.
`BoolExpr`	`mkLt(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 < t2`
`ArrayExpr`	`mkMap(FuncDecl f, ArrayExpr... args)` Maps f on the argument arrays.
`IntExpr`	`mkMod(IntExpr t1, IntExpr t2)` Create an expression representing `t1 mod t2`.
`ArithExpr`	`mkMul(ArithExpr... t)` Create an expression representing `t[0] * t[1] * ...`.
`BoolExpr`	`mkNot(BoolExpr a)` Mk an expression representing `not(a)`.
`Expr`	`mkNumeral(int v, Sort ty)` Create a Term of a given sort.
`Expr`	`mkNumeral(long v, Sort ty)` Create a Term of a given sort.
`Expr`	`mkNumeral(java.lang.String v, Sort ty)` Create a Term of a given sort.
`Optimize`	`mkOptimize()` Create a Optimize context.
`BoolExpr`	`mkOr(BoolExpr... t)` Create an expression representing `t[0] or t[1] or ...`.
`Params`	`mkParams()` Creates a new ParameterSet.
`Pattern`	`mkPattern(Expr... terms)` Create a quantifier pattern.
`ArithExpr`	`mkPower(ArithExpr t1, ArithExpr t2)` Create an expression representing `t1 ^ t2`.
`BoolExpr`	`MkPrefixOf(SeqExpr s1, SeqExpr s2)` Check for sequence prefix.
`Probe`	`mkProbe(java.lang.String name)` Creates a new Probe.
`Quantifier`	`mkQuantifier(boolean universal, Expr[] boundConstants, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Create a Quantifier
`Quantifier`	`mkQuantifier(boolean universal, Sort[] sorts, Symbol[] names, Expr body, int weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID)` Create a Quantifier.
`RatNum`	`mkReal(int v)` Create a real numeral.
`RatNum`	`mkReal(int num, int den)` Create a real from a fraction.
`RatNum`	`mkReal(long v)` Create a real numeral.
`RatNum`	`mkReal(java.lang.String v)` Create a real numeral.
`IntExpr`	`mkReal2Int(RealExpr t)` Coerce a real to an integer.
`RealExpr`	`mkRealConst(java.lang.String name)` Creates a real constant.
`RealExpr`	`mkRealConst(Symbol name)` Creates a real constant.
`RealSort`	`mkRealSort()` Create a real sort.
`IntExpr`	`mkRem(IntExpr t1, IntExpr t2)` Create an expression representing `t1 rem t2`.
`BitVecExpr`	`mkRepeat(int i, BitVecExpr t)` Bit-vector repetition.
`SeqExpr`	`MkReplace(SeqExpr s, SeqExpr src, SeqExpr dst)` Replace the first occurrence of src by dst in s.
`ReSort`	`mkReSort(Sort s)` Create a new regular expression sort
`Expr`	`mkSelect(ArrayExpr a, Expr i)` Array read.
`SeqSort`	`mkSeqSort(Sort s)` Create a new sequence sort
`ArrayExpr`	`mkSetAdd(ArrayExpr set, Expr element)` Add an element to the set.
`ArrayExpr`	`mkSetComplement(ArrayExpr arg)` Take the complement of a set.
`ArrayExpr`	`mkSetDel(ArrayExpr set, Expr element)` Remove an element from a set.
`ArrayExpr`	`mkSetDifference(ArrayExpr arg1, ArrayExpr arg2)` Take the difference between two sets.
`ArrayExpr`	`mkSetIntersection(ArrayExpr... args)` Take the intersection of a list of sets.
`BoolExpr`	`mkSetMembership(Expr elem, ArrayExpr set)` Check for set membership.
`SetSort`	`mkSetSort(Sort ty)` Create a set type.
`BoolExpr`	`mkSetSubset(ArrayExpr arg1, ArrayExpr arg2)` Check for subsetness of sets.
`ArrayExpr`	`mkSetUnion(ArrayExpr... args)` Take the union of a list of sets.
`BitVecExpr`	`mkSignExt(int i, BitVecExpr t)` Bit-vector sign extension.
`Solver`	`mkSimpleSolver()` Creates a new (incremental) solver.
`Solver`	`mkSolver()` Creates a new (incremental) solver.
`Solver`	`mkSolver(java.lang.String logic)` Creates a new (incremental) solver.
`Solver`	`mkSolver(Symbol logic)` Creates a new (incremental) solver.
`Solver`	`mkSolver(Tactic t)` Creates a solver that is implemented using the given tactic.
`ReExpr`	`MkStar(ReExpr re)` Take the Kleene star of a regular expression.
`ArrayExpr`	`mkStore(ArrayExpr a, Expr i, Expr v)` Array update.
`SeqExpr`	`MkString(java.lang.String s)` Create a string constant.
`SeqSort`	`mkStringSort()` Create a new string sort
`ArithExpr`	`mkSub(ArithExpr... t)` Create an expression representing `t[0] - t[1] - ...`.
`BoolExpr`	`MkSuffixOf(SeqExpr s1, SeqExpr s2)` Check for sequence suffix.
`IntSymbol`	`mkSymbol(int i)` Creates a new symbol using an integer.
`StringSymbol`	`mkSymbol(java.lang.String name)` Create a symbol using a string.
`Tactic`	`mkTactic(java.lang.String name)` Creates a new Tactic.
`Expr`	`mkTermArray(ArrayExpr array)` Access the array default value.
`ReExpr`	`MkToRe(SeqExpr s)` Convert a regular expression that accepts sequence s.
`BoolExpr`	`mkTrue()` The true Term.
`TupleSort`	`mkTupleSort(Symbol name, Symbol[] fieldNames, Sort[] fieldSorts)` Create a new tuple sort.
`ArithExpr`	`mkUnaryMinus(ArithExpr t)` Create an expression representing `-t`.
`UninterpretedSort`	`mkUninterpretedSort(java.lang.String str)` Create a new uninterpreted sort.
`UninterpretedSort`	`mkUninterpretedSort(Symbol s)` Create a new uninterpreted sort.
`ReExpr`	`MkUnion(ReExpr... t)` Create the union of regular languages.
`SeqExpr`	`MkUnit(Expr elem)` Create the singleton sequence.
`Expr`	`MkUpdateField(FuncDecl field, Expr t, Expr v)` Update a datatype field at expression t with value v.
`BoolExpr`	`mkXor(BoolExpr t1, BoolExpr t2)` Create an expression representing `t1 xor t2`.
`BitVecExpr`	`mkZeroExt(int i, BitVecExpr t)` Bit-vector zero extension.
`ReExpr`	`MOption(ReExpr re)` Create the optional regular expression.
`ReExpr`	`MPlus(ReExpr re)` Take the Kleene plus of a regular expression.
`Probe`	`not(Probe p)` Create a probe that evaluates to "true" when the value `p` does not evaluate to "true".
`Probe`	`or(Probe p1, Probe p2)` Create a probe that evaluates to "true" when the value `p1` or `p2` evaluate to "true".
`Tactic`	`orElse(Tactic t1, Tactic t2)` Create a tactic that first applies `t1` to a Goal and if it fails then returns the result of `t2` applied to the Goal.
`Tactic`	`parAndThen(Tactic t1, Tactic t2)` Create a tactic that applies `t1` to a given goal and then `t2` to every subgoal produced by `t1`.
`Tactic`	`parOr(Tactic... t)` Create a tactic that applies the given tactics in parallel until one of them succeeds (i.e., the first that doesn't fail).
`BoolExpr`	`parseSMTLIB2File(java.lang.String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls)` Parse the given file using the SMT-LIB2 parser.
`BoolExpr`	`parseSMTLIB2String(java.lang.String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls)` Parse the given string using the SMT-LIB2 parser.
`void`	`parseSMTLIBFile(java.lang.String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls)` Parse the given file using the SMT-LIB parser.
`void`	`parseSMTLIBString(java.lang.String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls)` Parse the given string using the SMT-LIB parser.
`Tactic`	`repeat(Tactic t, int max)` Create a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
`void`	`setPrintMode(Z3_ast_print_mode value)` Selects the format used for pretty-printing expressions.
`java.lang.String`	`SimplifyHelp()` Return a string describing all available parameters to `Expr.Simplify`.
`Tactic`	`skip()` Create a tactic that just returns the given goal.
`Tactic`	`then(Tactic t1, Tactic t2, Tactic... ts)` Create a tactic that applies `t1` to a Goal and then `t2` to every subgoal produced by `t1` Remarks: Shorthand for `AndThen`.
`Tactic`	`tryFor(Tactic t, int ms)` Create a tactic that applies `t` to a goal for `ms` milliseconds.
`long`	`unwrapAST(AST a)` Unwraps an AST.
`void`	`updateParamValue(java.lang.String id, java.lang.String value)` Update a mutable configuration parameter.
`Tactic`	`usingParams(Tactic t, Params p)` Create a tactic that applies `t` using the given set of parameters `p`.
`Tactic`	`when(Probe p, Tactic t)` Create a tactic that applies `t` to a given goal if the probe `p` evaluates to true.
`Tactic`	`with(Tactic t, Params p)` Create a tactic that applies `t` using the given set of parameters `p`.
`AST`	`wrapAST(long nativeObject)` Wraps an AST.

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - m_ctx
```
protected long m_ctx
```
  - creation_lock
```
protected static final java.lang.Object creation_lock
```
  - m_refCount
```
protected java.util.concurrent.atomic.AtomicInteger m_refCount
```
- Constructor Detail
  - Context
```
public Context()
```
    Constructor.
  - Context
```
public Context(java.util.Map<java.lang.String,java.lang.String> settings)
```
    Constructor. Remarks: 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
- Method Detail
  - mkSymbol
```
public IntSymbol mkSymbol(int i)
```
    Creates a new symbol using an integer. Remarks: Not all integers can be passed to this function. The legal range of unsigned integers is 0 to 2^30-1.
  - mkSymbol
```
public StringSymbol mkSymbol(java.lang.String name)
```
    Create a symbol using a string.
  - getBoolSort
```
public BoolSort getBoolSort()
```
    Retrieves the Boolean sort of the context.
  - getIntSort
```
public IntSort getIntSort()
```
    Retrieves the Integer sort of the context.
  - getRealSort
```
public RealSort getRealSort()
```
    Retrieves the Real sort of the context.
  - mkBoolSort
```
public BoolSort mkBoolSort()
```
    Create a new Boolean sort.
  - getStringSort
```
public SeqSort getStringSort()
```
    Retrieves the Integer sort of the context.
  - mkUninterpretedSort
```
public UninterpretedSort mkUninterpretedSort(Symbol s)
```
    Create a new uninterpreted sort.
  - mkUninterpretedSort
```
public UninterpretedSort mkUninterpretedSort(java.lang.String str)
```
    Create a new uninterpreted sort.
  - mkIntSort
```
public IntSort mkIntSort()
```
    Create a new integer sort.
  - mkRealSort
```
public RealSort mkRealSort()
```
    Create a real sort.
  - mkBitVecSort
```
public BitVecSort mkBitVecSort(int size)
```
    Create a new bit-vector sort.
  - mkArraySort
```
public ArraySort mkArraySort(Sort domain,
                    Sort range)
```
    Create a new array sort.
  - mkStringSort
```
public SeqSort mkStringSort()
```
    Create a new string sort
  - mkSeqSort
```
public SeqSort mkSeqSort(Sort s)
```
    Create a new sequence sort
  - mkReSort
```
public ReSort mkReSort(Sort s)
```
    Create a new regular expression sort
  - mkTupleSort
```
public TupleSort mkTupleSort(Symbol name,
                    Symbol[] fieldNames,
                    Sort[] fieldSorts)
```
    Create a new tuple sort.
  - mkEnumSort
```
public EnumSort mkEnumSort(Symbol name,
                  Symbol... enumNames)
```
    Create a new enumeration sort.
  - mkEnumSort
```
public EnumSort mkEnumSort(java.lang.String name,
                  java.lang.String... enumNames)
```
    Create a new enumeration sort.
  - mkListSort
```
public ListSort mkListSort(Symbol name,
                  Sort elemSort)
```
    Create a new list sort.
  - mkListSort
```
public ListSort mkListSort(java.lang.String name,
                  Sort elemSort)
```
    Create a new list sort.
  - mkFiniteDomainSort
```
public FiniteDomainSort mkFiniteDomainSort(Symbol name,
                                  long size)
```
    Create a new finite domain sort.
  - mkFiniteDomainSort
```
public FiniteDomainSort mkFiniteDomainSort(java.lang.String name,
                                  long size)
```
    Create a new finite domain sort.
  - mkConstructor
```
public Constructor mkConstructor(Symbol name,
                        Symbol recognizer,
                        Symbol[] fieldNames,
                        Sort[] sorts,
                        int[] sortRefs)
```
    Create a datatype constructor.
    
    Parameters:
    name - constructor name
    recognizer - name of recognizer function.
    fieldNames - names of the constructor fields.
    sorts - field sorts, 0 if the field sort refers to a recursive sort.
    sortRefs - 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.
  - mkConstructor
```
public Constructor mkConstructor(java.lang.String name,
                        java.lang.String recognizer,
                        java.lang.String[] fieldNames,
                        Sort[] sorts,
                        int[] sortRefs)
```
    Create a datatype constructor.
  - mkDatatypeSort
```
public DatatypeSort mkDatatypeSort(Symbol name,
                          Constructor[] constructors)
```
    Create a new datatype sort.
  - mkDatatypeSort
```
public DatatypeSort mkDatatypeSort(java.lang.String name,
                          Constructor[] constructors)
```
    Create a new datatype sort.
  - mkDatatypeSorts
```
public DatatypeSort[] mkDatatypeSorts(Symbol[] names,
                             Constructor[][] c)
```
    Create mutually recursive datatypes.
    
    Parameters:
    names - names of datatype sorts
    c - list of constructors, one list per sort.
  - mkDatatypeSorts
```
public DatatypeSort[] mkDatatypeSorts(java.lang.String[] names,
                             Constructor[][] c)
```
    Create mutually recursive data-types.
  - MkUpdateField
```
public Expr MkUpdateField(FuncDecl field,
                 Expr t,
                 Expr v)
                   throws Z3Exception
```
    Update a datatype field at expression t with value v. The function performs a record update at t. The field that is passed in as argument is updated with value v, the remaining fields of t are unchanged.
    
    Throws:
    
    Z3Exception
  - mkFuncDecl
```
public FuncDecl mkFuncDecl(Symbol name,
                  Sort[] domain,
                  Sort range)
```
    Creates a new function declaration.
  - mkFuncDecl
```
public FuncDecl mkFuncDecl(Symbol name,
                  Sort domain,
                  Sort range)
```
    Creates a new function declaration.
  - mkFuncDecl
```
public FuncDecl mkFuncDecl(java.lang.String name,
                  Sort[] domain,
                  Sort range)
```
    Creates a new function declaration.
  - mkFuncDecl
```
public FuncDecl mkFuncDecl(java.lang.String name,
                  Sort domain,
                  Sort range)
```
    Creates a new function declaration.
  - mkFreshFuncDecl
```
public FuncDecl mkFreshFuncDecl(java.lang.String prefix,
                       Sort[] domain,
                       Sort range)
```
    Creates a fresh function declaration with a name prefixed with prefix.
    
    See Also:
    mkFuncDecl(String,Sort,Sort), mkFuncDecl(String,Sort[],Sort)
  - mkConstDecl
```
public FuncDecl mkConstDecl(Symbol name,
                   Sort range)
```
    Creates a new constant function declaration.
  - mkConstDecl
```
public FuncDecl mkConstDecl(java.lang.String name,
                   Sort range)
```
    Creates a new constant function declaration.
  - mkFreshConstDecl
```
public FuncDecl mkFreshConstDecl(java.lang.String prefix,
                        Sort range)
```
    Creates a fresh constant function declaration with a name prefixed with prefix".
    
    See Also:
    mkFuncDecl(String,Sort,Sort), mkFuncDecl(String,Sort[],Sort)
  - mkBound
```
public Expr mkBound(int index,
           Sort ty)
```
    Creates a new bound variable.
    
    Parameters:
    index - The de-Bruijn index of the variable
    ty - The sort of the variable
  - mkPattern
```
public Pattern mkPattern(Expr... terms)
```
    Create a quantifier pattern.
  - mkConst
```
public Expr mkConst(Symbol name,
           Sort range)
```
    Creates a new Constant of sort range and named name.
  - mkConst
```
public Expr mkConst(java.lang.String name,
           Sort range)
```
    Creates a new Constant of sort range and named name.
  - mkFreshConst
```
public Expr mkFreshConst(java.lang.String prefix,
                Sort range)
```
    Creates a fresh Constant of sort range and a name prefixed with prefix.
  - mkConst
```
public Expr mkConst(FuncDecl f)
```
    Creates a fresh constant from the FuncDecl f.
    
    Parameters:
    f - A decl of a 0-arity function
  - mkBoolConst
```
public BoolExpr mkBoolConst(Symbol name)
```
    Create a Boolean constant.
  - mkBoolConst
```
public BoolExpr mkBoolConst(java.lang.String name)
```
    Create a Boolean constant.
  - mkIntConst
```
public IntExpr mkIntConst(Symbol name)
```
    Creates an integer constant.
  - mkIntConst
```
public IntExpr mkIntConst(java.lang.String name)
```
    Creates an integer constant.
  - mkRealConst
```
public RealExpr mkRealConst(Symbol name)
```
    Creates a real constant.
  - mkRealConst
```
public RealExpr mkRealConst(java.lang.String name)
```
    Creates a real constant.
  - mkBVConst
```
public BitVecExpr mkBVConst(Symbol name,
                   int size)
```
    Creates a bit-vector constant.
  - mkBVConst
```
public BitVecExpr mkBVConst(java.lang.String name,
                   int size)
```
    Creates a bit-vector constant.
  - mkApp
```
public Expr mkApp(FuncDecl f,
         Expr... args)
```
    Create a new function application.
  - mkTrue
```
public BoolExpr mkTrue()
```
    The true Term.
  - mkFalse
```
public BoolExpr mkFalse()
```
    The false Term.
  - mkBool
```
public BoolExpr mkBool(boolean value)
```
    Creates a Boolean value.
  - mkEq
```
public BoolExpr mkEq(Expr x,
            Expr y)
```
    Creates the equality x"/> = <paramref name="y.
  - mkDistinct
```
public BoolExpr mkDistinct(Expr... args)
```
    Creates a distinct term.
  - mkNot
```
public BoolExpr mkNot(BoolExpr a)
```
    Mk an expression representing not(a).
  - mkITE
```
public Expr mkITE(BoolExpr t1,
         Expr t2,
         Expr t3)
```
    Create an expression representing an if-then-else: ite(t1, t2, t3).
    
    Parameters:
    t1 - An expression with Boolean sort
    t2 - An expression
    t3 - An expression with the same sort as t2
  - mkIff
```
public BoolExpr mkIff(BoolExpr t1,
             BoolExpr t2)
```
    Create an expression representing t1 iff t2.
  - mkImplies
```
public BoolExpr mkImplies(BoolExpr t1,
                 BoolExpr t2)
```
    Create an expression representing t1 -> t2.
  - mkXor
```
public BoolExpr mkXor(BoolExpr t1,
             BoolExpr t2)
```
    Create an expression representing t1 xor t2.
  - mkAnd
```
public BoolExpr mkAnd(BoolExpr... t)
```
    Create an expression representing t[0] and t[1] and ....
  - mkOr
```
public BoolExpr mkOr(BoolExpr... t)
```
    Create an expression representing t[0] or t[1] or ....
  - mkAdd
```
public ArithExpr mkAdd(ArithExpr... t)
```
    Create an expression representing t[0] + t[1] + ....
  - mkMul
```
public ArithExpr mkMul(ArithExpr... t)
```
    Create an expression representing t[0] * t[1] * ....
  - mkSub
```
public ArithExpr mkSub(ArithExpr... t)
```
    Create an expression representing t[0] - t[1] - ....
  - mkUnaryMinus
```
public ArithExpr mkUnaryMinus(ArithExpr t)
```
    Create an expression representing -t.
  - mkDiv
```
public ArithExpr mkDiv(ArithExpr t1,
              ArithExpr t2)
```
    Create an expression representing t1 / t2.
  - mkMod
```
public IntExpr mkMod(IntExpr t1,
            IntExpr t2)
```
    Create an expression representing t1 mod t2. Remarks: The arguments must have int type.
  - mkRem
```
public IntExpr mkRem(IntExpr t1,
            IntExpr t2)
```
    Create an expression representing t1 rem t2. Remarks: The arguments must have int type.
  - mkPower
```
public ArithExpr mkPower(ArithExpr t1,
                ArithExpr t2)
```
    Create an expression representing t1 ^ t2.
  - mkLt
```
public BoolExpr mkLt(ArithExpr t1,
            ArithExpr t2)
```
    Create an expression representing t1 < t2
  - mkLe
```
public BoolExpr mkLe(ArithExpr t1,
            ArithExpr t2)
```
    Create an expression representing t1 <= t2
  - mkGt
```
public BoolExpr mkGt(ArithExpr t1,
            ArithExpr t2)
```
    Create an expression representing t1 > t2
  - mkGe
```
public BoolExpr mkGe(ArithExpr t1,
            ArithExpr t2)
```
    Create an expression representing t1 >= t2
  - mkInt2Real
```
public RealExpr mkInt2Real(IntExpr t)
```
    Coerce an integer to a real. Remarks: 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.
  - mkReal2Int
```
public IntExpr mkReal2Int(RealExpr t)
```
    Coerce a real to an integer. Remarks: The semantics of this function follows the SMT-LIB standard for the function to_int. The argument must be of real sort.
  - mkIsInteger
```
public BoolExpr mkIsInteger(RealExpr t)
```
    Creates an expression that checks whether a real number is an integer.
  - mkBVNot
```
public BitVecExpr mkBVNot(BitVecExpr t)
```
    Bitwise negation. Remarks: The argument must have a bit-vector sort.
  - mkBVRedAND
```
public BitVecExpr mkBVRedAND(BitVecExpr t)
```
    Take conjunction of bits in a vector, return vector of length 1. Remarks: The argument must have a bit-vector sort.
  - mkBVRedOR
```
public BitVecExpr mkBVRedOR(BitVecExpr t)
```
    Take disjunction of bits in a vector, return vector of length 1. Remarks: The argument must have a bit-vector sort.
  - mkBVAND
```
public BitVecExpr mkBVAND(BitVecExpr t1,
                 BitVecExpr t2)
```
    Bitwise conjunction. Remarks: The arguments must have a bit-vector sort.
  - mkBVOR
```
public BitVecExpr mkBVOR(BitVecExpr t1,
                BitVecExpr t2)
```
    Bitwise disjunction. Remarks: The arguments must have a bit-vector sort.
  - mkBVXOR
```
public BitVecExpr mkBVXOR(BitVecExpr t1,
                 BitVecExpr t2)
```
    Bitwise XOR. Remarks: The arguments must have a bit-vector sort.
  - mkBVNAND
```
public BitVecExpr mkBVNAND(BitVecExpr t1,
                  BitVecExpr t2)
```
    Bitwise NAND. Remarks: The arguments must have a bit-vector sort.
  - mkBVNOR
```
public BitVecExpr mkBVNOR(BitVecExpr t1,
                 BitVecExpr t2)
```
    Bitwise NOR. Remarks: The arguments must have a bit-vector sort.
  - mkBVXNOR
```
public BitVecExpr mkBVXNOR(BitVecExpr t1,
                  BitVecExpr t2)
```
    Bitwise XNOR. Remarks: The arguments must have a bit-vector sort.
  - mkBVNeg
```
public BitVecExpr mkBVNeg(BitVecExpr t)
```
    Standard two's complement unary minus. Remarks: The arguments must have a bit-vector sort.
  - mkBVAdd
```
public BitVecExpr mkBVAdd(BitVecExpr t1,
                 BitVecExpr t2)
```
    Two's complement addition. Remarks: The arguments must have the same bit-vector sort.
  - mkBVSub
```
public BitVecExpr mkBVSub(BitVecExpr t1,
                 BitVecExpr t2)
```
    Two's complement subtraction. Remarks: The arguments must have the same bit-vector sort.
  - mkBVMul
```
public BitVecExpr mkBVMul(BitVecExpr t1,
                 BitVecExpr t2)
```
    Two's complement multiplication. Remarks: The arguments must have the same bit-vector sort.
  - mkBVUDiv
```
public BitVecExpr mkBVUDiv(BitVecExpr t1,
                  BitVecExpr t2)
```
    Unsigned division. Remarks: 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.
  - mkBVSDiv
```
public BitVecExpr mkBVSDiv(BitVecExpr t1,
                  BitVecExpr t2)
```
    Signed division. Remarks: 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.
  - mkBVURem
```
public BitVecExpr mkBVURem(BitVecExpr t1,
                  BitVecExpr t2)
```
    Unsigned remainder. Remarks: 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.
  - mkBVSRem
```
public BitVecExpr mkBVSRem(BitVecExpr t1,
                  BitVecExpr t2)
```
    Signed remainder. Remarks: 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.
  - mkBVSMod
```
public BitVecExpr mkBVSMod(BitVecExpr t1,
                  BitVecExpr t2)
```
    Two's complement signed remainder (sign follows divisor). Remarks: If t2 is zero, then the result is undefined. The arguments must have the same bit-vector sort.
  - mkBVULT
```
public BoolExpr mkBVULT(BitVecExpr t1,
               BitVecExpr t2)
```
    Unsigned less-than Remarks: The arguments must have the same bit-vector sort.
  - mkBVSLT
```
public BoolExpr mkBVSLT(BitVecExpr t1,
               BitVecExpr t2)
```
    Two's complement signed less-than Remarks: The arguments must have the same bit-vector sort.
  - mkBVULE
```
public BoolExpr mkBVULE(BitVecExpr t1,
               BitVecExpr t2)
```
    Unsigned less-than or equal to. Remarks: The arguments must have the same bit-vector sort.
  - mkBVSLE
```
public BoolExpr mkBVSLE(BitVecExpr t1,
               BitVecExpr t2)
```
    Two's complement signed less-than or equal to. Remarks: The arguments must have the same bit-vector sort.
  - mkBVUGE
```
public BoolExpr mkBVUGE(BitVecExpr t1,
               BitVecExpr t2)
```
    Unsigned greater than or equal to. Remarks: The arguments must have the same bit-vector sort.
  - mkBVSGE
```
public BoolExpr mkBVSGE(BitVecExpr t1,
               BitVecExpr t2)
```
    Two's complement signed greater than or equal to. Remarks: The arguments must have the same bit-vector sort.
  - mkBVUGT
```
public BoolExpr mkBVUGT(BitVecExpr t1,
               BitVecExpr t2)
```
    Unsigned greater-than. Remarks: The arguments must have the same bit-vector sort.
  - mkBVSGT
```
public BoolExpr mkBVSGT(BitVecExpr t1,
               BitVecExpr t2)
```
    Two's complement signed greater-than. Remarks: The arguments must have the same bit-vector sort.
  - mkConcat
```
public BitVecExpr mkConcat(BitVecExpr t1,
                  BitVecExpr t2)
```
    Bit-vector concatenation. Remarks: The arguments must have a bit-vector sort.
    
    Returns:
    The result is a bit-vector of size n1+n2, where n1 (n2) is the size of t1 (t2).
  - mkExtract
```
public BitVecExpr mkExtract(int high,
                   int low,
                   BitVecExpr t)
```
    Bit-vector extraction. Remarks: 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.
  - mkSignExt
```
public BitVecExpr mkSignExt(int i,
                   BitVecExpr t)
```
    Bit-vector sign extension. Remarks: 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.
  - mkZeroExt
```
public BitVecExpr mkZeroExt(int i,
                   BitVecExpr t)
```
    Bit-vector zero extension. Remarks: 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.
  - mkRepeat
```
public BitVecExpr mkRepeat(int i,
                  BitVecExpr t)
```
    Bit-vector repetition. Remarks: The argument t must have a bit-vector sort.
  - mkBVSHL
```
public BitVecExpr mkBVSHL(BitVecExpr t1,
                 BitVecExpr t2)
```
    Shift left. Remarks: 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.
  - mkBVLSHR
```
public BitVecExpr mkBVLSHR(BitVecExpr t1,
                  BitVecExpr t2)
```
    Logical shift right Remarks: 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.
  - mkBVASHR
```
public BitVecExpr mkBVASHR(BitVecExpr t1,
                  BitVecExpr t2)
```
    Arithmetic shift right Remarks: 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.
  - mkBVRotateLeft
```
public BitVecExpr mkBVRotateLeft(int i,
                        BitVecExpr t)
```
    Rotate Left. Remarks: Rotate bits of \c t to the left \c i times. The argument t must have a bit-vector sort.
  - mkBVRotateRight
```
public BitVecExpr mkBVRotateRight(int i,
                         BitVecExpr t)
```
    Rotate Right. Remarks: Rotate bits of \c t to the right \c i times. The argument t must have a bit-vector sort.
  - mkBVRotateLeft
```
public BitVecExpr mkBVRotateLeft(BitVecExpr t1,
                        BitVecExpr t2)
```
    Rotate Left. Remarks: Rotate bits of t1 to the left t2 times. The arguments must have the same bit-vector sort.
  - mkBVRotateRight
```
public BitVecExpr mkBVRotateRight(BitVecExpr t1,
                         BitVecExpr t2)
```
    Rotate Right. Remarks: Rotate bits of t1 to the rightt2 times. The arguments must have the same bit-vector sort.
  - mkInt2BV
```
public BitVecExpr mkInt2BV(int n,
                  IntExpr t)
```
    Create an n bit bit-vector from the integer argument t. Remarks: 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.
  - mkBV2Int
```
public IntExpr mkBV2Int(BitVecExpr t,
               boolean signed)
```
    Create an integer from the bit-vector argument t. Remarks: 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.
  - mkBVAddNoOverflow
```
public BoolExpr mkBVAddNoOverflow(BitVecExpr t1,
                         BitVecExpr t2,
                         boolean isSigned)
```
    Create a predicate that checks that the bit-wise addition does not overflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVAddNoUnderflow
```
public BoolExpr mkBVAddNoUnderflow(BitVecExpr t1,
                          BitVecExpr t2)
```
    Create a predicate that checks that the bit-wise addition does not underflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVSubNoOverflow
```
public BoolExpr mkBVSubNoOverflow(BitVecExpr t1,
                         BitVecExpr t2)
```
    Create a predicate that checks that the bit-wise subtraction does not overflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVSubNoUnderflow
```
public BoolExpr mkBVSubNoUnderflow(BitVecExpr t1,
                          BitVecExpr t2,
                          boolean isSigned)
```
    Create a predicate that checks that the bit-wise subtraction does not underflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVSDivNoOverflow
```
public BoolExpr mkBVSDivNoOverflow(BitVecExpr t1,
                          BitVecExpr t2)
```
    Create a predicate that checks that the bit-wise signed division does not overflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVNegNoOverflow
```
public BoolExpr mkBVNegNoOverflow(BitVecExpr t)
```
    Create a predicate that checks that the bit-wise negation does not overflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVMulNoOverflow
```
public BoolExpr mkBVMulNoOverflow(BitVecExpr t1,
                         BitVecExpr t2,
                         boolean isSigned)
```
    Create a predicate that checks that the bit-wise multiplication does not overflow. Remarks: The arguments must be of bit-vector sort.
  - mkBVMulNoUnderflow
```
public BoolExpr mkBVMulNoUnderflow(BitVecExpr t1,
                          BitVecExpr t2)
```
    Create a predicate that checks that the bit-wise multiplication does not underflow. Remarks: The arguments must be of bit-vector sort.
  - mkArrayConst
```
public ArrayExpr mkArrayConst(Symbol name,
                     Sort domain,
                     Sort range)
```
    Create an array constant.
  - mkArrayConst
```
public ArrayExpr mkArrayConst(java.lang.String name,
                     Sort domain,
                     Sort range)
```
    Create an array constant.
  - mkSelect
```
public Expr mkSelect(ArrayExpr a,
            Expr i)
```
    Array read. Remarks: 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.
    
    See Also:
    mkArraySort(com.microsoft.z3.Sort, com.microsoft.z3.Sort), mkStore(com.microsoft.z3.ArrayExpr, com.microsoft.z3.Expr, com.microsoft.z3.Expr)
  - mkStore
```
public ArrayExpr mkStore(ArrayExpr a,
                Expr i,
                Expr v)
```
    Array update. Remarks: 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).
    
    See Also:
    mkArraySort(com.microsoft.z3.Sort, com.microsoft.z3.Sort), mkSelect(com.microsoft.z3.ArrayExpr, com.microsoft.z3.Expr)
  - mkConstArray
```
public ArrayExpr mkConstArray(Sort domain,
                     Expr v)
```
    Create a constant array. Remarks: The resulting term is an array, such that a select on an arbitrary index produces the value v.
    
    See Also:
    mkArraySort(com.microsoft.z3.Sort, com.microsoft.z3.Sort), mkSelect(com.microsoft.z3.ArrayExpr, com.microsoft.z3.Expr)
  - mkMap
```
public ArrayExpr mkMap(FuncDecl f,
              ArrayExpr... args)
```
    Maps f on the argument arrays. Remarks: Each 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].
    
    See Also:
    mkArraySort(com.microsoft.z3.Sort, com.microsoft.z3.Sort), mkSelect(com.microsoft.z3.ArrayExpr, com.microsoft.z3.Expr), mkStore(com.microsoft.z3.ArrayExpr, com.microsoft.z3.Expr, com.microsoft.z3.Expr)
  - mkTermArray
```
public Expr mkTermArray(ArrayExpr array)
```
    Access the array default value. Remarks: Produces the default range value, for arrays that can be represented as finite maps with a default range value.
  - mkArrayExt
```
public Expr mkArrayExt(ArrayExpr arg1,
              ArrayExpr arg2)
```
    Create Extentionality index. Two arrays are equal if and only if they are equal on the index returned by MkArrayExt.
  - mkSetSort
```
public SetSort mkSetSort(Sort ty)
```
    Create a set type.
  - mkEmptySet
```
public ArrayExpr mkEmptySet(Sort domain)
```
    Create an empty set.
  - mkFullSet
```
public ArrayExpr mkFullSet(Sort domain)
```
    Create the full set.
  - mkSetAdd
```
public ArrayExpr mkSetAdd(ArrayExpr set,
                 Expr element)
```
    Add an element to the set.
  - mkSetDel
```
public ArrayExpr mkSetDel(ArrayExpr set,
                 Expr element)
```
    Remove an element from a set.
  - mkSetUnion
```
public ArrayExpr mkSetUnion(ArrayExpr... args)
```
    Take the union of a list of sets.
  - mkSetIntersection
```
public ArrayExpr mkSetIntersection(ArrayExpr... args)
```
    Take the intersection of a list of sets.
  - mkSetDifference
```
public ArrayExpr mkSetDifference(ArrayExpr arg1,
                        ArrayExpr arg2)
```
    Take the difference between two sets.
  - mkSetComplement
```
public ArrayExpr mkSetComplement(ArrayExpr arg)
```
    Take the complement of a set.
  - mkSetMembership
```
public BoolExpr mkSetMembership(Expr elem,
                       ArrayExpr set)
```
    Check for set membership.
  - mkSetSubset
```
public BoolExpr mkSetSubset(ArrayExpr arg1,
                   ArrayExpr arg2)
```
    Check for subsetness of sets.
  - MkEmptySeq
```
public SeqExpr MkEmptySeq(Sort s)
```
    Create the empty sequence.
  - MkUnit
```
public SeqExpr MkUnit(Expr elem)
```
    Create the singleton sequence.
  - MkString
```
public SeqExpr MkString(java.lang.String s)
```
    Create a string constant.
  - MkConcat
```
public SeqExpr MkConcat(SeqExpr... t)
```
    Concatentate sequences.
  - MkLength
```
public IntExpr MkLength(SeqExpr s)
```
    Retrieve the length of a given sequence.
  - MkPrefixOf
```
public BoolExpr MkPrefixOf(SeqExpr s1,
                  SeqExpr s2)
```
    Check for sequence prefix.
  - MkSuffixOf
```
public BoolExpr MkSuffixOf(SeqExpr s1,
                  SeqExpr s2)
```
    Check for sequence suffix.
  - MkContains
```
public BoolExpr MkContains(SeqExpr s1,
                  SeqExpr s2)
```
    Check for sequence containment of s2 in s1.
  - MkAt
```
public SeqExpr MkAt(SeqExpr s,
           IntExpr index)
```
    Retrieve sequence of length one at index.
  - MkExtract
```
public SeqExpr MkExtract(SeqExpr s,
                IntExpr offset,
                IntExpr length)
```
    Extract subsequence.
  - MkIndexOf
```
public IntExpr MkIndexOf(SeqExpr s,
                SeqExpr substr,
                ArithExpr offset)
```
    Extract index of sub-string starting at offset.
  - MkReplace
```
public SeqExpr MkReplace(SeqExpr s,
                SeqExpr src,
                SeqExpr dst)
```
    Replace the first occurrence of src by dst in s.
  - MkToRe
```
public ReExpr MkToRe(SeqExpr s)
```
    Convert a regular expression that accepts sequence s.
  - MkInRe
```
public BoolExpr MkInRe(SeqExpr s,
              ReExpr re)
```
    Check for regular expression membership.
  - MkStar
```
public ReExpr MkStar(ReExpr re)
```
    Take the Kleene star of a regular expression.
  - MPlus
```
public ReExpr MPlus(ReExpr re)
```
    Take the Kleene plus of a regular expression.
  - MOption
```
public ReExpr MOption(ReExpr re)
```
    Create the optional regular expression.
  - MkConcat
```
public ReExpr MkConcat(ReExpr... t)
```
    Create the concatenation of regular languages.
  - MkUnion
```
public ReExpr MkUnion(ReExpr... t)
```
    Create the union of regular languages.
  - mkNumeral
```
public Expr mkNumeral(java.lang.String v,
             Sort ty)
```
    Create a Term of a given sort.
    
    Parameters:
    v - 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 - The sort of the numeral. In the current implementation, the given sort can be an int, real, or bit-vectors of arbitrary size.
    
    Returns:
    A Term with value v and sort ty
  - mkNumeral
```
public Expr mkNumeral(int v,
             Sort ty)
```
    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.
    
    Parameters:
    v - Value of the numeral
    ty - Sort of the numeral
    
    Returns:
    A Term with value v and type ty
  - mkNumeral
```
public Expr mkNumeral(long v,
             Sort ty)
```
    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.
    
    Parameters:
    v - Value of the numeral
    ty - Sort of the numeral
    
    Returns:
    A Term with value v and type ty
  - mkReal
```
public RatNum mkReal(int num,
            int den)
```
    Create a real from a fraction.
    
    Parameters:
    num - numerator of rational.
    den - denominator of rational.
    
    Returns:
    A Term with value num/den and sort Real
    See Also:
    mkNumeral(String,Sort)
  - mkReal
```
public RatNum mkReal(java.lang.String v)
```
    Create a real numeral.
    
    Parameters:
    v - A string representing the Term value in decimal notation.
    
    Returns:
    A Term with value v and sort Real
  - mkReal
```
public RatNum mkReal(int v)
```
    Create a real numeral.
    
    Parameters:
    v - value of the numeral.
    
    Returns:
    A Term with value v and sort Real
  - mkReal
```
public RatNum mkReal(long v)
```
    Create a real numeral.
    
    Parameters:
    v - value of the numeral.
    
    Returns:
    A Term with value v and sort Real
  - mkInt
```
public IntNum mkInt(java.lang.String v)
```
    Create an integer numeral.
    
    Parameters:
    v - A string representing the Term value in decimal notation.
  - mkInt
```
public IntNum mkInt(int v)
```
    Create an integer numeral.
    
    Parameters:
    v - value of the numeral.
    
    Returns:
    A Term with value v and sort Integer
  - mkInt
```
public IntNum mkInt(long v)
```
    Create an integer numeral.
    
    Parameters:
    v - value of the numeral.
    
    Returns:
    A Term with value v and sort Integer
  - mkBV
```
public BitVecNum mkBV(java.lang.String v,
             int size)
```
    Create a bit-vector numeral.
    
    Parameters:
    v - A string representing the value in decimal notation.
    size - the size of the bit-vector
  - mkBV
```
public BitVecNum mkBV(int v,
             int size)
```
    Create a bit-vector numeral.
    
    Parameters:
    v - value of the numeral.
    size - the size of the bit-vector
  - mkBV
```
public BitVecNum mkBV(long v,
             int size)
```
    Create a bit-vector numeral.
    
    Parameters:
    v - value of the numeral. *
    size - the size of the bit-vector
  - mkForall
```
public Quantifier mkForall(Sort[] sorts,
                  Symbol[] names,
                  Expr body,
                  int weight,
                  Pattern[] patterns,
                  Expr[] noPatterns,
                  Symbol quantifierID,
                  Symbol skolemID)
```
    Create a universal Quantifier.
    
    Parameters:
    sorts - the sorts of the bound variables.
    names - names of the bound variables
    body - the body of the quantifier.
    weight - quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0.
    patterns - array containing the patterns created using MkPattern.
    noPatterns - array containing the anti-patterns created using MkPattern.
    quantifierID - optional symbol to track quantifier.
    skolemID - optional symbol to track skolem constants.
    
    Returns:
    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. Note that the bound variables are de-Bruijn indices created using mkBound(int, com.microsoft.z3.Sort). Z3 applies the convention that the last element in names and sorts refers to the variable with index 0, the second to last element of names and sorts refers to the variable with index 1, etc.
  - mkForall
```
public Quantifier mkForall(Expr[] boundConstants,
                  Expr body,
                  int weight,
                  Pattern[] patterns,
                  Expr[] noPatterns,
                  Symbol quantifierID,
                  Symbol skolemID)
```
    Creates a universal quantifier using a list of constants that will form the set of bound variables.
    
    See Also:
    mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
  - mkExists
```
public Quantifier mkExists(Sort[] sorts,
                  Symbol[] names,
                  Expr body,
                  int weight,
                  Pattern[] patterns,
                  Expr[] noPatterns,
                  Symbol quantifierID,
                  Symbol skolemID)
```
    Creates an existential quantifier using de-Brujin indexed variables.
    
    See Also:
    mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
  - mkExists
```
public Quantifier mkExists(Expr[] boundConstants,
                  Expr body,
                  int weight,
                  Pattern[] patterns,
                  Expr[] noPatterns,
                  Symbol quantifierID,
                  Symbol skolemID)
```
    Creates an existential quantifier using a list of constants that will form the set of bound variables.
    
    See Also:
    mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
  - mkQuantifier
```
public Quantifier mkQuantifier(boolean universal,
                      Sort[] sorts,
                      Symbol[] names,
                      Expr body,
                      int weight,
                      Pattern[] patterns,
                      Expr[] noPatterns,
                      Symbol quantifierID,
                      Symbol skolemID)
```
    Create a Quantifier.
    
    See Also:
    mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
  - mkQuantifier
```
public Quantifier mkQuantifier(boolean universal,
                      Expr[] boundConstants,
                      Expr body,
                      int weight,
                      Pattern[] patterns,
                      Expr[] noPatterns,
                      Symbol quantifierID,
                      Symbol skolemID)
```
    Create a Quantifier
    
    See Also:
    mkForall(Sort[],Symbol[],Expr,int,Pattern[],Expr[],Symbol,Symbol)
  - setPrintMode
```
public void setPrintMode(Z3_ast_print_mode value)
```
    Selects the format used for pretty-printing expressions. Remarks: The default mode for pretty printing expressions is to produce SMT-LIB style output where common subexpressions are printed at each occurrence. The mode is called Z3_PRINT_SMTLIB_FULL. To print shared common subexpressions only once, use the Z3_PRINT_LOW_LEVEL mode. To print in way that conforms to SMT-LIB standards and uses let expressions to share common sub-expressions use Z3_PRINT_SMTLIB_COMPLIANT.
    
    See Also:
    Object.toString(), Object.toString(), Object.toString(), Object.toString()
  - benchmarkToSMTString
```
public java.lang.String benchmarkToSMTString(java.lang.String name,
                                    java.lang.String logic,
                                    java.lang.String status,
                                    java.lang.String attributes,
                                    BoolExpr[] assumptions,
                                    BoolExpr formula)
```
    Convert a benchmark into an SMT-LIB formatted string.
    
    Parameters:
    name - Name of the benchmark. The argument is optional.
    logic - The benchmark logic.
    status - The status string (sat, unsat, or unknown)
    attributes - Other attributes, such as source, difficulty or category.
    assumptions - Auxiliary assumptions.
    formula - Formula to be checked for consistency in conjunction with assumptions.
    
    Returns:
    A string representation of the benchmark.
  - parseSMTLIBString
```
public void parseSMTLIBString(java.lang.String str,
                     Symbol[] sortNames,
                     Sort[] sorts,
                     Symbol[] declNames,
                     FuncDecl[] decls)
```
    Parse the given string using the SMT-LIB parser. Remarks: 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.
  - parseSMTLIBFile
```
public void parseSMTLIBFile(java.lang.String fileName,
                   Symbol[] sortNames,
                   Sort[] sorts,
                   Symbol[] declNames,
                   FuncDecl[] decls)
```
    Parse the given file using the SMT-LIB parser.
    
    See Also:
    parseSMTLIBString(java.lang.String, com.microsoft.z3.Symbol[], com.microsoft.z3.Sort[], com.microsoft.z3.Symbol[], com.microsoft.z3.FuncDecl[])
  - getNumSMTLIBFormulas
```
public int getNumSMTLIBFormulas()
```
    The number of SMTLIB formulas parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getSMTLIBFormulas
```
public BoolExpr[] getSMTLIBFormulas()
```
    The formulas parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getNumSMTLIBAssumptions
```
public int getNumSMTLIBAssumptions()
```
    The number of SMTLIB assumptions parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getSMTLIBAssumptions
```
public BoolExpr[] getSMTLIBAssumptions()
```
    The assumptions parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getNumSMTLIBDecls
```
public int getNumSMTLIBDecls()
```
    The number of SMTLIB declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getSMTLIBDecls
```
public FuncDecl[] getSMTLIBDecls()
```
    The declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getNumSMTLIBSorts
```
public int getNumSMTLIBSorts()
```
    The number of SMTLIB sorts parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - getSMTLIBSorts
```
public Sort[] getSMTLIBSorts()
```
    The declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile.
  - parseSMTLIB2String
```
public BoolExpr parseSMTLIB2String(java.lang.String str,
                          Symbol[] sortNames,
                          Sort[] sorts,
                          Symbol[] declNames,
                          FuncDecl[] decls)
```
    Parse the given string using the SMT-LIB2 parser.
    
    Returns:
    A conjunction of assertions in the scope (up to push/pop) at the end of the string.
    See Also:
    parseSMTLIBString(java.lang.String, com.microsoft.z3.Symbol[], com.microsoft.z3.Sort[], com.microsoft.z3.Symbol[], com.microsoft.z3.FuncDecl[])
  - parseSMTLIB2File
```
public BoolExpr parseSMTLIB2File(java.lang.String fileName,
                        Symbol[] sortNames,
                        Sort[] sorts,
                        Symbol[] declNames,
                        FuncDecl[] decls)
```
    Parse the given file using the SMT-LIB2 parser.
    
    See Also:
    parseSMTLIB2String(java.lang.String, com.microsoft.z3.Symbol[], com.microsoft.z3.Sort[], com.microsoft.z3.Symbol[], com.microsoft.z3.FuncDecl[])
  - mkGoal
```
public Goal mkGoal(boolean models,
          boolean unsatCores,
          boolean proofs)
```
    Creates a new Goal. Remarks: Note that the Context must have been created with proof generation support if proofs is set to true here.
    
    Parameters:
    models - Indicates whether model generation should be enabled.
    unsatCores - Indicates whether unsat core generation should be enabled.
    proofs - Indicates whether proof generation should be enabled.
  - mkParams
```
public Params mkParams()
```
    Creates a new ParameterSet.
  - getNumTactics
```
public int getNumTactics()
```
    The number of supported tactics.
  - getTacticNames
```
public java.lang.String[] getTacticNames()
```
    The names of all supported tactics.
  - getTacticDescription
```
public java.lang.String getTacticDescription(java.lang.String name)
```
    Returns a string containing a description of the tactic with the given name.
  - mkTactic
```
public Tactic mkTactic(java.lang.String name)
```
    Creates a new Tactic.
  - andThen
```
public Tactic andThen(Tactic t1,
             Tactic t2,
             Tactic... ts)
```
    Create a tactic that applies t1 to a Goal and then t2"/> to every subgoal produced by <paramref name="t1.
  - then
```
public Tactic then(Tactic t1,
          Tactic t2,
          Tactic... ts)
```
    Create a tactic that applies t1 to a Goal and then t2 to every subgoal produced by t1 Remarks: Shorthand for AndThen.
  - orElse
```
public Tactic orElse(Tactic t1,
            Tactic t2)
```
    Create a tactic that first applies t1 to a Goal and if it fails then returns the result of t2 applied to the Goal.
  - tryFor
```
public Tactic tryFor(Tactic t,
            int ms)
```
    Create a tactic that applies t to a goal for ms milliseconds. Remarks: If t does not terminate within ms milliseconds, then it fails.
  - when
```
public Tactic when(Probe p,
          Tactic t)
```
    Create a tactic that applies t to a given goal if the probe p evaluates to true. Remarks: If p evaluates to false, then the new tactic behaves like the skip tactic.
  - cond
```
public Tactic cond(Probe p,
          Tactic t1,
          Tactic t2)
```
    Create a tactic that applies t1 to a given goal if the probe p"/> evaluates to true and <paramref name="t2 otherwise.
  - repeat
```
public Tactic repeat(Tactic t,
            int max)
```
    Create a tactic that keeps applying t until the goal is not modified anymore or the maximum number of iterations max is reached.
  - skip
```
public Tactic skip()
```
    Create a tactic that just returns the given goal.
  - fail
```
public Tactic fail()
```
    Create a tactic always fails.
  - failIf
```
public Tactic failIf(Probe p)
```
    Create a tactic that fails if the probe p evaluates to false.
  - failIfNotDecided
```
public Tactic failIfNotDecided()
```
    Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) or trivially unsatisfiable (i.e., contains `false').
  - usingParams
```
public Tactic usingParams(Tactic t,
                 Params p)
```
    Create a tactic that applies t using the given set of parameters p.
  - with
```
public Tactic with(Tactic t,
          Params p)
```
    Create a tactic that applies t using the given set of parameters p. Remarks: Alias for UsingParams
  - parOr
```
public Tactic parOr(Tactic... t)
```
    Create a tactic that applies the given tactics in parallel until one of them succeeds (i.e., the first that doesn't fail).
  - parAndThen
```
public Tactic parAndThen(Tactic t1,
                Tactic t2)
```
    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.
  - interrupt
```
public void interrupt()
```
    Interrupt the execution of a Z3 procedure. Remarks: This procedure can be used to interrupt: solvers, simplifiers and tactics.
  - getNumProbes
```
public int getNumProbes()
```
    The number of supported Probes.
  - getProbeNames
```
public java.lang.String[] getProbeNames()
```
    The names of all supported Probes.
  - getProbeDescription
```
public java.lang.String getProbeDescription(java.lang.String name)
```
    Returns a string containing a description of the probe with the given name.
  - mkProbe
```
public Probe mkProbe(java.lang.String name)
```
    Creates a new Probe.
  - constProbe
```
public Probe constProbe(double val)
```
    Create a probe that always evaluates to val.
  - lt
```
public Probe lt(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value returned by p1 is less than the value returned by p2
  - gt
```
public Probe gt(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value returned by p1 is greater than the value returned by p2
  - le
```
public Probe le(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value returned by p1 is less than or equal the value returned by p2
  - ge
```
public Probe ge(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value returned by p1 is greater than or equal the value returned by p2
  - eq
```
public Probe eq(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value returned by p1 is equal to the value returned by p2
  - and
```
public Probe and(Probe p1,
        Probe p2)
```
    Create a probe that evaluates to "true" when the value p1 and p2 evaluate to "true".
  - or
```
public Probe or(Probe p1,
       Probe p2)
```
    Create a probe that evaluates to "true" when the value p1 or p2 evaluate to "true".
  - not
```
public Probe not(Probe p)
```
    Create a probe that evaluates to "true" when the value p does not evaluate to "true".
  - mkSolver
```
public Solver mkSolver()
```
    Creates a new (incremental) solver. Remarks: 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
```
public Solver mkSolver(Symbol logic)
```
    Creates a new (incremental) solver. Remarks: 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
```
public Solver mkSolver(java.lang.String logic)
```
    Creates a new (incremental) solver.
    
    See Also:
    mkSolver(Symbol)
  - mkSimpleSolver
```
public Solver mkSimpleSolver()
```
    Creates a new (incremental) solver.
  - mkSolver
```
public Solver mkSolver(Tactic t)
```
    Creates a solver that is implemented using the given tactic. Remarks: The solver supports the commands Push and Pop, but it will always solve each check from scratch.
  - mkFixedpoint
```
public Fixedpoint mkFixedpoint()
```
    Create a Fixedpoint context.
  - mkOptimize
```
public Optimize mkOptimize()
```
    Create a Optimize context.
  - mkFPRoundingModeSort
```
public FPRMSort mkFPRoundingModeSort()
```
    Create the floating-point RoundingMode sort.
    
    Throws:
    
    Z3Exception
  - mkFPRoundNearestTiesToEven
```
public FPRMExpr mkFPRoundNearestTiesToEven()
```
    Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRNE
```
public FPRMNum mkFPRNE()
```
    Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRoundNearestTiesToAway
```
public FPRMNum mkFPRoundNearestTiesToAway()
```
    Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRNA
```
public FPRMNum mkFPRNA()
```
    Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRoundTowardPositive
```
public FPRMNum mkFPRoundTowardPositive()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRTP
```
public FPRMNum mkFPRTP()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardPositive rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRoundTowardNegative
```
public FPRMNum mkFPRoundTowardNegative()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRTN
```
public FPRMNum mkFPRTN()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardNegative rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRoundTowardZero
```
public FPRMNum mkFPRoundTowardZero()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPRTZ
```
public FPRMNum mkFPRTZ()
```
    Create a numeral of RoundingMode sort which represents the RoundTowardZero rounding mode.
    
    Throws:
    
    Z3Exception
  - mkFPSort
```
public FPSort mkFPSort(int ebits,
              int sbits)
```
    Create a FloatingPoint sort.
    
    Parameters:
    ebits - exponent bits in the FloatingPoint sort.
    sbits - significand bits in the FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSortHalf
```
public FPSort mkFPSortHalf()
```
    Create the half-precision (16-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSort16
```
public FPSort mkFPSort16()
```
    Create the half-precision (16-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSortSingle
```
public FPSort mkFPSortSingle()
```
    Create the single-precision (32-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSort32
```
public FPSort mkFPSort32()
```
    Create the single-precision (32-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSortDouble
```
public FPSort mkFPSortDouble()
```
    Create the double-precision (64-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSort64
```
public FPSort mkFPSort64()
```
    Create the double-precision (64-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSortQuadruple
```
public FPSort mkFPSortQuadruple()
```
    Create the quadruple-precision (128-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPSort128
```
public FPSort mkFPSort128()
```
    Create the quadruple-precision (128-bit) FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPNaN
```
public FPNum mkFPNaN(FPSort s)
```
    Create a NaN of sort s.
    
    Parameters:
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPInf
```
public FPNum mkFPInf(FPSort s,
            boolean negative)
```
    Create a floating-point infinity of sort s.
    
    Parameters:
    s - FloatingPoint sort.
    negative - indicates whether the result should be negative.
    
    Throws:
    
    Z3Exception
  - mkFPZero
```
public FPNum mkFPZero(FPSort s,
             boolean negative)
```
    Create a floating-point zero of sort s.
    
    Parameters:
    s - FloatingPoint sort.
    negative - indicates whether the result should be negative.
    
    Throws:
    
    Z3Exception
  - mkFPNumeral
```
public FPNum mkFPNumeral(float v,
                FPSort s)
```
    Create a numeral of FloatingPoint sort from a float.
    
    Parameters:
    v - numeral value.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPNumeral
```
public FPNum mkFPNumeral(double v,
                FPSort s)
```
    Create a numeral of FloatingPoint sort from a float.
    
    Parameters:
    v - numeral value.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPNumeral
```
public FPNum mkFPNumeral(int v,
                FPSort s)
```
    Create a numeral of FloatingPoint sort from an int. * @param v numeral value.
    
    Parameters:
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPNumeral
```
public FPNum mkFPNumeral(boolean sgn,
                int exp,
                int sig,
                FPSort s)
```
    Create a numeral of FloatingPoint sort from a sign bit and two integers.
    
    Parameters:
    sgn - the sign.
    sig - the significand.
    exp - the exponent.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPNumeral
```
public FPNum mkFPNumeral(boolean sgn,
                long exp,
                long sig,
                FPSort s)
```
    Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers.
    
    Parameters:
    sgn - the sign.
    sig - the significand.
    exp - the exponent.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPNum mkFP(float v,
         FPSort s)
```
    Create a numeral of FloatingPoint sort from a float.
    
    Parameters:
    v - numeral value.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPNum mkFP(double v,
         FPSort s)
```
    Create a numeral of FloatingPoint sort from a float.
    
    Parameters:
    v - numeral value.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPNum mkFP(int v,
         FPSort s)
```
    Create a numeral of FloatingPoint sort from an int.
    
    Parameters:
    v - numeral value.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPNum mkFP(boolean sgn,
         int exp,
         int sig,
         FPSort s)
```
    Create a numeral of FloatingPoint sort from a sign bit and two integers.
    
    Parameters:
    sgn - the sign.
    exp - the exponent.
    sig - the significand.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPNum mkFP(boolean sgn,
         long exp,
         long sig,
         FPSort s)
```
    Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers.
    
    Parameters:
    sgn - the sign.
    exp - the exponent.
    sig - the significand.
    s - FloatingPoint sort.
    
    Throws:
    
    Z3Exception
  - mkFPAbs
```
public FPExpr mkFPAbs(FPExpr t)
```
    Floating-point absolute value
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPNeg
```
public FPExpr mkFPNeg(FPExpr t)
```
    Floating-point negation
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPAdd
```
public FPExpr mkFPAdd(FPRMExpr rm,
             FPExpr t1,
             FPExpr t2)
```
    Floating-point addition
    
    Parameters:
    rm - rounding mode term
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPSub
```
public FPExpr mkFPSub(FPRMExpr rm,
             FPExpr t1,
             FPExpr t2)
```
    Floating-point subtraction
    
    Parameters:
    rm - rounding mode term
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPMul
```
public FPExpr mkFPMul(FPRMExpr rm,
             FPExpr t1,
             FPExpr t2)
```
    Floating-point multiplication
    
    Parameters:
    rm - rounding mode term
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPDiv
```
public FPExpr mkFPDiv(FPRMExpr rm,
             FPExpr t1,
             FPExpr t2)
```
    Floating-point division
    
    Parameters:
    rm - rounding mode term
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPFMA
```
public FPExpr mkFPFMA(FPRMExpr rm,
             FPExpr t1,
             FPExpr t2,
             FPExpr t3)
```
    Floating-point fused multiply-add
    
    Parameters:
    rm - rounding mode term
    t1 - floating-point term
    t2 - floating-point term
    t3 - floating-point term Remarks: The result is round((t1 * t2) + t3)
    
    Throws:
    
    Z3Exception
  - mkFPSqrt
```
public FPExpr mkFPSqrt(FPRMExpr rm,
              FPExpr t)
```
    Floating-point square root
    
    Parameters:
    rm - rounding mode term
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPRem
```
public FPExpr mkFPRem(FPExpr t1,
             FPExpr t2)
```
    Floating-point remainder
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPRoundToIntegral
```
public FPExpr mkFPRoundToIntegral(FPRMExpr rm,
                         FPExpr t)
```
    Floating-point roundToIntegral. Rounds a floating-point number to the closest integer, again represented as a floating-point number.
    
    Parameters:
    rm - term of RoundingMode sort
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPMin
```
public FPExpr mkFPMin(FPExpr t1,
             FPExpr t2)
```
    Minimum of floating-point numbers.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPMax
```
public FPExpr mkFPMax(FPExpr t1,
             FPExpr t2)
```
    Maximum of floating-point numbers.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPLEq
```
public BoolExpr mkFPLEq(FPExpr t1,
               FPExpr t2)
```
    Floating-point less than or equal.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPLt
```
public BoolExpr mkFPLt(FPExpr t1,
              FPExpr t2)
```
    Floating-point less than.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPGEq
```
public BoolExpr mkFPGEq(FPExpr t1,
               FPExpr t2)
```
    Floating-point greater than or equal.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPGt
```
public BoolExpr mkFPGt(FPExpr t1,
              FPExpr t2)
```
    Floating-point greater than.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPEq
```
public BoolExpr mkFPEq(FPExpr t1,
              FPExpr t2)
```
    Floating-point equality.
    
    Parameters:
    t1 - floating-point term
    t2 - floating-point term Remarks: Note that this is IEEE 754 equality (as opposed to standard =).
    
    Throws:
    
    Z3Exception
  - mkFPIsNormal
```
public BoolExpr mkFPIsNormal(FPExpr t)
```
    Predicate indicating whether t is a normal floating-point number.\
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsSubnormal
```
public BoolExpr mkFPIsSubnormal(FPExpr t)
```
    Predicate indicating whether t is a subnormal floating-point number.\
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsZero
```
public BoolExpr mkFPIsZero(FPExpr t)
```
    Predicate indicating whether t is a floating-point number with zero value, i.e., +0 or -0.
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsInfinite
```
public BoolExpr mkFPIsInfinite(FPExpr t)
```
    Predicate indicating whether t is a floating-point number representing +oo or -oo.
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsNaN
```
public BoolExpr mkFPIsNaN(FPExpr t)
```
    Predicate indicating whether t is a NaN.
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsNegative
```
public BoolExpr mkFPIsNegative(FPExpr t)
```
    Predicate indicating whether t is a negative floating-point number.
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFPIsPositive
```
public BoolExpr mkFPIsPositive(FPExpr t)
```
    Predicate indicating whether t is a positive floating-point number.
    
    Parameters:
    t - floating-point term
    
    Throws:
    
    Z3Exception
  - mkFP
```
public FPExpr mkFP(BitVecExpr sgn,
          BitVecExpr sig,
          BitVecExpr exp)
```
    Create an expression of FloatingPoint sort from three bit-vector expressions.
    
    Parameters:
    sgn - bit-vector term (of size 1) representing the sign.
    sig - bit-vector term representing the significand.
    exp - bit-vector term representing the exponent. Remarks: This is the operator named `fp' in the SMT FP theory definition. Note that sgn is required to be a bit-vector of size 1. Significand and exponent are required to be greater than 1 and 2 respectively. The FloatingPoint sort of the resulting expression is automatically determined from the bit-vector sizes of the arguments.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public FPExpr mkFPToFP(BitVecExpr bv,
              FPSort s)
```
    Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.
    
    Parameters:
    bv - bit-vector value (of size m).
    s - FloatingPoint sort (ebits+sbits == m) Remarks: Produces a term that represents the conversion of a bit-vector term bv to a floating-point term of sort s. The bit-vector size of bv (m) must be equal to ebits+sbits of s. The format of the bit-vector is as defined by the IEEE 754-2008 interchange format.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public FPExpr mkFPToFP(FPRMExpr rm,
              FPExpr t,
              FPSort s)
```
    Conversion of a FloatingPoint term into another term of different FloatingPoint sort.
    
    Parameters:
    rm - RoundingMode term.
    t - FloatingPoint term.
    s - FloatingPoint sort. Remarks: Produces a term that represents the conversion of a floating-point term t to a floating-point term of sort s. If necessary, the result will be rounded according to rounding mode rm.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public FPExpr mkFPToFP(FPRMExpr rm,
              RealExpr t,
              FPSort s)
```
    Conversion of a term of real sort into a term of FloatingPoint sort.
    
    Parameters:
    rm - RoundingMode term.
    t - term of Real sort.
    s - FloatingPoint sort. Remarks: Produces a term that represents the conversion of term t of real sort into a floating-point term of sort s. If necessary, the result will be rounded according to rounding mode rm.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public FPExpr mkFPToFP(FPRMExpr rm,
              BitVecExpr t,
              FPSort s,
              boolean signed)
```
    Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort.
    
    Parameters:
    rm - RoundingMode term.
    t - term of bit-vector sort.
    s - FloatingPoint sort.
    signed - flag indicating whether t is interpreted as signed or unsigned bit-vector. Remarks: Produces a term that represents the conversion of the bit-vector term t into a floating-point term of sort s. The bit-vector t is taken to be in signed 2's complement format (when signed==true, otherwise unsigned). If necessary, the result will be rounded according to rounding mode rm.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public FPExpr mkFPToFP(FPSort s,
              FPRMExpr rm,
              FPExpr t)
```
    Conversion of a floating-point number to another FloatingPoint sort s.
    
    Parameters:
    s - FloatingPoint sort
    rm - floating-point rounding mode term
    t - floating-point term Remarks: Produces a term that represents the conversion of a floating-point term t to a different FloatingPoint sort s. If necessary, rounding according to rm is applied.
    
    Throws:
    
    Z3Exception
  - mkFPToBV
```
public BitVecExpr mkFPToBV(FPRMExpr rm,
                  FPExpr t,
                  int sz,
                  boolean signed)
```
    Conversion of a floating-point term into a bit-vector.
    
    Parameters:
    rm - RoundingMode term.
    t - FloatingPoint term
    sz - Size of the resulting bit-vector.
    signed - Indicates whether the result is a signed or unsigned bit-vector. Remarks: Produces a term that represents the conversion of the floating-poiunt term t into a bit-vector term of size sz in 2's complement format (signed when signed==true). If necessary, the result will be rounded according to rounding mode rm.
    
    Throws:
    
    Z3Exception
  - mkFPToReal
```
public RealExpr mkFPToReal(FPExpr t)
```
    Conversion of a floating-point term into a real-numbered term.
    
    Parameters:
    t - FloatingPoint term Remarks: Produces a term that represents the conversion of the floating-poiunt term t into a real number. Note that this type of conversion will often result in non-linear constraints over real terms.
    
    Throws:
    
    Z3Exception
  - mkFPToIEEEBV
```
public BitVecExpr mkFPToIEEEBV(FPExpr t)
```
    Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
    
    Parameters:
    t - FloatingPoint term. Remarks: The size of the resulting bit-vector is automatically determined. Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion knows only one NaN and it will always produce the same bit-vector represenatation of that NaN.
    
    Throws:
    
    Z3Exception
  - mkFPToFP
```
public BitVecExpr mkFPToFP(FPRMExpr rm,
                  IntExpr exp,
                  RealExpr sig,
                  FPSort s)
```
    Conversion of a real-sorted significand and an integer-sorted exponent into a term of FloatingPoint sort.
    
    Parameters:
    rm - RoundingMode term.
    exp - Exponent term of Int sort.
    sig - Significand term of Real sort.
    s - FloatingPoint sort. Remarks: Produces a term that represents the conversion of sig * 2^exp into a floating-point term of sort s. If necessary, the result will be rounded according to rounding mode rm.
    
    Throws:
    
    Z3Exception
  - wrapAST
```
public AST wrapAST(long nativeObject)
```
    Wraps an AST. Remarks: 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.
    
    Parameters:
    nativeObject - The native pointer to wrap.
    See Also:
    Native#incRef, unwrapAST
  - unwrapAST
```
public long unwrapAST(AST a)
```
    Unwraps an AST. Remarks: 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.,
    
    Parameters:
    a - The AST to unwrap.
    See Also:
    Native#incRef, wrapAST(long)
  - SimplifyHelp
```
public java.lang.String SimplifyHelp()
```
    Return a string describing all available parameters to Expr.Simplify.
  - getSimplifyParameterDescriptions
```
public ParamDescrs getSimplifyParameterDescriptions()
```
    Retrieves parameter descriptions for simplifier.
  - updateParamValue
```
public void updateParamValue(java.lang.String id,
                    java.lang.String value)
```
    Update a mutable configuration parameter. Remarks: The list of all configuration parameters can be obtained using the Z3 executable: z3.exe -ini? Only a few configuration parameters are mutable once the context is created. An exception is thrown when trying to modify an immutable parameter.
  - getASTDRQ
```
public IDecRefQueue getASTDRQ()
```
  - getASTMapDRQ
```
public IDecRefQueue getASTMapDRQ()
```
  - getASTVectorDRQ
```
public IDecRefQueue getASTVectorDRQ()
```
  - getApplyResultDRQ
```
public IDecRefQueue getApplyResultDRQ()
```
  - getFuncEntryDRQ
```
public IDecRefQueue getFuncEntryDRQ()
```
  - getFuncInterpDRQ
```
public IDecRefQueue getFuncInterpDRQ()
```
  - getGoalDRQ
```
public IDecRefQueue getGoalDRQ()
```
  - getModelDRQ
```
public IDecRefQueue getModelDRQ()
```
  - getParamsDRQ
```
public IDecRefQueue getParamsDRQ()
```
  - getParamDescrsDRQ
```
public IDecRefQueue getParamDescrsDRQ()
```
  - getProbeDRQ
```
public IDecRefQueue getProbeDRQ()
```
  - getSolverDRQ
```
public IDecRefQueue getSolverDRQ()
```
  - getStatisticsDRQ
```
public IDecRefQueue getStatisticsDRQ()
```
  - getTacticDRQ
```
public IDecRefQueue getTacticDRQ()
```
  - getFixedpointDRQ
```
public IDecRefQueue getFixedpointDRQ()
```
  - getOptimizeDRQ
```
public IDecRefQueue getOptimizeDRQ()
```
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Finalizer.
    
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable
  - dispose
```
public void dispose()
```
    Disposes of the context.
    
    Specified by:
    
    dispose in class IDisposable

Class Context

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

m_ctx

creation_lock

m_refCount

Constructor Detail

Context

Context

Method Detail

mkSymbol

mkSymbol

getBoolSort

getIntSort

getRealSort

mkBoolSort

getStringSort

mkUninterpretedSort

mkUninterpretedSort

mkIntSort

mkRealSort

mkBitVecSort

mkArraySort

mkStringSort

mkSeqSort

mkReSort

mkTupleSort

mkEnumSort

mkEnumSort

mkListSort

mkListSort

mkFiniteDomainSort

mkFiniteDomainSort

mkConstructor

mkConstructor

mkDatatypeSort

mkDatatypeSort

mkDatatypeSorts

mkDatatypeSorts

MkUpdateField

mkFuncDecl

mkFuncDecl

mkFuncDecl

mkFuncDecl

mkFreshFuncDecl

mkConstDecl

mkConstDecl

mkFreshConstDecl

mkBound

mkPattern

mkConst

mkConst

mkFreshConst

mkConst

mkBoolConst

mkBoolConst

mkIntConst

mkIntConst

mkRealConst

mkRealConst

mkBVConst

mkBVConst

mkApp

mkTrue

mkFalse

mkBool

mkEq

mkDistinct

mkNot

mkITE

mkIff

mkImplies

mkXor

mkAnd

mkOr

mkAdd

mkMul