<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<link rel="stylesheet" href="style.css" type="text/css">
<meta content="text/html; charset=iso-8859-1" http-equiv="Content-Type">
<link rel="Start" href="index.html">
<link rel="previous" href="JITRegion.html">
<link rel="next" href="IR.html">
<link rel="Up" href="index.html">
<link title="Index of types" rel=Appendix href="index_types.html">
<link title="Index of exceptions" rel=Appendix href="index_exceptions.html">
<link title="Index of values" rel=Appendix href="index_values.html">
<link title="Index of modules" rel=Appendix href="index_modules.html">
<link title="IDA" rel="Chapter" href="IDA.html">
<link title="IDAColor" rel="Chapter" href="IDAColor.html">
<link title="IDAGUI" rel="Chapter" href="IDAGUI.html">
<link title="IDAGraph" rel="Chapter" href="IDAGraph.html">
<link title="IDAHotKey" rel="Chapter" href="IDAHotKey.html">
<link title="IDATopLoop" rel="Chapter" href="IDATopLoop.html">
<link title="JITRegion" rel="Chapter" href="JITRegion.html">
<link title="Z3" rel="Chapter" href="Z3.html">
<link title="IR" rel="Chapter" href="IR.html">
<link title="IRLocalOpt" rel="Chapter" href="IRLocalOpt.html">
<link title="IRTypeCheck" rel="Chapter" href="IRTypeCheck.html">
<link title="PpIR" rel="Chapter" href="PpIR.html">
<link title="X86" rel="Chapter" href="X86.html">
<link title="X86CFG" rel="Chapter" href="X86CFG.html">
<link title="X86CFGAssembler" rel="Chapter" href="X86CFGAssembler.html">
<link title="X86Constraints" rel="Chapter" href="X86Constraints.html">
<link title="X86Decode" rel="Chapter" href="X86Decode.html">
<link title="X86Disasm" rel="Chapter" href="X86Disasm.html">
<link title="X86Encode" rel="Chapter" href="X86Encode.html">
<link title="X86InternalOperand" rel="Chapter" href="X86InternalOperand.html">
<link title="X86LocalOpt" rel="Chapter" href="X86LocalOpt.html">
<link title="X86TextualAssembler" rel="Chapter" href="X86TextualAssembler.html">
<link title="X86TypeCheck" rel="Chapter" href="X86TypeCheck.html">
<link title="X86Util" rel="Chapter" href="X86Util.html">
<link title="X86Random" rel="Chapter" href="X86Random.html">
<link title="X86ToIR" rel="Chapter" href="X86ToIR.html">
<link title="ASMUtil" rel="Chapter" href="ASMUtil.html">
<link title="LowLevel-old" rel="Chapter" href="LowLevel-old.html">
<link title="StringUtil" rel="Chapter" href="StringUtil.html">
<link title="Util" rel="Chapter" href="Util.html"><link title="Create configuration" rel="Section" href="#2_Createconfiguration">
<link title="Create context" rel="Section" href="#2_Createcontext">
<link title="Symbols" rel="Section" href="#2_Symbols">
<link title="Sorts" rel="Section" href="#2_Sorts">
<link title="Injective functions" rel="Section" href="#2_Injectivefunctions">
<link title="Constants and Applications" rel="Section" href="#2_ConstantsandApplications">
<link title="Sets" rel="Section" href="#2_Sets">
<link title="Numerals" rel="Section" href="#2_Numerals">
<link title="Quantifiers" rel="Section" href="#2_Quantifiers">
<link title="Accessors" rel="Section" href="#2_Accessors">
<link title="Modifiers" rel="Section" href="#2_Modifiers">
<link title="Coercions" rel="Section" href="#2_Coercions">
<link title="Constraints" rel="Section" href="#2_Constraints">
<link title="Search control." rel="Section" href="#2_Searchcontrol">
<link title="Labels." rel="Section" href="#2_Labels">
<link title="Model navigation" rel="Section" href="#2_Modelnavigation">
<link title="Interaction logging." rel="Section" href="#2_Interactionlogging">
<link title="String conversion" rel="Section" href="#2_Stringconversion">
<link title="Parser interface" rel="Section" href="#2_Parserinterface">
<link title="Miscellaneous" rel="Section" href="#2_Miscellaneous">
<link title="External Theory Plugins" rel="Section" href="#2_ExternalTheoryPlugins">
<link title="Fixedpoint and Datalog facilities" rel="Section" href="#2_FixedpointandDatalogfacilities">
<link title="ML Extensions" rel="Section" href="#2_MLExtensions">
<title>Z3</title>
</head>
<body>
<div class="navbar"><a href="JITRegion.html">Previous</a>
&nbsp;<a href="index.html">Up</a>
&nbsp;<a href="IR.html">Next</a>
</div>
<center><h1>Module <a href="type_Z3.html">Z3</a></h1></center>
<br>
<pre><span class="keyword">module</span> Z3: <code class="code">sig</code> <a href="Z3.html">..</a> <code class="code">end</code></pre><hr width="100%">
<pre><span id="TYPEconfig"><span class="keyword">type</span> <code class="type"></code>config</span> </pre>

<pre><span id="TYPEcontext"><span class="keyword">type</span> <code class="type"></code>context</span> </pre>

<pre><span id="TYPEsort"><span class="keyword">type</span> <code class="type"></code>sort</span> </pre>

<pre><span id="TYPEfunc_decl"><span class="keyword">type</span> <code class="type"></code>func_decl</span> </pre>

<pre><span id="TYPEast"><span class="keyword">type</span> <code class="type"></code>ast</span> </pre>

<pre><span id="TYPEapp"><span class="keyword">type</span> <code class="type"></code>app</span> </pre>

<pre><span id="TYPEpattern"><span class="keyword">type</span> <code class="type"></code>pattern</span> </pre>

<pre><span id="TYPEsymbol"><span class="keyword">type</span> <code class="type"></code>symbol</span> </pre>

<pre><span id="TYPEparameter"><span class="keyword">type</span> <code class="type"></code>parameter</span> </pre>

<pre><span id="TYPEmodel"><span class="keyword">type</span> <code class="type"></code>model</span> </pre>

<pre><span id="TYPEliterals"><span class="keyword">type</span> <code class="type"></code>literals</span> </pre>

<pre><span id="TYPEconstructor"><span class="keyword">type</span> <code class="type"></code>constructor</span> </pre>

<pre><span id="TYPEconstructor_list"><span class="keyword">type</span> <code class="type"></code>constructor_list</span> </pre>

<pre><span id="TYPEtheory"><span class="keyword">type</span> <code class="type"></code>theory</span> </pre>

<pre><span id="TYPEtheory_data"><span class="keyword">type</span> <code class="type"></code>theory_data</span> </pre>

<br><code><span id="TYPEenum_1"><span class="keyword">type</span> <code class="type"></code>enum_1</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">L_FALSE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">L_UNDEF</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">L_TRUE</span></code></td>

</tr></table>


<pre><span id="TYPElbool"><span class="keyword">type</span> <code class="type"></code>lbool</span> = <code class="type"><a href="Z3.html#TYPEenum_1">enum_1</a></code> </pre>

<br><code><span id="TYPEenum_2"><span class="keyword">type</span> <code class="type"></code>enum_2</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">INT_SYMBOL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">STRING_SYMBOL</span></code></td>

</tr></table>


<pre><span id="TYPEsymbol_kind"><span class="keyword">type</span> <code class="type"></code>symbol_kind</span> = <code class="type"><a href="Z3.html#TYPEenum_2">enum_2</a></code> </pre>

<br><code><span id="TYPEenum_3"><span class="keyword">type</span> <code class="type"></code>enum_3</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_INT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_DOUBLE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_RATIONAL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_SYMBOL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_AST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PARAMETER_FUNC_DECL</span></code></td>

</tr></table>


<pre><span id="TYPEparameter_kind"><span class="keyword">type</span> <code class="type"></code>parameter_kind</span> = <code class="type"><a href="Z3.html#TYPEenum_3">enum_3</a></code> </pre>

<br><code><span id="TYPEenum_4"><span class="keyword">type</span> <code class="type"></code>enum_4</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">UNINTERPRETED_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BOOL_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">INT_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">REAL_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">BV_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">ARRAY_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">DATATYPE_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">RELATION_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">FINITE_DOMAIN_SORT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">UNKNOWN_SORT</span></code></td>

</tr></table>


<pre><span id="TYPEsort_kind"><span class="keyword">type</span> <code class="type"></code>sort_kind</span> = <code class="type"><a href="Z3.html#TYPEenum_4">enum_4</a></code> </pre>

<br><code><span id="TYPEenum_5"><span class="keyword">type</span> <code class="type"></code>enum_5</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">NUMERAL_AST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">APP_AST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">VAR_AST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">QUANTIFIER_AST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">UNKNOWN_AST</span></code></td>

</tr></table>


<pre><span id="TYPEast_kind"><span class="keyword">type</span> <code class="type"></code>ast_kind</span> = <code class="type"><a href="Z3.html#TYPEenum_5">enum_5</a></code> </pre>

<br><code><span id="TYPEenum_6"><span class="keyword">type</span> <code class="type"></code>enum_6</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_TRUE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_FALSE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_EQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_DISTINCT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ITE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_AND</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_OR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_IFF</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_XOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_NOT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_IMPLIES</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_OEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ANUM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_LE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_GE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_LT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_GT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ADD</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SUB</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_UMINUS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_MUL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_DIV</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_IDIV</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_REM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_MOD</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_TO_REAL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_TO_INT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_IS_INT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_STORE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SELECT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_CONST_ARRAY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ARRAY_MAP</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ARRAY_DEFAULT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SET_UNION</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SET_INTERSECT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SET_DIFFERENCE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SET_COMPLEMENT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SET_SUBSET</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_AS_ARRAY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BNUM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BIT1</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BIT0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BNEG</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BADD</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSUB</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BMUL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSDIV</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BUDIV</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSREM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BUREM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSMOD</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSDIV0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BUDIV0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSREM0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BUREM0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSMOD0</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ULEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SLEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_UGEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SGEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ULT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SLT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_UGT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SGT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BAND</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BNOT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BXOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BNAND</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BNOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BXNOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_CONCAT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_SIGN_EXT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ZERO_EXT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_EXTRACT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_REPEAT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BREDOR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BREDAND</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BCOMP</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BSHL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BLSHR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BASHR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ROTATE_LEFT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_ROTATE_RIGHT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_EXT_ROTATE_LEFT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_EXT_ROTATE_RIGHT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_INT2BV</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_BV2INT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_CARRY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_XOR3</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_UNDEF</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_TRUE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_ASSERTED</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_GOAL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_MODUS_PONENS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_REFLEXIVITY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_SYMMETRY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_TRANSITIVITY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_TRANSITIVITY_STAR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_MONOTONICITY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_QUANT_INTRO</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_DISTRIBUTIVITY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_AND_ELIM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_NOT_OR_ELIM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_REWRITE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_REWRITE_STAR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_PULL_QUANT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_PULL_QUANT_STAR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_PUSH_QUANT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_ELIM_UNUSED_VARS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_DER</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_QUANT_INST</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_HYPOTHESIS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_LEMMA</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_UNIT_RESOLUTION</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_IFF_TRUE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_IFF_FALSE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_COMMUTATIVITY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_DEF_AXIOM</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_DEF_INTRO</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_APPLY_DEF</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_IFF_OEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_NNF_POS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_NNF_NEG</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_NNF_STAR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_CNF_STAR</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_SKOLEMIZE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_MODUS_PONENS_OEQ</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_PR_TH_LEMMA</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_STORE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_EMPTY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_IS_EMPTY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_JOIN</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_UNION</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_WIDEN</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_PROJECT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_FILTER</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_NEGATION_FILTER</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_RENAME</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_COMPLEMENT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_SELECT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_RA_CLONE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_FD_LT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">OP_UNINTERPRETED</span></code></td>

</tr></table>


<pre><span id="TYPEdecl_kind"><span class="keyword">type</span> <code class="type"></code>decl_kind</span> = <code class="type"><a href="Z3.html#TYPEenum_6">enum_6</a></code> </pre>

<br><code><span id="TYPEenum_7"><span class="keyword">type</span> <code class="type"></code>enum_7</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">NO_FAILURE</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">UNKNOWN</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">TIMEOUT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">MEMOUT_WATERMARK</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">CANCELED</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">NUM_CONFLICTS</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">THEORY</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">QUANTIFIERS</span></code></td>

</tr></table>


<pre><span id="TYPEsearch_failure"><span class="keyword">type</span> <code class="type"></code>search_failure</span> = <code class="type"><a href="Z3.html#TYPEenum_7">enum_7</a></code> </pre>

<br><code><span id="TYPEenum_8"><span class="keyword">type</span> <code class="type"></code>enum_8</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PRINT_SMTLIB_FULL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PRINT_LOW_LEVEL</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PRINT_SMTLIB_COMPLIANT</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">PRINT_SMTLIB2_COMPLIANT</span></code></td>

</tr></table>


<pre><span id="TYPEast_print_mode"><span class="keyword">type</span> <code class="type"></code>ast_print_mode</span> = <code class="type"><a href="Z3.html#TYPEenum_8">enum_8</a></code> </pre>

<br>
(*
<ul>
<li>OP_TRUE The constant true.
</li>
</ul>
<ul>
<li>OP_FALSE The constant false.
</li>
</ul>
<ul>
<li>OP_EQ The equality predicate.
</li>
</ul>
<ul>
<li>OP_DISTINCT The n-ary distinct predicate (every argument is mutually distinct).
</li>
</ul>
<ul>
<li>OP_ITE The ternary if-then-else term.
</li>
</ul>
<ul>
<li>OP_AND n-ary conjunction.
</li>
</ul>
<ul>
<li>OP_OR n-ary disjunction.
</li>
</ul>
<ul>
<li>OP_IFF equivalence (binary).
</li>
</ul>
<ul>
<li>OP_XOR Exclusive or.
</li>
</ul>
<ul>
<li>OP_NOT Negation.
</li>
</ul>
<ul>
<li>OP_IMPLIES Implication.
</li>
</ul>
<ul>
<li>OP_OEQ Binary equivalence modulo namings. This binary predicate is used in proof terms.

        It captures equisatisfiability and equivalence modulo renamings.
</li>
</ul>
<ul>
<li>OP_ANUM Arithmetic numeral.
</li>
</ul>
<ul>
<li>OP_LE &lt;=.
</li>
</ul>
<ul>
<li>OP_GE &gt;=.
</li>
</ul>
<ul>
<li>OP_LT &lt;.
</li>
</ul>
<ul>
<li>OP_GT &gt;.
</li>
</ul>
<ul>
<li>OP_ADD Addition - Binary.
</li>
</ul>
<ul>
<li>OP_SUB Binary subtraction.
</li>
</ul>
<ul>
<li>OP_UMINUS Unary minus.
</li>
</ul>
<ul>
<li>OP_MUL Multiplication - Binary.
</li>
</ul>
<ul>
<li>OP_DIV Division - Binary.
</li>
</ul>
<ul>
<li>OP_IDIV Integer division - Binary.
</li>
</ul>
<ul>
<li>OP_REM Remainder - Binary.
</li>
</ul>
<ul>
<li>OP_MOD Modulus - Binary.
</li>
</ul>
<ul>
<li>OP_TO_REAL Coercion of integer to real - Unary.
</li>
</ul>
<ul>
<li>OP_TO_INT Coercion of real to integer - Unary.
</li>
</ul>
<ul>
<li>OP_IS_INT Check if real is also an integer - Unary.
</li>
</ul>
<ul>
<li>OP_STORE Array store. It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j).

        Array store takes at least 3 arguments. 
</li>
</ul>
<ul>
<li>OP_SELECT Array select. 
</li>
</ul>
<ul>
<li>OP_CONST_ARRAY The constant array. For example, select(const(v),i) = v holds for every v and i. The function is unary.
</li>
</ul>
<ul>
<li>OP_ARRAY_DEFAULT Default value of arrays. For example default(const(v)) = v. The function is unary.
</li>
</ul>
<ul>
<li>OP_ARRAY_MAP Array map operator.

         It satisfies map<code class="code">f</code>(a1,..,a_n)<code class="code">i</code> = f(a1<code class="code">i</code>,...,a_n<code class="code">i</code>) for every i.
</li>
</ul>
<ul>
<li>OP_SET_UNION Set union between two Booelan arrays (two arrays whose range type is Boolean). The function is binary.
</li>
</ul>
<ul>
<li>OP_SET_INTERSECT Set intersection between two Boolean arrays. The function is binary.
</li>
</ul>
<ul>
<li>OP_SET_DIFFERENCE Set difference between two Boolean arrays. The function is binary.
</li>
</ul>
<ul>
<li>OP_SET_COMPLEMENT Set complement of a Boolean array. The function is unary.
</li>
</ul>
<ul>
<li>OP_SET_SUBSET Subset predicate between two Boolean arrays. The relation is binary.
</li>
</ul>
<ul>
<li>OP_AS_ARRAY An array value that behaves as the function graph of the

                    function passed as parameter.
</li>
</ul>
<ul>
<li>OP_BNUM Bit-vector numeral.
</li>
</ul>
<ul>
<li>OP_BIT1 One bit bit-vector.
</li>
</ul>
<ul>
<li>OP_BIT0 Zero bit bit-vector.
</li>
</ul>
<ul>
<li>OP_BNEG Unary minus.
</li>
</ul>
<ul>
<li>OP_BADD Binary addition.
</li>
</ul>
<ul>
<li>OP_BSUB Binary subtraction.
</li>
</ul>
<ul>
<li>OP_BMUL Binary multiplication.
</li>
</ul>
<ul>
<li>OP_BSDIV Binary signed division.
</li>
</ul>
<ul>
<li>OP_BUDIV Binary unsigned int division.
</li>
</ul>
<ul>
<li>OP_BSREM Binary signed remainder.
</li>
</ul>
<ul>
<li>OP_BUREM Binary unsigned int remainder.
</li>
</ul>
<ul>
<li>OP_BSMOD Binary signed modulus.
</li>
</ul>
<ul>
<li>OP_BSDIV0 Unary function. bsdiv(x,0) is congruent to bsdiv0(x).
</li>
</ul>
<ul>
<li>OP_BUDIV0 Unary function. budiv(x,0) is congruent to budiv0(x).
</li>
</ul>
<ul>
<li>OP_BSREM0 Unary function. bsrem(x,0) is congruent to bsrem0(x).
</li>
</ul>
<ul>
<li>OP_BUREM0 Unary function. burem(x,0) is congruent to burem0(x).
</li>
</ul>
<ul>
<li>OP_BSMOD0 Unary function. bsmod(x,0) is congruent to bsmod0(x).
</li>
</ul>
<ul>
<li>OP_ULEQ Unsigned bit-vector &lt;= - Binary relation.
</li>
</ul>
<ul>
<li>OP_SLEQ Signed bit-vector  &lt;= - Binary relation.
</li>
</ul>
<ul>
<li>OP_UGEQ Unsigned bit-vector  &gt;= - Binary relation.
</li>
</ul>
<ul>
<li>OP_SGEQ Signed bit-vector  &gt;= - Binary relation.
</li>
</ul>
<ul>
<li>OP_ULT Unsigned bit-vector  &lt; - Binary relation.
</li>
</ul>
<ul>
<li>OP_SLT Signed bit-vector &lt; - Binary relation.
</li>
</ul>
<ul>
<li>OP_UGT Unsigned bit-vector &gt; - Binary relation.
</li>
</ul>
<ul>
<li>OP_SGT Signed bit-vector &gt; - Binary relation.
</li>
</ul>
<ul>
<li>OP_BAND Bit-wise and - Binary.
</li>
</ul>
<ul>
<li>OP_BOR Bit-wise or - Binary.
</li>
</ul>
<ul>
<li>OP_BNOT Bit-wise not - Unary.
</li>
</ul>
<ul>
<li>OP_BXOR Bit-wise xor - Binary.
</li>
</ul>
<ul>
<li>OP_BNAND Bit-wise nand - Binary.
</li>
</ul>
<ul>
<li>OP_BNOR Bit-wise nor - Binary.
</li>
</ul>
<ul>
<li>OP_BXNOR Bit-wise xnor - Binary.
</li>
</ul>
<ul>
<li>OP_CONCAT Bit-vector concatenation - Binary.
</li>
</ul>
<ul>
<li>OP_SIGN_EXT Bit-vector sign extension.
</li>
</ul>
<ul>
<li>OP_ZERO_EXT Bit-vector zero extension.
</li>
</ul>
<ul>
<li>OP_EXTRACT Bit-vector extraction.
</li>
</ul>
<ul>
<li>OP_REPEAT Repeat bit-vector n times.
</li>
</ul>
<ul>
<li>OP_BREDOR Bit-vector reduce or - Unary.
</li>
</ul>
<ul>
<li>OP_BREDAND Bit-vector reduce and - Unary.
</li>
</ul>
<ul>
<li>OP_BCOMP .
</li>
</ul>
<ul>
<li>OP_BSHL Shift left.
</li>
</ul>
<ul>
<li>OP_BLSHR Logical shift right.
</li>
</ul>
<ul>
<li>OP_BASHR Arithmetical shift right.
</li>
</ul>
<ul>
<li>OP_ROTATE_LEFT Left rotation.
</li>
</ul>
<ul>
<li>OP_ROTATE_RIGHT Right rotation.
</li>
</ul>
<ul>
<li>OP_EXT_ROTATE_LEFT (extended) Left rotation. Similar to OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one.
</li>
</ul>
<ul>
<li>OP_EXT_ROTATE_RIGHT (extended) Right rotation. Similar to OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one.
</li>
</ul>
<ul>
<li>OP_INT2BV Coerce integer to bit-vector. NB. This function

       is not supported by the decision procedures. Only the most

       rudimentary simplification rules are applied to this function.
</li>
</ul>
<ul>
<li>OP_BV2INT Coerce bit-vector to integer. NB. This function

       is not supported by the decision procedures. Only the most

       rudimentary simplification rules are applied to this function.
</li>
</ul>
<ul>
<li>OP_CARRY Compute the carry bit in a full-adder. 

       The meaning is given by the equivalence

       (carry l1 l2 l3) &lt;=&gt; (or (and l1 l2) (and l1 l3) (and l2 l3)))
</li>
</ul>
<ul>
<li>OP_XOR3 Compute ternary XOR.

       The meaning is given by the equivalence

       (xor3 l1 l2 l3) &lt;=&gt; (xor (xor l1 l2) l3)
</li>
</ul>
<ul>
<li>OP_PR_TRUE: Proof for the expression 'true'.
</li>
</ul>
<ul>
<li>OP_PR_ASSERTED: Proof for a fact asserted by the user.
</li>
</ul>
<ul>
<li>OP_PR_GOAL: Proof for a fact (tagged as goal) asserted by the user.
</li>
</ul>
<ul>
<li>OP_PR_MODUS_PONENS: Given a proof for p and a proof for (implies p q), produces a proof for q.

       <em>
          T1: p

          T2: (implies p q)

          <code class="code">mp T1 T2</code>: q

          </em>

          The second antecedents may also be a proof for (iff p q).
</li>
</ul>
<ul>
<li>OP_PR_REFLEXIVITY: A proof for (R t t), where R is a reflexive relation. This proof object has no antecedents.

        The only reflexive relations that are used are 

        equivalence modulo namings, equality and equivalence.

        That is, R is either '~', '=' or 'iff'.
</li>
</ul>
<ul>
<li>OP_PR_SYMMETRY: Given an symmetric relation R and a proof for (R t s), produces a proof for (R s t).

          <em>
          T1: (R t s)

          <code class="code">symmetry T1</code>: (R s t)

          </em>

          T1 is the antecedent of this proof object.
</li>
</ul>
<ul>
<li>OP_PR_TRANSITIVITY: Given a transitive relation R, and proofs for (R t s) and (R s u), produces a proof

       for (R t u).

       <em>
       T1: (R t s)

       T2: (R s u)

       <code class="code">trans T1 T2</code>: (R t u)

       </em>
</li>
</ul>
<ul>
<li>OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1.

     It combines several symmetry and transitivity proofs. 
</li>
</ul>

          Example:

          <em>
          T1: (R a b)

          T2: (R c b)

          T3: (R c d)

          <code class="code">trans* T1 T2 T3</code>: (R a d)

          </em>

          R must be a symmetric and transitive relation.

<p>

          Assuming that this proof object is a proof for (R s t), then

          a proof checker must check if it is possible to prove (R s t)

          using the antecedents, symmetry and transitivity.  That is, 

          if there is a path from s to t, if we view every

          antecedent (R a b) as an edge between a and b.

<p>
<ul>
<li>OP_PR_MONOTONICITY: Monotonicity proof object.

          <em>
          T1: (R t_1 s_1)

          ...

          Tn: (R t_n s_n)

          <code class="code">monotonicity T1 ... Tn</code>: (R (f t_1 ... t_n) (f s_1 ... s_n))

          </em>

          Remark: if t_i == s_i, then the antecedent Ti is suppressed.

          That is, reflexivity proofs are supressed to save space.
</li>
</ul>
<ul>
<li>OP_PR_QUANT_INTRO: Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)).
</li>
</ul>

       T1: (~ p q)

       <code class="code">quant-intro T1</code>: (~ (forall (x) p) (forall (x) q))

<p>
<ul>
<li>OP_PR_DISTRIBUTIVITY: Distributivity proof object. 

          Given that f (= or) distributes over g (= and), produces a proof for
</li>
</ul>

          (= (f a (g c d))

             (g (f a c) (f a d)))

<p>

          If f and g are associative, this proof also justifies the following equality:

<p>

          (= (f (g a b) (g c d))

             (g (f a c) (f a d) (f b c) (f b d)))

<p>

          where each f and g can have arbitrary number of arguments.

<p>

          This proof object has no antecedents.

          Remark. This rule is used by the CNF conversion pass and 

          instantiated by f = or, and g = and.

<p>
<ul>
<li>OP_PR_AND_ELIM: Given a proof for (and l_1 ... l_n), produces a proof for l_i
</li>
</ul>

       <em>
       T1: (and l_1 ... l_n)

       <code class="code">and-elim T1</code>: l_i

       </em>
<ul>
<li>OP_PR_NOT_OR_ELIM: Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i).
</li>
</ul>

       <em>
       T1: (not (or l_1 ... l_n))

       <code class="code">not-or-elim T1</code>: (not l_i)

       </em>

<p>
<ul>
<li>OP_PR_REWRITE: A proof for a local rewriting step (= t s).

          The head function symbol of t is interpreted.
</li>
</ul>

          This proof object has no antecedents.

          The conclusion of a rewrite rule is either an equality (= t s), 

          an equivalence (iff t s), or equi-satisfiability (~ t s).

          Remark: if f is bool, then = is iff.

<p>

          Examples:

          <em>
          (= (+ x 0) x)

          (= (+ x 1 2) (+ 3 x))

          (iff (or x false) x)

          </em>

<p>
<ul>
<li>OP_PR_REWRITE_STAR: A proof for rewriting an expression t into an expression s.

       This proof object is used if the parameter PROOF_MODE is 1.

       This proof object can have n antecedents.

       The antecedents are proofs for equalities used as substitution rules.

       The object is also used in a few cases if the parameter PROOF_MODE is 2.

       The cases are:
</li>
<li>When applying contextual simplification (CONTEXT_SIMPLIFIER=true)
</li>
<li>When converting bit-vectors to Booleans (BIT2BOOL=true)
</li>
<li>When pulling ite expression up (PULL_CHEAP_ITE_TREES=true)
</li>
</ul>
<ul>
<li>OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents.
</li>
</ul>
<ul>
<li>OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form.

       This proof object is only used if the parameter PROOF_MODE is 1.       

       This proof object has no antecedents.
</li>
</ul>
<ul>
<li>OP_PR_PUSH_QUANT: A proof for:
</li>
</ul>

       <em>
          (iff (forall (x_1 ... x_m) (and p_1<code class="code">x_1 ... x_m</code> ... p_n<code class="code">x_1 ... x_m</code>))

               (and (forall (x_1 ... x_m) p_1<code class="code">x_1 ... x_m</code>)

                 ... 

               (forall (x_1 ... x_m) p_n<code class="code">x_1 ... x_m</code>)))

               </em>

         This proof object has no antecedents.

<p>
<ul>
<li>OP_PR_ELIM_UNUSED_VARS:  

          A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p<code class="code">x_1 ... x_n</code>)

                           (forall (x_1 ... x_n) p<code class="code">x_1 ... x_n</code>)) 
</li>
</ul>

          It is used to justify the elimination of unused variables.

          This proof object has no antecedents.

<p>
<ul>
<li>OP_PR_DER: A proof for destructive equality resolution:

          (iff (forall (x) (or (not (= x t)) P<code class="code">x</code>)) P<code class="code">t</code>)

          if x does not occur in t.
</li>
</ul>

          This proof object has no antecedents.

<p>

          Several variables can be eliminated simultaneously.

<p>
<ul>
<li>OP_PR_QUANT_INST: A proof of (or (not (forall (x) (P x))) (P a))
</li>
</ul>
<ul>
<li>OP_PR_HYPOTHESIS: Mark a hypothesis in a natural deduction style proof.
</li>
</ul>
<ul>
<li>OP_PR_LEMMA: 
</li>
</ul>

       <em>
          T1: false

          <code class="code">lemma T1</code>: (or (not l_1) ... (not l_n))

          </em>

          This proof object has one antecedent: a hypothetical proof for false.

          It converts the proof in a proof for (or (not l_1) ... (not l_n)),

          when T1 contains the hypotheses: l_1, ..., l_n.

<p>
<ul>
<li>OP_PR_UNIT_RESOLUTION: 

       <em>
          T1:      (or l_1 ... l_n l_1' ... l_m')

          T2:      (not l_1)

          ...

          T(n+1):  (not l_n)

          <code class="code">unit-resolution T1 ... T(n+1)</code>: (or l_1' ... l_m')

          </em>
</li>
</ul>
<ul>
<li>OP_PR_IFF_TRUE: 

      <em>
       T1: p

       <code class="code">iff-true T1</code>: (iff p true)

       </em>
</li>
</ul>
<ul>
<li>OP_PR_IFF_FALSE:

      <em>
       T1: (not p)

       <code class="code">iff-false T1</code>: (iff p false)

       </em>
</li>
</ul>
<ul>
<li>OP_PR_COMMUTATIVITY:
</li>
</ul>

          <code class="code">comm</code>: (= (f a b) (f b a))

<p>

          f is a commutative operator.

<p>

          This proof object has no antecedents.

          Remark: if f is bool, then = is iff.

<p>
<ul>
<li>OP_PR_DEF_AXIOM: Proof object used to justify Tseitin's like axioms:
</li>
</ul>

          <em>
          (or (not (and p q)) p)

          (or (not (and p q)) q)

          (or (not (and p q r)) p)

          (or (not (and p q r)) q)

          (or (not (and p q r)) r)

          ...

          (or (and p q) (not p) (not q))

          (or (not (or p q)) p q)

          (or (or p q) (not p))

          (or (or p q) (not q))

          (or (not (iff p q)) (not p) q)

          (or (not (iff p q)) p (not q))

          (or (iff p q) (not p) (not q))

          (or (iff p q) p q)

          (or (not (ite a b c)) (not a) b)

          (or (not (ite a b c)) a c)

          (or (ite a b c) (not a) (not b))

          (or (ite a b c) a (not c))

          (or (not (not a)) (not a))

          (or (not a) a)

          </em>

          This proof object has no antecedents.

          Note: all axioms are propositional tautologies.

          Note also that 'and' and 'or' can take multiple arguments.

          You can recover the propositional tautologies by

          unfolding the Boolean connectives in the axioms a small

          bounded number of steps (=3).

<p>
<ul>
<li>OP_PR_DEF_INTRO: Introduces a name for a formula/term.

       Suppose e is an expression with free variables x, and def-intro

       introduces the name n(x). The possible cases are:
</li>
</ul>

       When e is of Boolean type:

       <code class="code">def-intro</code>: (and (or n (not e)) (or (not n) e))

<p>

       or:

       <code class="code">def-intro</code>: (or (not n) e)

       when e only occurs positively.

<p>

       When e is of the form (ite cond th el):

       <code class="code">def-intro</code>: (and (or (not cond) (= n th)) (or cond (= n el)))

<p>

       Otherwise:

       <code class="code">def-intro</code>: (= n e)       

<p>
<ul>
<li>OP_PR_APPLY_DEF: 

       <code class="code">apply-def T1</code>: F ~ n

       F is 'equivalent' to n, given that T1 is a proof that

       n is a name for F.
</li>
</ul>
<ul>
<li>OP_PR_IFF_OEQ:

       T1: (iff p q)

       <code class="code">iff~ T1</code>: (~ p q)
</li>
</ul>
<ul>
<li>OP_PR_NNF_POS: Proof for a (positive) NNF step. Example:

       <em>
          T1: (not s_1) ~ r_1

          T2: (not s_2) ~ r_2

          T3: s_1 ~ r_1'

          T4: s_2 ~ r_2'

          <code class="code">nnf-pos T1 T2 T3 T4</code>: (~ (iff s_1 s_2)

                                    (and (or r_1 r_2') (or r_1' r_2)))

          </em>

       The negation normal form steps NNF_POS and NNF_NEG are used in the following cases:

       (a) When creating the NNF of a positive force quantifier.

        The quantifier is retained (unless the bound variables are eliminated).

        Example

        <em>
           T1: q ~ q_new 

           <code class="code">nnf-pos T1</code>: (~ (forall (x T) q) (forall (x T) q_new))

        </em>

       (b) When recursively creating NNF over Boolean formulas, where the top-level

       connective is changed during NNF conversion. The relevant Boolean connectives

       for NNF_POS are 'implies', 'iff', 'xor', 'ite'.

       NNF_NEG furthermore handles the case where negation is pushed

       over Boolean connectives 'and' and 'or'.
</li>
</ul>
<ul>
<li>OP_PR_NFF_NEG: Proof for a (negative) NNF step. Examples:

          <em>
          T1: (not s_1) ~ r_1

          ...

          Tn: (not s_n) ~ r_n

         <code class="code">nnf-neg T1 ... Tn</code>: (not (and s_1 ... s_n)) ~ (or r_1 ... r_n)

      and

          T1: (not s_1) ~ r_1

          ...

          Tn: (not s_n) ~ r_n

         <code class="code">nnf-neg T1 ... Tn</code>: (not (or s_1 ... s_n)) ~ (and r_1 ... r_n)

      and

          T1: (not s_1) ~ r_1

          T2: (not s_2) ~ r_2

          T3: s_1 ~ r_1'

          T4: s_2 ~ r_2'

         <code class="code">nnf-neg T1 T2 T3 T4</code>: (~ (not (iff s_1 s_2))

                                   (and (or r_1 r_2) (or r_1' r_2')))

       </em>
</li>
<li>OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form.
</li>
</ul>

       This proof object is only used if the parameter PROOF_MODE is 1.       

<p>

       This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO.

<p>
<ul>
<li>OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form.

       This proof object is only used if the parameter PROOF_MODE is 1.       

       This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO.          
</li>
</ul>
<ul>
<li>OP_PR_SKOLEMIZE: Proof for:  
</li>
</ul>

          <em>
          <code class="code">sk</code>: (~ (not (forall x (p x y))) (not (p (sk y) y)))

          <code class="code">sk</code>: (~ (exists x (p x y)) (p (sk y) y))

          </em>

<p>

          This proof object has no antecedents.

<p>
<ul>
<li>OP_PR_MODUS_PONENS_OEQ: Modus ponens style rule for equi-satisfiability.

       <em>
          T1: p

          T2: (~ p q)

          <code class="code">mp~ T1 T2</code>: q

          </em>
</li>
</ul>
<ul>
<li>OP_PR_TH_LEMMA: Generic proof for theory lemmas.
</li>
</ul>

         The theory lemma function comes with one or more parameters.

         The first parameter indicates the name of the theory.

         For the theory of arithmetic, additional parameters provide hints for

         checking the theory lemma. 

         The hints for arithmetic are:

<p>
<ul>
<li>farkas - followed by rational coefficients. Multiply the coefficients to the

           inequalities in the lemma, add the (negated) inequalities and obtain a contradiction.
</li>
</ul>
<ul>
<li>triangle-eq - Indicates a lemma related to the equivalence:

         <em>
            (iff (= t1 t2) (and (&lt;= t1 t2) (&lt;= t2 t1)))

         </em>
</li>
</ul>
<ul>
<li>gcd-test - Indicates an integer linear arithmetic lemma that uses a gcd test.
</li>
</ul>
<ul>
<li>OP_RA_STORE: Insert a record into a relation.

        The function takes n+1 arguments, where the first argument is the relation and the remaining n elements 

        correspond to the n columns of the relation.
</li>
</ul>
<ul>
<li>OP_RA_EMPTY: Creates the empty relation. 
</li>
</ul>
<ul>
<li>OP_RA_IS_EMPTY: Tests if the relation is empty.
</li>
</ul>
<ul>
<li>OP_RA_JOIN: Create the relational join.
</li>
</ul>
<ul>
<li>OP_RA_UNION: Create the union or convex hull of two relations. 

        The function takes two arguments.
</li>
</ul>
<ul>
<li>OP_RA_WIDEN: Widen two relations.

        The function takes two arguments.
</li>
</ul>
<ul>
<li>OP_RA_PROJECT: Project the columns (provided as numbers in the parameters).

        The function takes one argument.
</li>
</ul>
<ul>
<li>OP_RA_FILTER: Filter (restrict) a relation with respect to a predicate.

        The first argument is a relation. 

        The second argument is a predicate with free de-Brujin indices

        corresponding to the columns of the relation.

        So the first column in the relation has index 0.
</li>
</ul>
<ul>
<li>OP_RA_NEGATION_FILTER: Intersect the first relation with respect to negation

        of the second relation (the function takes two arguments).

        Logically, the specification can be described by a function
</li>
</ul>

           target = filter_by_negation(pos, neg, columns)

<p>

        where columns are pairs c1, d1, .., cN, dN of columns from pos and neg, such that

        target are elements in x in pos, such that there is no y in neg that agrees with

        x on the columns c1, d1, .., cN, dN.

<p>
<ul>
<li>OP_RA_RENAME: rename columns in the relation. 

        The function takes one argument.

        The parameters contain the renaming as a cycle.
</li>
</ul>
<ul>
<li>OP_RA_COMPLEMENT: Complement the relation.
</li>
</ul>
<ul>
<li>OP_RA_SELECT: Check if a record is an element of the relation.

        The function takes n+1 arguments, where the first argument is a relation,

        and the remaining n arguments correspond to a record.
</li>
</ul>
<ul>
<li>OP_RA_CLONE: Create a fresh copy (clone) of a relation. 
</li>
</ul>
<ul>
<li>OP_FD_LT: A less than predicate over the finite domain FINITE_DOMAIN_SORT.
</li>
</ul>

    *)<br>
<br>
<span id="2_Createconfiguration"><h2><div align=left>Create configuration</div></h2></span><br>
<pre><span id="VALmk_config"><span class="keyword">val</span> mk_config</span> : <code class="type">unit -> <a href="Z3.html#TYPEconfig">config</a></code></pre><div class="info">
Summary: Create a configuration.

<p>

       Configurations are created in order to assign parameters prior to creating 

       contexts for Z3 interaction. For example, if the users whishes to use model

       generation, then call:

<p>

       <code class="code">set_param_value cfg "MODEL" "true"</code>

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALmk_context_x"><code class="code">Z3.mk_context_x</code></a> instead of using

       explicit configuration objects. The function <a href="Z3.html#VALmk_context_x"><code class="code">Z3.mk_context_x</code></a>

       receives an array of string pairs. This array represents the

       configuration options. 
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALset_param_value"><code class="code">Z3.set_param_value</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALdel_config"><code class="code">Z3.del_config</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALdel_config"><span class="keyword">val</span> del_config</span> : <code class="type"><a href="Z3.html#TYPEconfig">config</a> -> unit</code></pre><div class="info">
Summary: Delete the given configuration object.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALset_param_value"><span class="keyword">val</span> set_param_value</span> : <code class="type"><a href="Z3.html#TYPEconfig">config</a> -> string -> string -> unit</code></pre><div class="info">
Summary: Set a configuration parameter.

<p>

       The list of all configuration parameters can be obtained using the Z3 executable:

<p>

       <pre>

       z3.exe -ini?

       </pre>

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a></li>
</ul>
<br>
</div>
<br>
<span id="2_Createcontext"><h2><div align=left>Create context</div></h2></span><br>
<pre><span id="VALmk_context"><span class="keyword">val</span> mk_context</span> : <code class="type"><a href="Z3.html#TYPEconfig">config</a> -> <a href="Z3.html#TYPEcontext">context</a></code></pre><div class="info">
Summary: Create a context using the given configuration. 

<p>

       After a context is created, the configuration cannot be changed.

       All main interaction with Z3 happens in the context of a context.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALmk_context_x"><code class="code">Z3.mk_context_x</code></a> instead of using

       explicit configuration objects. The function <a href="Z3.html#VALmk_context_x"><code class="code">Z3.mk_context_x</code></a>

       receives an array of string pairs. This array represents the

       configuration options. 
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALdel_context"><code class="code">Z3.del_context</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_context_rc"><span class="keyword">val</span> mk_context_rc</span> : <code class="type"><a href="Z3.html#TYPEconfig">config</a> -> <a href="Z3.html#TYPEcontext">context</a></code></pre><div class="info">
Summary: Create a context using the given configuration.

       This function is similar to <a href="Z3.html#VALmk_context"><code class="code">Z3.mk_context</code></a>. However,

       in the context returned by this function, the user

       is responsible for managing ast reference counters.

       Managing reference counters is a burden and error-prone,

       but allows the user to use the memory more efficiently. 

       The user must invoke <a href="Z3.html#VALinc_ref"><code class="code">Z3.inc_ref</code></a> for any ast returned

       by Z3, and <a href="Z3.html#VALdec_ref"><code class="code">Z3.dec_ref</code></a> whenever the ast is not needed

       anymore. This idiom is similar to the one used in

       BDD (binary decision diagrams) packages such as CUDD.

<p>

       Remark: sort, func_decl, app, pattern are

       ast's.

<p>

       After a context is created, the configuration cannot be changed.

       All main interaction with Z3 happens in the context of a context.<br>
</div>
<pre><span id="VALset_logic"><span class="keyword">val</span> set_logic</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> bool</code></pre><div class="info">
Summary: Set the SMTLIB logic to be used in the given logical context.

       It is incorrect to invoke this function after invoking

       <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a>, <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a>, <a href="Z3.html#VALcheck_assumptions"><code class="code">Z3.check_assumptions</code></a> and <a href="Z3.html#VALpush"><code class="code">Z3.push</code></a>.

       Return TRUE if the logic was changed successfully, and FALSE otherwise.<br>
</div>
<pre><span id="VALdel_context"><span class="keyword">val</span> del_context</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Delete the given logical context.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALinc_ref"><span class="keyword">val</span> inc_ref</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit</code></pre><div class="info">
Summary: Increment the reference counter of the given AST.

       The context c should have been created using <a href="Z3.html#VALmk_context_rc"><code class="code">Z3.mk_context_rc</code></a>.

       This function is a NOOP if c was created using <a href="Z3.html#VALmk_context"><code class="code">Z3.mk_context</code></a>.<br>
</div>
<pre><span id="VALdec_ref"><span class="keyword">val</span> dec_ref</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit</code></pre><div class="info">
Summary: Decrement the reference counter of the given AST.

       The context c should have been created using <a href="Z3.html#VALmk_context_rc"><code class="code">Z3.mk_context_rc</code></a>.

       This function is a NOOP if c was created using <a href="Z3.html#VALmk_context"><code class="code">Z3.mk_context</code></a>.<br>
</div>
<pre><span id="VALtrace_to_file"><span class="keyword">val</span> trace_to_file</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> bool</code></pre><div class="info">
Summary: Enable trace messages to a file

<p>

       When trace messages are enabled, Z3 will record the operations performed on a context in the given file file.

       Return TRUE if the file was opened successfully, and FALSE otherwise.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALtrace_off"><code class="code">Z3.trace_off</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALtrace_to_stderr"><span class="keyword">val</span> trace_to_stderr</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Enable trace messages to a standard error.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALtrace_off"><code class="code">Z3.trace_off</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALtrace_to_stdout"><span class="keyword">val</span> trace_to_stdout</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Enable trace messages to a standard output.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALtrace_off"><code class="code">Z3.trace_off</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALtrace_off"><span class="keyword">val</span> trace_off</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Disable trace messages.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALtrace_to_file"><code class="code">Z3.trace_to_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALtrace_to_stdout"><code class="code">Z3.trace_to_stdout</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALtrace_to_stderr"><code class="code">Z3.trace_to_stderr</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALtoggle_warning_messages"><span class="keyword">val</span> toggle_warning_messages</span> : <code class="type">bool -> unit</code></pre><div class="info">
Summary: Enable/disable printing warning messages to the console.

<p>

       Warnings are printed after passing true, warning messages are

       suppressed after calling this method with false.<br>
</div>
<pre><span id="VALupdate_param_value"><span class="keyword">val</span> update_param_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> string -> unit</code></pre><div class="info">
Summary: Update a mutable configuration parameter.

<p>

       The list of all configuration parameters can be obtained using the Z3 executable:

<p>

       <pre>

       z3.exe -ini?

       </pre>

<p>

       Only a few configuration parameters are mutable once the context is created.

       The error handler is invoked when trying to modify an immutable parameter.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALset_param_value"><code class="code">Z3.set_param_value</code></a></li>
</ul>
<br>
</div>
<br>
Summary: Get a configuration parameter.

<p>

       Returns false if the parameter value does not exist.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALset_param_value"><code class="code">Z3.set_param_value</code></a></li>
</ul>
<br>
<br>
<span id="2_Symbols"><h2><div align=left>Symbols</div></h2></span><br>
<pre><span id="VALmk_int_symbol"><span class="keyword">val</span> mk_int_symbol</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Create a Z3 symbol using an integer.

<p>

       Symbols are used to name several term and type constructors.

<p>

       NB. Not all integers can be passed to this function.

       The legal range of unsigned int integers is 0 to 2^30-1.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_string_symbol"><code class="code">Z3.mk_string_symbol</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_string_symbol"><span class="keyword">val</span> mk_string_symbol</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Create a Z3 symbol using a C string.

<p>

       Symbols are used to name several term and type constructors.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_int_symbol"><code class="code">Z3.mk_int_symbol</code></a></li>
</ul>
<br>
</div>
<br>
<span id="2_Sorts"><h2><div align=left>Sorts</div></h2></span><br>
<pre><span id="VALis_eq_sort"><span class="keyword">val</span> is_eq_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a> -> bool</code></pre><div class="info">
Summary: compare sorts.<br>
</div>
<pre><span id="VALmk_uninterpreted_sort"><span class="keyword">val</span> mk_uninterpreted_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create a free (uninterpreted) type using the given name (symbol).

<p>

       Two free types are considered the same iff the have the same name.<br>
</div>
<pre><span id="VALmk_bool_sort"><span class="keyword">val</span> mk_bool_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create the Boolean type. 

<p>

       This type is used to create propositional variables and predicates.<br>
</div>
<pre><span id="VALmk_int_sort"><span class="keyword">val</span> mk_int_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create an integer type.

<p>

       This type is not the int type found in programming languages.

       A machine integer can be represented using bit-vectors. The function

       <a href="Z3.html#VALmk_bv_sort"><code class="code">Z3.mk_bv_sort</code></a> creates a bit-vector type.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_bv_sort"><code class="code">Z3.mk_bv_sort</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_real_sort"><span class="keyword">val</span> mk_real_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create a real type. 

<p>

       This type is not a floating point number.

       Z3 does not have support for floating point numbers yet.<br>
</div>
<pre><span id="VALmk_bv_sort"><span class="keyword">val</span> mk_bv_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create a bit-vector type of the given size.

<p>

       This type can also be seen as a machine integer.

<p>
<ul>
<li><b>Remarks</b>: The size of the bitvector type must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_array_sort"><span class="keyword">val</span> mk_array_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create an array type. 

<p>

       We usually represent the array type as: <em><code class="code">domain -&gt; range</code> </em>.

       Arrays are usually used to model the heap/memory in software verification.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_select"><code class="code">Z3.mk_select</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_store"><code class="code">Z3.mk_store</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_tuple_sort"><span class="keyword">val</span> mk_tuple_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
Summary: Create a tuple type.

<p>

        <code class="code">mk_tuple_sort c name field_names field_sorts</code> creates a tuple with a constructor named <code class="code">name</code>,

       a <code class="code">n</code> fields, where <code class="code">n</code> is the size of the arrays <code class="code">field_names</code> and <code class="code">field_sorts</code>.<br>
</div>
<pre><span id="VALmk_enumeration_sort"><span class="keyword">val</span> mk_enumeration_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
Summary: Create a enumeration sort.

<p>

        <code class="code">mk_enumeration_sort c enums</code> creates an enumeration sort with enumeration names <code class="code">enums</code>, 

               it also returns <code class="code">n</code> predicates, where <code class="code">n</code> is the number of <code class="code">enums</code> corresponding

               to testing whether an element is one of the enumerants.<br>
</div>
<pre><span id="VALmk_list_sort"><span class="keyword">val</span> mk_list_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsort">sort</a> -><br>       <a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> *<br>       <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Create a list sort

<p>

        <code class="code">mk_list_sort c name elem_sort</code> creates a list sort of <code class="code">name</code>, over elements of sort <code class="code">elem_sort</code>.<br>
</div>
<pre><span id="VALmk_constructor"><span class="keyword">val</span> mk_constructor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEsort">sort</a> array -> int array -> <a href="Z3.html#TYPEconstructor">constructor</a></code></pre><div class="info">
Summary: Create a constructor.

<p>

                        sort reference is 0, then the value in sort_refs should be an index referring to 

                        one of the recursive datatypes that is declared.<br>
</div>
<pre><span id="VALquery_constructor"><span class="keyword">val</span> query_constructor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEconstructor">constructor</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
Summary: Query constructor for declared funcions.<br>
</div>
<pre><span id="VALdel_constructor"><span class="keyword">val</span> del_constructor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEconstructor">constructor</a> -> unit</code></pre><div class="info">
Summary: Reclaim memory allocated to constructor.<br>
</div>
<pre><span id="VALmk_datatype"><span class="keyword">val</span> mk_datatype</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEconstructor">constructor</a> array -> <a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEconstructor">constructor</a> array</code></pre><div class="info">
Summary: Create recursive datatype. Return the datatype sort.<br>
</div>
<pre><span id="VALmk_constructor_list"><span class="keyword">val</span> mk_constructor_list</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEconstructor">constructor</a> array -> <a href="Z3.html#TYPEconstructor_list">constructor_list</a></code></pre><div class="info">
Summary: Create list of constructors.<br>
</div>
<pre><span id="VALdel_constructor_list"><span class="keyword">val</span> del_constructor_list</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEconstructor_list">constructor_list</a> -> unit</code></pre><div class="info">
Summary: reclaim memory allocated for constructor list.

<p>

       Each constructor inside the constructor list must be independently reclaimed using <a href="Z3.html#VALdel_constructor"><code class="code">Z3.del_constructor</code></a>.<br>
</div>
<pre><span id="VALmk_datatypes"><span class="keyword">val</span> mk_datatypes</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEconstructor_list">constructor_list</a> array -> <a href="Z3.html#TYPEsort">sort</a> array * <a href="Z3.html#TYPEconstructor_list">constructor_list</a> array</code></pre><div class="info">
Summary: Create mutually recursive datatypes.<br>
</div>
<br>
<span id="2_Injectivefunctions"><h2><div align=left>Injective functions</div></h2></span><br>
<pre><span id="VALmk_injective_function"><span class="keyword">val</span> mk_injective_function</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Create injective function declaration<br>
</div>
<br>
<span id="2_ConstantsandApplications"><h2><div align=left>Constants and Applications</div></h2></span><br>
<pre><span id="VALis_eq_ast"><span class="keyword">val</span> is_eq_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool</code></pre><div class="info">
Summary: compare terms.<br>
</div>
<pre><span id="VALis_eq_func_decl"><span class="keyword">val</span> is_eq_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> bool</code></pre><div class="info">
Summary: compare terms.<br>
</div>
<pre><span id="VALmk_func_decl"><span class="keyword">val</span> mk_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Declare a constant or function.

<p>

        <code class="code">mk_func_decl c n d r</code> creates a function with name <code class="code">n</code>, domain <code class="code">d</code>, and range <code class="code">r</code>.

       The arity of the function is the size of the array <code class="code">d</code>. 

<p>

       After declaring a constant or function, the function

       <a href="Z3.html#VALmk_app"><code class="code">Z3.mk_app</code></a> can be used to create a constant or function

       application.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_app"><code class="code">Z3.mk_app</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_app"><span class="keyword">val</span> mk_app</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a constant or function application.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_func_decl"><code class="code">Z3.mk_func_decl</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_const"><span class="keyword">val</span> mk_const</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Declare and create a constant.

<p>

        <code class="code">mk_const c s t</code> is a shorthand for <code class="code">mk_app c (mk_func_decl c s [||] t) [||]</code> 

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_func_decl"><code class="code">Z3.mk_func_decl</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_app"><code class="code">Z3.mk_app</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_label"><span class="keyword">val</span> mk_label</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> bool -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a labeled formula.

<p>

       A label behaves as an identity function, so the truth value of the 

       labeled formula is unchanged. Labels are used for identifying 

       useful sub-formulas when generating counter-examples.<br>
</div>
<pre><span id="VALmk_fresh_func_decl"><span class="keyword">val</span> mk_fresh_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Declare a fresh constant or function.

<p>

       Z3 will generate an unique name for this function declaration.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_func_decl"><code class="code">Z3.mk_func_decl</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_fresh_const"><span class="keyword">val</span> mk_fresh_const</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Declare and create a fresh constant.

<p>

        <code class="code">mk_fresh_const c p t</code> is a shorthand for <code class="code">mk_app c (mk_fresh_func_decl c p [||] t) [||]</code>. 

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_func_decl"><code class="code">Z3.mk_func_decl</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_app"><code class="code">Z3.mk_app</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_true"><span class="keyword">val</span> mk_true</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create an AST node representing true.<br>
</div>
<pre><span id="VALmk_false"><span class="keyword">val</span> mk_false</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create an AST node representing false.<br>
</div>
<pre><span id="VALmk_eq"><span class="keyword">val</span> mk_eq</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_eq c l r </code> ]

        Create an AST node representing <em>l = r </em>.

<p>

        The nodes l and r must have the same type.<br>
</div>
<pre><span id="VALmk_distinct"><span class="keyword">val</span> mk_distinct</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_distinct c [| t_1; ...; t_n |]</code> ] Create an AST

       node represeting a distinct construct. It is used for declaring

       the arguments t_i pairwise distinct. 

<p>

       All arguments must have the same sort.

<p>
<ul>
<li><b>Remarks</b>: The number of arguments of a distinct construct must be greater than one.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_not"><span class="keyword">val</span> mk_not</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_not c a </code> ] 

        Create an AST node representing <em>not(a) </em>.

<p>

        The node a must have Boolean sort.<br>
</div>
<pre><span id="VALmk_ite"><span class="keyword">val</span> mk_ite</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_ite c t1 t2 t2 </code> ] 

       Create an AST node representing an if-then-else: <em>ite(t1, t2,

       t3) </em>.

<p>

       The node t1 must have Boolean sort, t2 and t3 must have the same sort.

       The sort of the new node is equal to the sort of t2 and t3.<br>
</div>
<pre><span id="VALmk_iff"><span class="keyword">val</span> mk_iff</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_iff c t1 t2 </code> ]

       Create an AST node representing <em>t1 iff t2 </em>.

<p>

       The nodes t1 and t2 must have Boolean sort.<br>
</div>
<pre><span id="VALmk_implies"><span class="keyword">val</span> mk_implies</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_implies c t1 t2 </code> ]

       Create an AST node representing <em>t1 implies t2 </em>.

<p>

       The nodes t1 and t2 must have Boolean sort.<br>
</div>
<pre><span id="VALmk_xor"><span class="keyword">val</span> mk_xor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_xor c t1 t2 </code> ]

       Create an AST node representing <em>t1 xor t2 </em>.

<p>

       The nodes t1 and t2 must have Boolean sort.<br>
</div>
<pre><span id="VALmk_and"><span class="keyword">val</span> mk_and</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_and c [| t_1; ...; t_n |]</code> ] Create the conjunction: <em>t_1 and ... and t_n</em>. 

<p>

       All arguments must have Boolean sort.

<p>
<ul>
<li><b>Remarks</b>: The number of arguments must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_or"><span class="keyword">val</span> mk_or</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_or c [| t_1; ...; t_n |]</code> ] Create the disjunction: <em>t_1 or ... or t_n</em>. 

<p>

       All arguments must have Boolean sort.

<p>
<ul>
<li><b>Remarks</b>: The number of arguments must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_add"><span class="keyword">val</span> mk_add</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_add c [| t_1; ...; t_n |]</code> ] Create the term: <em>t_1 + ... + t_n</em>. 

<p>

       All arguments must have int or real sort.

<p>
<ul>
<li><b>Remarks</b>: The number of arguments must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_mul"><span class="keyword">val</span> mk_mul</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_mul c [| t_1; ...; t_n |]</code> ] Create the term: <em>t_1 * ... * t_n</em>. 

<p>

       All arguments must have int or real sort.

<p>
<ul>
<li><b>Remarks</b>: Z3 has limited support for non-linear arithmetic.
</li>
<li><b>Remarks</b>: The number of arguments must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_sub"><span class="keyword">val</span> mk_sub</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_sub c [| t_1; ...; t_n |]</code> ] Create the term: <em>t_1 - ... - t_n</em>. 

<p>

       All arguments must have int or real sort.

<p>
<ul>
<li><b>Remarks</b>: The number of arguments must be greater than zero.</li>
</ul>
<br>
</div>
<pre><span id="VALmk_unary_minus"><span class="keyword">val</span> mk_unary_minus</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_unary_minus c arg</code> ] Create the term: <em>- arg</em>. 

<p>

       The argument must have int or real type.<br>
</div>
<pre><span id="VALmk_div"><span class="keyword">val</span> mk_div</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_div c t_1 t_2</code> ] Create the term: <em>t_1 div t_2</em>. 

<p>

       The arguments must either both have int type or both have real type.

       If the arguments have int type, then the result type is an int type, otherwise the

       the result type is real.<br>
</div>
<pre><span id="VALmk_mod"><span class="keyword">val</span> mk_mod</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_mod c t_1 t_2</code> ] Create the term: <em>t_1 mod t_2</em>. 

<p>

       The arguments must have int type.<br>
</div>
<pre><span id="VALmk_rem"><span class="keyword">val</span> mk_rem</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code">mk_rem c t_1 t_2</code> ] Create the term: <em>t_1 rem t_2</em>. 

<p>

       The arguments must have int type.<br>
</div>
<pre><span id="VALmk_lt"><span class="keyword">val</span> mk_lt</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_lt c t1 t2 </code> ] 

        Create less than.

<p>

        The nodes t1 and t2 must have the same sort, and must be int or real.<br>
</div>
<pre><span id="VALmk_le"><span class="keyword">val</span> mk_le</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_le c t1 t2 </code> ]

        Create less than or equal to.

<p>

        The nodes t1 and t2 must have the same sort, and must be int or real.<br>
</div>
<pre><span id="VALmk_gt"><span class="keyword">val</span> mk_gt</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_gt c t1 t2 </code> ]

        Create greater than.

<p>

        The nodes t1 and t2 must have the same sort, and must be int or real.<br>
</div>
<pre><span id="VALmk_ge"><span class="keyword">val</span> mk_ge</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_ge c t1 t2 </code> ]

        Create greater than or equal to.

<p>

        The nodes t1 and t2 must have the same sort, and must be int or real.<br>
</div>
<pre><span id="VALmk_int2real"><span class="keyword">val</span> mk_int2real</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_int2real c t1 </code> ]

        Coerce an integer to a real.

<p>

        There is also a converse operation exposed.

        It follows the semantics prescribed by the SMT-LIB standard.

<p>

        You can take the floor of a real by 

        creating an auxiliary integer constant k and

        and asserting <em> mk_int2real(k) &lt;= t1 &lt; mk_int2real(k)+1 </em>.

<p>

        The node t1 must have sort integer.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_real2int"><code class="code">Z3.mk_real2int</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_is_int"><code class="code">Z3.mk_is_int</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_real2int"><span class="keyword">val</span> mk_real2int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_real2int c t1 </code> ]

        Coerce a real to an integer.

<p>

        The semantics of this function follows the SMT-LIB standard

        for the function to_int

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_int2real"><code class="code">Z3.mk_int2real</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_is_int"><code class="code">Z3.mk_is_int</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_is_int"><span class="keyword">val</span> mk_is_int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_is_int c t1 </code> ]

        Check if a real number is an integer.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_int2real"><code class="code">Z3.mk_int2real</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_real2int"><code class="code">Z3.mk_real2int</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_bvnot"><span class="keyword">val</span> mk_bvnot</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvnot c t1 </code> ]

       Bitwise negation.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvredand"><span class="keyword">val</span> mk_bvredand</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvredand c t1 </code> ]

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

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvredor"><span class="keyword">val</span> mk_bvredor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvredor c t1 </code> ]

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

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvand"><span class="keyword">val</span> mk_bvand</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvand c t1 t2 </code> ]

       Bitwise and.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvor"><span class="keyword">val</span> mk_bvor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvor c t1 t2 </code> ]

       Bitwise or.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvxor"><span class="keyword">val</span> mk_bvxor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvxor c t1 t2 </code> ]

       Bitwise exclusive-or.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvnand"><span class="keyword">val</span> mk_bvnand</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvnand c t1 t2 </code> ]

       Bitwise nand. 

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvnor"><span class="keyword">val</span> mk_bvnor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvnor c t1 t2 </code> ]

       Bitwise nor. 

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvxnor"><span class="keyword">val</span> mk_bvxnor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvxnor c t1 t2 </code> ]

       Bitwise xnor. 

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvneg"><span class="keyword">val</span> mk_bvneg</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvneg c t1 </code> ]

       Standard two's complement unary minus. 

<p>

       The node t1 must have bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvadd"><span class="keyword">val</span> mk_bvadd</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvadd c t1 t2 </code> ]

        Standard two's complement addition.

<p>

        The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsub"><span class="keyword">val</span> mk_bvsub</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsub c t1 t2 </code> ]

        Standard two's complement subtraction.

<p>

        The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvmul"><span class="keyword">val</span> mk_bvmul</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvmul c t1 t2 </code> ]

        Standard two's complement multiplication.

<p>

        The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvudiv"><span class="keyword">val</span> mk_bvudiv</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvudiv c t1 t2 </code> ]

        Unsigned division. 

<p>

        It is defined as the floor of <em>t1/t2 </em> if t2 is

        different from zero. If <em>t2 </em> is zero, then the result

        is undefined.

<p>

        The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsdiv"><span class="keyword">val</span> mk_bvsdiv</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsdiv c t1 t2 </code> ]

        Two's complement signed division. 

<p>

        It is defined in the following way:

<p>
<ul>
<li>The floor of <em>t1/t2 </em> if t2 is different from zero, and <em>t1*t2 &gt;= 0 </em>.
</li>
</ul>
<ul>
<li>The ceiling of <em>t1/t2 </em> if t2 is different from zero, and <em>t1*t2 &lt; 0 </em>.
</li>
</ul>

        If <em>t2 </em> is zero, then the result is undefined.

<p>

        The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvurem"><span class="keyword">val</span> mk_bvurem</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvurem c t1 t2 </code> ]

       Unsigned remainder.

<p>

       It is defined as <em>t1 - (t1 /u t2) * t2 </em>, where <em>/u </em> represents unsigned int division.

<p>

       If <em>t2 </em> is zero, then the result is undefined.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsrem"><span class="keyword">val</span> mk_bvsrem</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsrem c t1 t2 </code> ]

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

<p>

       It is defined as <em>t1 - (t1 /s t2) * t2 </em>, where <em>/s </em> represents signed division.

       The most significant bit (sign) of the result is equal to the most significant bit of t1.

<p>

       If <em>t2 </em> is zero, then the result is undefined.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_bvsmod"><code class="code">Z3.mk_bvsmod</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_bvsmod"><span class="keyword">val</span> mk_bvsmod</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsmod c t1 t2 </code> ]

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

<p>

       If <em>t2 </em> is zero, then the result is undefined.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_bvsrem"><code class="code">Z3.mk_bvsrem</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_bvult"><span class="keyword">val</span> mk_bvult</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvult c t1 t2 </code> ]

       Unsigned less than.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvslt"><span class="keyword">val</span> mk_bvslt</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvslt c t1 t2 </code> ]

       Two's complement signed less than.

<p>

       It abbreviates:

       <pre>

      (or (and (= (extract[|m-1|:|m-1|] t1) bit1)

               (= (extract[|m-1|:|m-1|] t2) bit0))

          (and (= (extract[|m-1|:|m-1|] t1) (extract[|m-1|:|m-1|] t2))

               (bvult t1 t2)))

       </pre>

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvule"><span class="keyword">val</span> mk_bvule</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvule c t1 t2 </code> ]

       Unsigned less than or equal to.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsle"><span class="keyword">val</span> mk_bvsle</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsle c t1 t2 </code> ]

       Two's complement signed less than or equal to.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvuge"><span class="keyword">val</span> mk_bvuge</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvuge c t1 t2 </code> ]

       Unsigned greater than or equal to.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsge"><span class="keyword">val</span> mk_bvsge</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsge c t1 t2 </code> ]

       Two's complement signed greater than or equal to.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvugt"><span class="keyword">val</span> mk_bvugt</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvugt c t1 t2 </code> ]

       Unsigned greater than.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsgt"><span class="keyword">val</span> mk_bvsgt</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsgt c t1 t2 </code> ]

       Two's complement signed greater than.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_concat"><span class="keyword">val</span> mk_concat</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_concat c t1 t2 </code> ]

       Concatenate the given bit-vectors.

<p>

       The nodes t1 and t2 must have (possibly different) bit-vector sorts

<p>

       The result is a bit-vector of size <em>n1+n2 </em>, where n1 (n2) is the size

       of t1 (t2).<br>
</div>
<pre><span id="VALmk_extract"><span class="keyword">val</span> mk_extract</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_extract c high low t1 </code> ]

       Extract the bits high down to low from a bitvector of

       size m to yield a new bitvector of size n, where <em>n =

       high - low + 1 </em>.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_sign_ext"><span class="keyword">val</span> mk_sign_ext</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_sign_ext c i t1 </code> ]

       Sign-extend of the given bit-vector to the (signed) equivalent bitvector of

       size <em>m+i </em>, where m is the size of the given

       bit-vector.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_zero_ext"><span class="keyword">val</span> mk_zero_ext</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_zero_ext c i t1 </code> ]

       Extend the given bit-vector with zeros to the (unsigned int) equivalent

       bitvector of size <em>m+i </em>, where m is the size of the

       given bit-vector.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_repeat"><span class="keyword">val</span> mk_repeat</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_repeat c i t1 </code> ]

       Repeat the given bit-vector up length <em>i </em>.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvshl"><span class="keyword">val</span> mk_bvshl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvshl c t1 t2 </code> ]

       Shift left.

<p>

       It is equivalent to multiplication by <em>2^x </em> where x is the value of the

       third argument.

<p>

       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.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvlshr"><span class="keyword">val</span> mk_bvlshr</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvlshr c t1 t2 </code> ]

       Logical shift right.

<p>

       It is equivalent to unsigned int division by <em>2^x </em> where x is the

       value of the third argument.

<p>

       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.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvashr"><span class="keyword">val</span> mk_bvashr</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvashr c t1 t2 </code> ]

       Arithmetic shift right.

<p>

       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.

<p>

       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.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_rotate_left"><span class="keyword">val</span> mk_rotate_left</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_rotate_left c i t1 </code> ]

       Rotate bits of t1 to the left i times.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_rotate_right"><span class="keyword">val</span> mk_rotate_right</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_rotate_right c i t1 </code> ]

       Rotate bits of t1 to the right i times.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_ext_rotate_left"><span class="keyword">val</span> mk_ext_rotate_left</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_ext_rotate_left c t1 t2 </code> ]

       Rotate bits of t1 to the left t2 times.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_ext_rotate_right"><span class="keyword">val</span> mk_ext_rotate_right</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_ext_rotate_right c t1 t2 </code> ]

       Rotate bits of t1 to the right t2 times.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_int2bv"><span class="keyword">val</span> mk_int2bv</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_int2bv c n t1 </code> ]

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

<p>

       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.

<p>

       The node t1 must have integer sort.<br>
</div>
<pre><span id="VALmk_bv2int"><span class="keyword">val</span> mk_bv2int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bv2int c t1 is_signed </code> ]

       Create an integer from the bit-vector argument t1.

       If is_signed is false, then the bit-vector t1 is treated as unsigned int. 

       So the result is non-negative

       and in the range <em><code class="code">0..2^N-1</code> </em>, where N are the number of bits in t1.

       If is_signed is true, t1 is treated as a signed bit-vector.

<p>

       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.

<p>

       The node t1 must have a bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvadd_no_overflow"><span class="keyword">val</span> mk_bvadd_no_overflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvadd_no_overflow c t1 t2 is_signed </code> ]

       Create a predicate that checks that the bit-wise addition

       of t1 and t2 does not overflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvadd_no_underflow"><span class="keyword">val</span> mk_bvadd_no_underflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvadd_no_underflow c t1 t2 </code> ]

       Create a predicate that checks that the bit-wise signed addition

       of t1 and t2 does not underflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsub_no_overflow"><span class="keyword">val</span> mk_bvsub_no_overflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsub_no_overflow c t1 t2 </code> ]

       Create a predicate that checks that the bit-wise signed subtraction

       of t1 and t2 does not overflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsub_no_underflow"><span class="keyword">val</span> mk_bvsub_no_underflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsub_no_underflow c t1 t2 is_signed </code> ]

       Create a predicate that checks that the bit-wise subtraction

       of t1 and t2 does not underflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvsdiv_no_overflow"><span class="keyword">val</span> mk_bvsdiv_no_overflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvsdiv_no_overflow c t1 t2 </code> ]

       Create a predicate that checks that the bit-wise signed division 

       of t1 and t2 does not overflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvneg_no_overflow"><span class="keyword">val</span> mk_bvneg_no_overflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvneg_no_overflow c t1 </code> ]

       Check that bit-wise negation does not overflow when 

       t1 is interpreted as a signed bit-vector.

<p>

       The node t1 must have bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvmul_no_overflow"><span class="keyword">val</span> mk_bvmul_no_overflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvmul_no_overflow c t1 t2 is_signed </code> ]

       Create a predicate that checks that the bit-wise multiplication

       of t1 and t2 does not overflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_bvmul_no_underflow"><span class="keyword">val</span> mk_bvmul_no_underflow</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_bvmul_no_underflow c t1 t2 </code> ]

       Create a predicate that checks that the bit-wise signed multiplication

       of t1 and t2 does not underflow.

<p>

       The nodes t1 and t2 must have the same bit-vector sort.<br>
</div>
<pre><span id="VALmk_select"><span class="keyword">val</span> mk_select</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_select c a i </code> ]

       Array read.

<p>

       The node a must have an array sort <em><code class="code">domain -&gt; range</code> </em>, and i must have the sort domain.

       The sort of the result is range.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_array_sort"><code class="code">Z3.mk_array_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_store"><code class="code">Z3.mk_store</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_store"><span class="keyword">val</span> mk_store</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_store c a i v </code> ]

       Array update.

<p>

       The node a must have an array sort <em><code class="code">domain -&gt; range</code> </em>, i must have sort domain,

       v must have sort range. The sort of the result is <em><code class="code">domain -&gt; range</code> </em>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_array_sort"><code class="code">Z3.mk_array_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_select"><code class="code">Z3.mk_select</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_const_array"><span class="keyword">val</span> mk_const_array</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create the constant array.<br>
</div>
<pre><span id="VALmk_map"><span class="keyword">val</span> mk_map</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> mk_map f n args </code> ]

       map f on the the argument arrays.

<p>

       The n nodes args must be of array sorts <em><code class="code">domain_i -&gt; range_i</code> </em>.

       The function declaration f must have type <em> range_1 .. range_n -&gt; range </em>.

       v must have sort range. The sort of the result is <em><code class="code">domain_i -&gt; range</code> </em>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_array_sort"><code class="code">Z3.mk_array_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_store"><code class="code">Z3.mk_store</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_select"><code class="code">Z3.mk_select</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_array_default"><span class="keyword">val</span> mk_array_default</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Access the array default value.

        Produces the default range value, for arrays that can be represented as 

        finite maps with a default range value.<br>
</div>
<br>
<span id="2_Sets"><h2><div align=left>Sets</div></h2></span><br>
<pre><span id="VALmk_set_sort"><span class="keyword">val</span> mk_set_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create Set type.<br>
</div>
<pre><span id="VALmk_empty_set"><span class="keyword">val</span> mk_empty_set</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create the empty set.<br>
</div>
<pre><span id="VALmk_full_set"><span class="keyword">val</span> mk_full_set</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create the full set.<br>
</div>
<pre><span id="VALmk_set_add"><span class="keyword">val</span> mk_set_add</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Add an element to a set.

<p>

       The first argument must be a set, the second an element.<br>
</div>
<pre><span id="VALmk_set_del"><span class="keyword">val</span> mk_set_del</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Remove an element to a set.

<p>

       The first argument must be a set, the second an element.<br>
</div>
<pre><span id="VALmk_set_union"><span class="keyword">val</span> mk_set_union</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Take the union of a list of sets.<br>
</div>
<pre><span id="VALmk_set_intersect"><span class="keyword">val</span> mk_set_intersect</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Take the intersection of a list of sets.<br>
</div>
<pre><span id="VALmk_set_difference"><span class="keyword">val</span> mk_set_difference</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Take the set difference between two sets.<br>
</div>
<pre><span id="VALmk_set_complement"><span class="keyword">val</span> mk_set_complement</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Take the complement of a set.<br>
</div>
<pre><span id="VALmk_set_member"><span class="keyword">val</span> mk_set_member</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Check for set membership.

<p>

       The first argument should be an element type of the set.<br>
</div>
<pre><span id="VALmk_set_subset"><span class="keyword">val</span> mk_set_subset</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Check for subsetness of sets.<br>
</div>
<br>
<span id="2_Numerals"><h2><div align=left>Numerals</div></h2></span><br>
<pre><span id="VALmk_numeral"><span class="keyword">val</span> mk_numeral</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a numeral of a given sort. 

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_int"><code class="code">Z3.mk_int</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_unsigned_int"><code class="code">Z3.mk_unsigned_int</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_real"><span class="keyword">val</span> mk_real</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a real from a fraction.

<p>
<ul>
<li><b>Precondition</b>: den != 0
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_numeral"><code class="code">Z3.mk_numeral</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_int"><code class="code">Z3.mk_int</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_unsigned_int"><code class="code">Z3.mk_unsigned_int</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_int"><span class="keyword">val</span> mk_int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a numeral of a given sort. 

<p>

       This function can be use to create numerals that fit in a machine integer.

       It is slightly faster than <a href="Z3.html#VALmk_numeral"><code class="code">Z3.mk_numeral</code></a> since it is not necessary to parse a string.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_numeral"><code class="code">Z3.mk_numeral</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_unsigned_int"><span class="keyword">val</span> mk_unsigned_int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a numeral of a given sort. 

<p>

       This function can be use to create numerals that fit in a machine unsinged integer.

       It is slightly faster than <a href="Z3.html#VALmk_numeral"><code class="code">Z3.mk_numeral</code></a> since it is not necessary to parse a string.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_numeral"><code class="code">Z3.mk_numeral</code></a></li>
</ul>
<br>
</div>
<br>
<span id="2_Quantifiers"><h2><div align=left>Quantifiers</div></h2></span><br>
<pre><span id="VALmk_pattern"><span class="keyword">val</span> mk_pattern</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEpattern">pattern</a></code></pre><div class="info">
Summary: Create a pattern for quantifier instantiation.

<p>

       Z3 uses pattern matching to instantiate quantifiers. If a

       pattern is not provided for a quantifier, then Z3 will

       automatically compute a set of patterns for it. However, for

       optimal performance, the user should provide the patterns.

<p>

       Patterns comprise a list of terms. The list should be

       non-empty.  If the list comprises of more than one term, it is

       a called a multi-pattern.

<p>

       In general, one can pass in a list of (multi-)patterns in the

       quantifier constructor.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists"><code class="code">Z3.mk_exists</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_bound"><span class="keyword">val</span> mk_bound</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a bound variable.

<p>

       Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain

       the meaning of de-Bruijn indices by indicating the compilation process from

       non-de-Bruijn formulas to de-Bruijn format.

<p>

       <pre> 

       abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0)

       abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi))

       abs1(x, x, n) = b_n

       abs1(y, x, n) = y

       abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n))

       abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1))

       </pre>

<p>

       The last line is significant: the index of a bound variable is different depending

       on the scope in which it appears. The deeper x appears, the higher is its

       index.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists"><code class="code">Z3.mk_exists</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_forall"><span class="keyword">val</span> mk_forall</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       int -><br>       <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a forall formula.

<p>

        <code class="code">mk_forall c w p t n b</code> creates a forall formula, where

       <code class="code">w</code> is the weight, <code class="code">p</code> is an array of patterns, <code class="code">t</code> is an array

       with the sorts of the bound variables, <code class="code">n</code> is an array with the

       'names' of the bound variables, and <code class="code">b</code> is the body of the

       quantifier. Quantifiers are associated with weights indicating

       the importance of using the quantifier during

       instantiation. 

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_bound"><code class="code">Z3.mk_bound</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists"><code class="code">Z3.mk_exists</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_exists"><span class="keyword">val</span> mk_exists</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       int -><br>       <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create an exists formula. Similar to <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_bound"><code class="code">Z3.mk_bound</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_quantifier"><span class="keyword">val</span> mk_quantifier</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       bool -><br>       int -><br>       <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a quantifier - universal or existential, with pattern hints.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_bound"><code class="code">Z3.mk_bound</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists"><code class="code">Z3.mk_exists</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_quantifier_ex"><span class="keyword">val</span> mk_quantifier_ex</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       bool -><br>       int -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEpattern">pattern</a> array -><br>       <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a quantifier - universal or existential, with pattern hints, no patterns, and attributes

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_bound"><code class="code">Z3.mk_bound</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall"><code class="code">Z3.mk_forall</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists"><code class="code">Z3.mk_exists</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_forall_const"><span class="keyword">val</span> mk_forall_const</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEapp">app</a> array -> <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a universal quantifier using a list of constants that

       will form the set of bound variables.

<p>

              the quantifier during instantiation. By default, pass the weight 0.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_exists_const"><code class="code">Z3.mk_exists_const</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_exists_const"><span class="keyword">val</span> mk_exists_const</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEapp">app</a> array -> <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Similar to <a href="Z3.html#VALmk_forall_const"><code class="code">Z3.mk_forall_const</code></a>.

<p>

       Summary: Create an existential quantifier using a list of constants that

       will form the set of bound variables.

<p>

              the quantifier during instantiation. By default, pass the weight 0.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_pattern"><code class="code">Z3.mk_pattern</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALmk_forall_const"><code class="code">Z3.mk_forall_const</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_quantifier_const"><span class="keyword">val</span> mk_quantifier_const</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       bool -> int -> <a href="Z3.html#TYPEapp">app</a> array -> <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a universal or existential 

       quantifier using a list of constants that

       will form the set of bound variables.<br>
</div>
<pre><span id="VALmk_quantifier_const_ex"><span class="keyword">val</span> mk_quantifier_const_ex</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       bool -><br>       int -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> -><br>       <a href="Z3.html#TYPEapp">app</a> array -> <a href="Z3.html#TYPEpattern">pattern</a> array -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create a universal or existential 

       quantifier using a list of constants that

       will form the set of bound variables.<br>
</div>
<br>
<span id="2_Accessors"><h2><div align=left>Accessors</div></h2></span><br>
<pre><span id="VALget_ast_id"><span class="keyword">val</span> get_ast_id</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return a unique identifier for t.<br>
</div>
<pre><span id="VALget_func_decl_id"><span class="keyword">val</span> get_func_decl_id</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int</code></pre><div class="info">
Summary: Return a unique identifier for f.<br>
</div>
<pre><span id="VALget_sort_id"><span class="keyword">val</span> get_sort_id</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int</code></pre><div class="info">
Summary: Return a unique identifier for s.<br>
</div>
<pre><span id="VALis_well_sorted"><span class="keyword">val</span> is_well_sorted</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool</code></pre><div class="info">
Summary: Return true if the given expression t is well sorted.<br>
</div>
<pre><span id="VALget_symbol_kind"><span class="keyword">val</span> get_symbol_kind</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsymbol_kind">symbol_kind</a></code></pre><div class="info">
Summary: Return INT_SYMBOL if the symbol was constructed

       using <a href="Z3.html#VALmk_int_symbol"><code class="code">Z3.mk_int_symbol</code></a>, and STRING_SYMBOL if the symbol

       was constructed using <a href="Z3.html#VALmk_string_symbol"><code class="code">Z3.mk_string_symbol</code></a>.<br>
</div>
<pre><span id="VALget_symbol_int"><span class="keyword">val</span> get_symbol_int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_symbol_int c s </code> ]

       Return the symbol int value. 

<p>
<ul>
<li><b>Precondition</b>: get_symbol_kind s == INT_SYMBOL
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_int_symbol"><code class="code">Z3.mk_int_symbol</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_symbol_string"><span class="keyword">val</span> get_symbol_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> string</code></pre><div class="info">
Summary: [ <code class="code"> get_symbol_string c s </code> ]

       Return the symbol name. 

<p>
<ul>
<li><b>Precondition</b>: get_symbol_string s == STRING_SYMBOL
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_string_symbol"><code class="code">Z3.mk_string_symbol</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_ast_kind"><span class="keyword">val</span> get_ast_kind</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast_kind">ast_kind</a></code></pre><div class="info">
Summary: Return the kind of the given AST.<br>
</div>
<pre><span id="VALget_numeral_string"><span class="keyword">val</span> get_numeral_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> string</code></pre><div class="info">
Summary: Return numeral value, as a string of a numeric constant term

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind c a == NUMERAL_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_numeral_small"><span class="keyword">val</span> get_numeral_small</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool * int64 * int64</code></pre><div class="info">
Summary: Return numeral value, as a pair of 64 bit numbers if the representation fits.

<p>

       Preturn TRUE if the numeral value fits in 64 bit numerals, FALSE otherwise.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == NUMERAL_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_numeral_int"><span class="keyword">val</span> get_numeral_int</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool * int</code></pre><div class="info">
Summary: [ <code class="code"> get_numeral_int c v </code> ]

       Similar to <a href="Z3.html#VALget_numeral_string"><code class="code">Z3.get_numeral_string</code></a>, but only succeeds if

       the value can fit in a machine int. Return TRUE if the call succeeded.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind c v == NUMERAL_AST
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_numeral_string"><code class="code">Z3.get_numeral_string</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_numeral_uint"><span class="keyword">val</span> get_numeral_uint</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool * int</code></pre><div class="info">
Summary: [ <code class="code"> get_numeral_uint c v </code> ]

       Similar to <a href="Z3.html#VALget_numeral_string"><code class="code">Z3.get_numeral_string</code></a>, but only succeeds if

       the value can fit in a machine unsigned int int. Return TRUE if the call succeeded.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind c v == NUMERAL_AST
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_numeral_string"><code class="code">Z3.get_numeral_string</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_bool_value"><span class="keyword">val</span> get_bool_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPElbool">lbool</a></code></pre><div class="info">
Summary: Return L_TRUE if a is true, L_FALSE if it is false, and L_UNDEF otherwise.<br>
</div>
<pre><span id="VALget_app_decl"><span class="keyword">val</span> get_app_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEapp">app</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Return the declaration of a constant or function application.<br>
</div>
<pre><span id="VALget_app_num_args"><span class="keyword">val</span> get_app_num_args</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEapp">app</a> -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_app_num_args c a </code> ]

       Return the number of argument of an application. If t

       is an constant, then the number of arguments is 0.<br>
</div>
<pre><span id="VALget_app_arg"><span class="keyword">val</span> get_app_arg</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEapp">app</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_app_arg c a i </code> ]

       Return the i-th argument of the given application.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_num_args c a</li>
</ul>
<br>
</div>
<pre><span id="VALget_index_value"><span class="keyword">val</span> get_index_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return index of de-Brujin bound variable.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == VAR_AST</li>
</ul>
<br>
</div>
<pre><span id="VALis_quantifier_forall"><span class="keyword">val</span> is_quantifier_forall</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool</code></pre><div class="info">
Summary: Determine if quantifier is universal.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_weight"><span class="keyword">val</span> get_quantifier_weight</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Obtain weight of quantifier.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_num_patterns"><span class="keyword">val</span> get_quantifier_num_patterns</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return number of patterns used in quantifier.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_pattern_ast"><span class="keyword">val</span> get_quantifier_pattern_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> <a href="Z3.html#TYPEpattern">pattern</a></code></pre><div class="info">
Summary: Return i'th pattern.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_num_no_patterns"><span class="keyword">val</span> get_quantifier_num_no_patterns</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return number of no_patterns used in quantifier.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_no_pattern_ast"><span class="keyword">val</span> get_quantifier_no_pattern_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return i'th no_pattern.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_bound_name"><span class="keyword">val</span> get_quantifier_bound_name</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Return symbol of the i'th bound variable.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_bound_sort"><span class="keyword">val</span> get_quantifier_bound_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Return sort of the i'th bound variable.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_body"><span class="keyword">val</span> get_quantifier_body</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return body of quantifier.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_quantifier_num_bound"><span class="keyword">val</span> get_quantifier_num_bound</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return number of bound variables of quantifier.

<p>
<ul>
<li><b>Precondition</b>: get_ast_kind a == QUANTIFIER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_name"><span class="keyword">val</span> get_decl_name</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Return the constant declaration name as a symbol.<br>
</div>
<pre><span id="VALget_decl_num_parameters"><span class="keyword">val</span> get_decl_num_parameters</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int</code></pre><div class="info">
Summary: Return the number of parameters associated with a declaration.<br>
</div>
<pre><span id="VALget_decl_parameter_kind"><span class="keyword">val</span> get_decl_parameter_kind</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEparameter_kind">parameter_kind</a></code></pre><div class="info">
Summary: Return the parameter type associated with a declaration.<br>
</div>
<pre><span id="VALget_decl_int_parameter"><span class="keyword">val</span> get_decl_int_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> int</code></pre><div class="info">
Summary: Return the integer value associated with an integer parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_INT</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_double_parameter"><span class="keyword">val</span> get_decl_double_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> float</code></pre><div class="info">
Summary: Return the double value associated with an double parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_DOUBLE</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_symbol_parameter"><span class="keyword">val</span> get_decl_symbol_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Return the double value associated with an double parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_SYMBOL</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_sort_parameter"><span class="keyword">val</span> get_decl_sort_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Return the sort value associated with a sort parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_SORT</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_ast_parameter"><span class="keyword">val</span> get_decl_ast_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the expresson value associated with an expression parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_AST</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_func_decl_parameter"><span class="keyword">val</span> get_decl_func_decl_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Return the expresson value associated with an expression parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_FUNC_DECL</li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_rational_parameter"><span class="keyword">val</span> get_decl_rational_parameter</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> string</code></pre><div class="info">
Summary: Return the rational value, as a string, associated with a rational parameter.

<p>
<ul>
<li><b>Precondition</b>: get_decl_parameter_kind c d idx == PARAMETER_RATIONAL</li>
</ul>
<br>
</div>
<pre><span id="VALget_sort_name"><span class="keyword">val</span> get_sort_name</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Return the sort name as a symbol.<br>
</div>
<pre><span id="VALget_sort"><span class="keyword">val</span> get_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Return the sort of an AST node.

<p>

       The AST node must be a constant, application, numeral, bound variable, or quantifier.<br>
</div>
<pre><span id="VALget_domain_size"><span class="keyword">val</span> get_domain_size</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int</code></pre><div class="info">
Summary: Return the number of parameters of the given declaration.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_domain_size"><code class="code">Z3.get_domain_size</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_domain"><span class="keyword">val</span> get_domain</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: [ <code class="code"> get_domain c d i </code> ]

       Return the sort of the i-th parameter of the given function declaration.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_domain_size d
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_domain_size"><code class="code">Z3.get_domain_size</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_range"><span class="keyword">val</span> get_range</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: [ <code class="code"> get_range c d </code> ]

       Return the range of the given declaration. 

<p>

       If d is a constant (i.e., has zero arguments), then this

       function returns the sort of the constant.<br>
</div>
<pre><span id="VALget_sort_kind"><span class="keyword">val</span> get_sort_kind</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort_kind">sort_kind</a></code></pre><div class="info">
Summary: Return the sort kind (e.g., array, tuple, int, bool, etc).

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#TYPEsort_kind"><code class="code">Z3.sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_bv_sort_size"><span class="keyword">val</span> get_bv_sort_size</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_bv_sort_size c t </code> ]

       Return the size of the given bit-vector sort. 

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c t == BV_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_bv_sort"><code class="code">Z3.mk_bv_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_array_sort_domain"><span class="keyword">val</span> get_array_sort_domain</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: [ <code class="code"> get_array_sort_domain c t </code> ]

       Return the domain of the given array sort.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c t == ARRAY_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_array_sort"><code class="code">Z3.mk_array_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_array_sort_range"><span class="keyword">val</span> get_array_sort_range</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: [ <code class="code"> get_array_sort_range c t </code> ] 

       Return the range of the given array sort. 

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c t == ARRAY_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_array_sort"><code class="code">Z3.mk_array_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_tuple_sort_mk_decl"><span class="keyword">val</span> get_tuple_sort_mk_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: [ <code class="code"> get_tuple_sort_mk_decl c t </code> ]

       Return the constructor declaration of the given tuple

       sort. 

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c t == DATATYPE_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_tuple_sort"><code class="code">Z3.mk_tuple_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_decl_kind"><span class="keyword">val</span> get_decl_kind</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEdecl_kind">decl_kind</a></code></pre><div class="info">
Summary: Return declaration kind corresponding to declaration.<br>
</div>
<pre><span id="VALget_tuple_sort_num_fields"><span class="keyword">val</span> get_tuple_sort_num_fields</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_tuple_sort_num_fields c t </code> ]

       Return the number of fields of the given tuple sort. 

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c t == DATATYPE_SORT
</li>
</ul>
<ul>
<li><b>Remarks</b>: Consider using the function <a href="Z3.html#VALget_tuple_sort"><code class="code">Z3.get_tuple_sort</code></a>, which 

       returns a tuple: tuple constructor, and an array of the tuple sort fields. 
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_tuple_sort"><code class="code">Z3.mk_tuple_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_tuple_sort_field_decl"><span class="keyword">val</span> get_tuple_sort_field_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: [ <code class="code"> get_tuple_sort_field_decl c t i </code> ]

       Return the i-th field declaration (i.e., projection function declaration)

       of the given tuple sort. 

<p>
<ul>
<li><b>Remarks</b>: Consider using the function <a href="Z3.html#VALget_tuple_sort"><code class="code">Z3.get_tuple_sort</code></a>, which 

       returns a tuple: tuple constructor, and an array of the tuple sort fields. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: get_sort_kind t == DATATYPE_SORT
</li>
<li><b>Precondition</b>: i &lt; get_tuple_sort_num_fields c t
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALmk_tuple_sort"><code class="code">Z3.mk_tuple_sort</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_datatype_sort_num_constructors"><span class="keyword">val</span> get_datatype_sort_num_constructors</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int</code></pre><div class="info">
Summary: Return number of constructors for datatype.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind t == DATATYPE_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor"><code class="code">Z3.get_datatype_sort_constructor</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_recognizer"><code class="code">Z3.get_datatype_sort_recognizer</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor_accessor"><code class="code">Z3.get_datatype_sort_constructor_accessor</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_datatype_sort_constructor"><span class="keyword">val</span> get_datatype_sort_constructor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Return idx'th constructor.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind t == DATATYPE_SORT
</li>
<li><b>Precondition</b>: idx &lt; get_datatype_sort_num_constructors c t
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_num_constructors"><code class="code">Z3.get_datatype_sort_num_constructors</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_recognizer"><code class="code">Z3.get_datatype_sort_recognizer</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor_accessor"><code class="code">Z3.get_datatype_sort_constructor_accessor</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_datatype_sort_recognizer"><span class="keyword">val</span> get_datatype_sort_recognizer</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Return idx'th recognizer.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind t == DATATYPE_SORT
</li>
<li><b>Precondition</b>: idx &lt; get_datatype_sort_num_constructors c t
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_num_constructors"><code class="code">Z3.get_datatype_sort_num_constructors</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor"><code class="code">Z3.get_datatype_sort_constructor</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor_accessor"><code class="code">Z3.get_datatype_sort_constructor_accessor</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_datatype_sort_constructor_accessor"><span class="keyword">val</span> get_datatype_sort_constructor_accessor</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Return idx_a'th accessor for the idx_c'th constructor.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind t == DATATYPE_SORT
</li>
<li><b>Precondition</b>: idx_c &lt; get_datatype_sort_num_constructors c t
</li>
<li><b>Precondition</b>: idx_a &lt; get_domain_size c get_datatype_sort_constructor c idx_c
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_num_constructors"><code class="code">Z3.get_datatype_sort_num_constructors</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor"><code class="code">Z3.get_datatype_sort_constructor</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_recognizer"><code class="code">Z3.get_datatype_sort_recognizer</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_relation_arity"><span class="keyword">val</span> get_relation_arity</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int</code></pre><div class="info">
Summary: Return arity of relation.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind s == RELATION_SORT
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_relation_column"><code class="code">Z3.get_relation_column</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_relation_column"><span class="keyword">val</span> get_relation_column</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Return sort at i'th column of relation sort.

<p>
<ul>
<li><b>Precondition</b>: get_sort_kind c s == RELATION_SORT
</li>
<li><b>Precondition</b>: col &lt; get_relation_arity c s
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_relation_arity"><code class="code">Z3.get_relation_arity</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_pattern_num_terms"><span class="keyword">val</span> get_pattern_num_terms</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEpattern">pattern</a> -> int</code></pre><div class="info">
Summary: Return number of terms in pattern.<br>
</div>
<pre><span id="VALget_pattern"><span class="keyword">val</span> get_pattern</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEpattern">pattern</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return i'th ast in pattern.<br>
</div>
<pre><span id="VALsimplify"><span class="keyword">val</span> simplify</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Interface to simplifier.

<p>

        Provides an interface to the AST simplifier used by Z3.

        It allows clients to piggyback on top of the AST simplifier

        for their own term manipulation.<br>
</div>
<br>
<span id="2_Modifiers"><h2><div align=left>Modifiers</div></h2></span><br>
<pre><span id="VALupdate_term"><span class="keyword">val</span> update_term</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Update the arguments of term a using the arguments args.

       The number of arguments num_args should coincide 

       with the number of arguments to a.

       If a is a quantifier, then num_args has to be 1.<br>
</div>
<br>
<span id="2_Coercions"><h2><div align=left>Coercions</div></h2></span><br>
<pre><span id="VALsort_to_ast"><span class="keyword">val</span> sort_to_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Convert a sort into ast. This is just type casting.<br>
</div>
<pre><span id="VALfunc_decl_to_ast"><span class="keyword">val</span> func_decl_to_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Convert a func_decl into ast. This is just type casting.<br>
</div>
<pre><span id="VALpattern_to_ast"><span class="keyword">val</span> pattern_to_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEpattern">pattern</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Convert a pattern into ast. This is just type casting.<br>
</div>
<pre><span id="VALapp_to_ast"><span class="keyword">val</span> app_to_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEapp">app</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Convert a APP_AST into an AST. This is just type casting.<br>
</div>
<pre><span id="VALto_app"><span class="keyword">val</span> to_app</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEapp">app</a></code></pre><div class="info">
Summary: Convert an AST into a APP_AST. This is just type casting.

<p>
<ul>
<li><b>Warning</b>: This conversion is only safe if <a href="Z3.html#VALget_ast_kind"><code class="code">Z3.get_ast_kind</code></a> returns app.</li>
</ul>
<br>
</div>
<br>
<span id="2_Constraints"><h2><div align=left>Constraints</div></h2></span><br>
<pre><span id="VALpush"><span class="keyword">val</span> push</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Create a backtracking point.

<p>

        The logical context can be viewed as a stack of contexts.  The

        scope level is the number of elements on this stack. The stack

        of contexts is simulated using trail (undo) stacks.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALpop"><code class="code">Z3.pop</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALpop"><span class="keyword">val</span> pop</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> unit</code></pre><div class="info">
Summary: Backtrack.

<p>

       Restores the context from the top of the stack, and pops it off the

       stack.  Any changes to the logical context (by <a href="Z3.html#VALassert_cnstr"><code class="code">Z3.assert_cnstr</code></a> or

       other functions) between the matching <a href="Z3.html#VALpush"><code class="code">Z3.push</code></a> and pop

       operators are flushed, and the context is completely restored to

       what it was right before the <a href="Z3.html#VALpush"><code class="code">Z3.push</code></a>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALpush"><code class="code">Z3.push</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_num_scopes"><span class="keyword">val</span> get_num_scopes</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int</code></pre><div class="info">
Summary: Retrieve the current scope level.

<p>

       It retrieves the number of scopes that have been pushed, but not yet popped.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALpush"><code class="code">Z3.push</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALpop"><code class="code">Z3.pop</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALpersist_ast"><span class="keyword">val</span> persist_ast</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> unit</code></pre><div class="info">
Summary: Persist AST through num_scopes pops.

       This function is only relevant if c was created using <a href="Z3.html#VALmk_context"><code class="code">Z3.mk_context</code></a>.

       If c was created using <a href="Z3.html#VALmk_context_rc"><code class="code">Z3.mk_context_rc</code></a>, this function is a NOOP.

<p>

       Normally, for contexts created using <a href="Z3.html#VALmk_context"><code class="code">Z3.mk_context</code></a>, 

       references to terms are no longer valid when 

       popping scopes beyond the level where the terms are created.

       If you want to reference a term below the scope where it

       was created, use this method to specify how many pops

       the term should survive.

       The num_scopes should be at most equal to the number of

       calls to push subtracted with the calls to pop.<br>
</div>
<pre><span id="VALassert_cnstr"><span class="keyword">val</span> assert_cnstr</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit</code></pre><div class="info">
Summary: Assert a constraing into the logical context.

<p>

       After one assertion, the logical context may become

       inconsistent.  

<p>

       The functions <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a> or <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a> should be

       used to check whether the logical context is consistent or not.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALcheck_and_get_model"><span class="keyword">val</span> check_and_get_model</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPElbool">lbool</a> * <a href="Z3.html#TYPEmodel">model</a></code></pre><div class="info">
Summary: Check whether the given logical context is consistent or not.

<p>

       If the logical context is not unsatisfiable (i.e., the return value is different from L_FALSE)

       and model construction is enabled (see <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a>), then a model is stored in m. Otherwise,

       the value 0 is stored in m.

       The caller is responsible for deleting the model using the function <a href="Z3.html#VALdel_model"><code class="code">Z3.del_model</code></a>.

<p>
<ul>
<li><b>Remarks</b>: Model construction must be enabled using configuration

       parameters (See, <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a>).
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALdel_model"><code class="code">Z3.del_model</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALcheck"><span class="keyword">val</span> check</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPElbool">lbool</a></code></pre><div class="info">
Summary: Check whether the given logical context is consistent or not.

<p>

       The function <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a> should be used when models are needed.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALcheck_assumptions"><span class="keyword">val</span> check_assumptions</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEast">ast</a> array -><br>       int -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPElbool">lbool</a> * <a href="Z3.html#TYPEmodel">model</a> * <a href="Z3.html#TYPEast">ast</a> * int * <a href="Z3.html#TYPEast">ast</a> array</code></pre><div class="info">
Summary: Check whether the given logical context and optional assumptions is consistent or not.

<p>

       If the logical context is not unsatisfiable (i.e., the return value is different from L_FALSE),

       a non-0 model argument is passed in,

       and model construction is enabled (see <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a>), then a model is stored in m. 

       Otherwise, m is left unchanged.

       The caller is responsible for deleting the model using the function <a href="Z3.html#VALdel_model"><code class="code">Z3.del_model</code></a>.

<p>
<ul>
<li><b>Remarks</b>: If the model argument is non-0, then model construction must be enabled using configuration

       parameters (See, <a href="Z3.html#VALmk_config"><code class="code">Z3.mk_config</code></a>).
</li>
</ul>

              The unsatisfiable core is a subset of the assumptions, so the array has the same size as the assumptions.

              The core array is not populated if core_size is set to 0.

<p>
<ul>
<li><b>Precondition</b>: assumptions comprises of propositional literals.

            In other words, you cannot use compound formulas for assumptions, 

            but should use propositional variables or negations of propositional variables.
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALdel_model"><code class="code">Z3.del_model</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_implied_equalities"><span class="keyword">val</span> get_implied_equalities</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPElbool">lbool</a> * int array</code></pre><div class="info">
Summary: Retrieve congruence class representatives for terms.

<p>

       The function can be used for relying on Z3 to identify equal terms under the current

       set of assumptions. The array of terms and array of class identifiers should have

       the same length. The class identifiers are numerals that are assigned to the same

       value for their corresponding terms if the current context forces the terms to be

       equal. You cannot deduce that terms corresponding to different numerals must be all different, 

       (especially when using non-convex theories).

       All implied equalities are returned by this call.

       This means that two terms map to the same class identifier if and only if

       the current context implies that they are equal.

<p>

       A side-effect of the function is a satisfiability check.

       The function return L_FALSE if the current assertions are not satisfiable.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALdel_model"><span class="keyword">val</span> del_model</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> unit</code></pre><div class="info">
Summary: Delete a model object.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a></li>
</ul>
<br>
</div>
<br>
<span id="2_Searchcontrol"><h2><div align=left>Search control.</div></h2></span><br>
<pre><span id="VALsoft_check_cancel"><span class="keyword">val</span> soft_check_cancel</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Cancel an ongoing check.

<p>

       Notifies the current check to abort and return.

       This method should be called from a different thread

       than the one performing the check.<br>
</div>
<pre><span id="VALget_search_failure"><span class="keyword">val</span> get_search_failure</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsearch_failure">search_failure</a></code></pre><div class="info">
Summary: Retrieve reason for search failure.

<p>

       If a call to <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a> or <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a> returns L_UNDEF, 

       use this facility to determine the more detailed cause of search failure.<br>
</div>
<br>
<span id="2_Labels"><h2><div align=left>Labels.</div></h2></span><br>
<pre><span id="VALget_relevant_labels"><span class="keyword">val</span> get_relevant_labels</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a></code></pre><div class="info">
Summary: Retrieve the set of labels that were relevant in

        the context of the current satisfied context.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALdel_literals"><code class="code">Z3.del_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_num_literals"><code class="code">Z3.get_num_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_label_symbol"><code class="code">Z3.get_label_symbol</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_literal"><code class="code">Z3.get_literal</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_relevant_literals"><span class="keyword">val</span> get_relevant_literals</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a></code></pre><div class="info">
Summary: Retrieve the set of literals that satisfy the current context.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALdel_literals"><code class="code">Z3.del_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_num_literals"><code class="code">Z3.get_num_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_label_symbol"><code class="code">Z3.get_label_symbol</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_literal"><code class="code">Z3.get_literal</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_guessed_literals"><span class="keyword">val</span> get_guessed_literals</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a></code></pre><div class="info">
Summary: Retrieve the set of literals that whose assignment were 

        guess, but not propagated during the search.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALdel_literals"><code class="code">Z3.del_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_num_literals"><code class="code">Z3.get_num_literals</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_label_symbol"><code class="code">Z3.get_label_symbol</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_literal"><code class="code">Z3.get_literal</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALdel_literals"><span class="keyword">val</span> del_literals</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> unit</code></pre><div class="info">
Summary: Delete a labels context.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_relevant_labels"><code class="code">Z3.get_relevant_labels</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_num_literals"><span class="keyword">val</span> get_num_literals</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> int</code></pre><div class="info">
Summary: Retrieve the number of label symbols that were returned.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_relevant_labels"><code class="code">Z3.get_relevant_labels</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_label_symbol"><span class="keyword">val</span> get_label_symbol</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> int -> <a href="Z3.html#TYPEsymbol">symbol</a></code></pre><div class="info">
Summary: Retrieve label symbol at idx.<br>
</div>
<pre><span id="VALget_literal"><span class="keyword">val</span> get_literal</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Retrieve literal expression at idx.<br>
</div>
<pre><span id="VALdisable_literal"><span class="keyword">val</span> disable_literal</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> int -> unit</code></pre><div class="info">
Summary: Disable label.

<p>

       The disabled label is not going to be used when blocking the subsequent search.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALblock_literals"><code class="code">Z3.block_literals</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALblock_literals"><span class="keyword">val</span> block_literals</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEliterals">literals</a> -> unit</code></pre><div class="info">
Summary: Block subsequent checks using the remaining enabled labels.<br>
</div>
<br>
<span id="2_Modelnavigation"><h2><div align=left>Model navigation</div></h2></span><br>
<pre><span id="VALget_model_num_constants"><span class="keyword">val</span> get_model_num_constants</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int</code></pre><div class="info">
Summary: Return the number of constants assigned by the given model.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_constants"><code class="code">Z3.get_model_constants</code></a>. 
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_constant"><code class="code">Z3.get_model_constant</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_constant"><span class="keyword">val</span> get_model_constant</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: [ <code class="code"> get_model_constant c m i </code> ]

       Return the i-th constant in the given model. 

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_constants"><code class="code">Z3.get_model_constants</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_constants c m
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALeval"><code class="code">Z3.eval</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALeval_func_decl"><span class="keyword">val</span> eval_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> bool * <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the value of the given constant or function 

              in the given model.<br>
</div>
<pre><span id="VALis_array_value"><span class="keyword">val</span> is_array_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool * int</code></pre><div class="info">
Summary: [ <code class="code"> is_array_value c v </code> ]

       Determine whether the term encodes an array value.       

       Return the number of entries mapping to non-default values of the array.<br>
</div>
<pre><span id="VALget_array_value"><span class="keyword">val</span> get_array_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEmodel">model</a> -><br>       <a href="Z3.html#TYPEast">ast</a> -><br>       <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_array_value c v </code> ]

       An array values is represented as a dictionary plus a

       default (else) value. This function returns the array graph.

<p>
<ul>
<li><b>Precondition</b>: TRUE == is_array_value c v &amp;num_entries</li>
</ul>
<br>
</div>
<pre><span id="VALget_model_num_funcs"><span class="keyword">val</span> get_model_num_funcs</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int</code></pre><div class="info">
Summary: Return the number of function interpretations in the given model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

       Each entry in the finite map represents the value of a function given a set of arguments.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_decl"><code class="code">Z3.get_model_func_decl</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_else"><code class="code">Z3.get_model_func_else</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_num_args"><code class="code">Z3.get_model_func_entry_num_args</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_arg"><code class="code">Z3.get_model_func_entry_arg</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_decl"><span class="keyword">val</span> get_model_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_decl c m i </code> ]

       Return the declaration of the i-th function in the given model.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_else"><span class="keyword">val</span> get_model_func_else</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_else c m i </code> ]

       Return the 'else' value of the i-th function interpretation in the given model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_num_args"><code class="code">Z3.get_model_func_entry_num_args</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_arg"><code class="code">Z3.get_model_func_entry_arg</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_num_entries"><span class="keyword">val</span> get_model_func_num_entries</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_num_entries c m i </code> ]

       Return the number of entries of the i-th function interpretation in the given model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_else"><code class="code">Z3.get_model_func_else</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_num_args"><code class="code">Z3.get_model_func_entry_num_args</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_arg"><code class="code">Z3.get_model_func_entry_arg</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_entry_num_args"><span class="keyword">val</span> get_model_func_entry_num_args</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> int -> int</code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_entry_num_args c m i j </code> ]

       Return the number of arguments of the j-th entry of the i-th function interpretation in the given

       model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

       This function returns the j-th entry of this map.

<p>

       An entry represents the value of a function given a set of arguments.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
<li><b>Precondition</b>: j &lt; get_model_func_num_entries c m i
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_arg"><code class="code">Z3.get_model_func_entry_arg</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_entry_arg"><span class="keyword">val</span> get_model_func_entry_arg</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> int -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_entry_arg c m i j k </code> ]

       Return the k-th argument of the j-th entry of the i-th function interpretation in the given

       model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

       This function returns the j-th entry of this map.

<p>

       An entry represents the value of a function given a set of arguments.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
<li><b>Precondition</b>: j &lt; get_model_func_num_entries c m i
</li>
<li><b>Precondition</b>: k &lt; get_model_func_entry_num_args c m i j
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_num_args"><code class="code">Z3.get_model_func_entry_num_args</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_entry_value"><span class="keyword">val</span> get_model_func_entry_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_model_func_entry_value c m i j </code> ]

       Return the return value of the j-th entry of the i-th function interpretation in the given

       model.

<p>

       A function interpretation is represented as a finite map and an 'else' value.

       This function returns the j-th entry of this map.

<p>

       An entry represents the value of a function given a set of arguments.

<p>
<ul>
<li><b>Remarks</b>: Consider using <a href="Z3.html#VALget_model_funcs"><code class="code">Z3.get_model_funcs</code></a>. 
</li>
</ul>
<ul>
<li><b>Precondition</b>: i &lt; get_model_num_funcs c m
</li>
<li><b>Precondition</b>: j &lt; get_model_func_num_entries c m i
</li>
</ul>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALeval"><span class="keyword">val</span> eval</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool * <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> eval c m t </code> ]

       Evaluate the AST node t in the given model. 

<p>

        Return a pair: Boolean and value. The Boolean is true if the term was successfully evaluated. 

<p>

       The evaluation may fail for the following reasons:

<p>
<ul>
<li>t contains a quantifier.
</li>
</ul>
<ul>
<li>the model m is partial, that is, it doesn't have a complete interpretation for uninterpreted functions. 

         That is, the option <em>MODEL_PARTIAL=true </em> was used.
</li>
</ul>
<ul>
<li>t is type incorrect.</li>
</ul>
<br>
</div>
<pre><span id="VALeval_decl"><span class="keyword">val</span> eval_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEast">ast</a> array -> bool * <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Evaluate declaration given values.

<p>

       Provides direct way to evaluate declarations

       without going over terms.<br>
</div>
<br>
<span id="2_Interactionlogging"><h2><div align=left>Interaction logging.</div></h2></span><br>
<pre><span id="VALopen_log"><span class="keyword">val</span> open_log</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> bool</code></pre><div class="info">
Summary: Log interaction to a file.<br>
</div>
<pre><span id="VALappend_log"><span class="keyword">val</span> append_log</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> unit</code></pre><div class="info">
Summary: Append user-defined string to interaction log.

<p>

       The interaction log is opened using open_log.

       It contains the formulas that are checked using Z3.

       You can use this command to append comments, for instance.<br>
</div>
<pre><span id="VALclose_log"><span class="keyword">val</span> close_log</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> unit</code></pre><div class="info">
Summary: Close interaction log.<br>
</div>
<br>
<span id="2_Stringconversion"><h2><div align=left>String conversion</div></h2></span><br>
<pre><span id="VALset_ast_print_mode"><span class="keyword">val</span> set_ast_print_mode</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast_print_mode">ast_print_mode</a> -> unit</code></pre><div class="info">
Summary: Select mode for the format used for pretty-printing AST nodes.

<p>

       The default mode for pretty printing AST nodes is to produce

       SMT-LIB style output where common subexpressions are printed 

       at each occurrence. The mode is called PRINT_SMTLIB_FULL.

       To print shared common subexpressions only once, 

       use the PRINT_LOW_LEVEL mode.

       To print in way that conforms to SMT-LIB standards and uses let

       expressions to share common sub-expressions use PRINT_SMTLIB_COMPLIANT.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALast_to_string"><code class="code">Z3.ast_to_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALpattern_to_string"><code class="code">Z3.pattern_to_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALfunc_decl_to_string"><code class="code">Z3.func_decl_to_string</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALast_to_string"><span class="keyword">val</span> ast_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> string</code></pre><div class="info">
Summary: Convert the given AST node into a string.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALpattern_to_string"><code class="code">Z3.pattern_to_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALsort_to_string"><code class="code">Z3.sort_to_string</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALpattern_to_string"><span class="keyword">val</span> pattern_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEpattern">pattern</a> -> string</code></pre><pre><span id="VALsort_to_string"><span class="keyword">val</span> sort_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> string</code></pre><pre><span id="VALfunc_decl_to_string"><span class="keyword">val</span> func_decl_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> string</code></pre><pre><span id="VALmodel_to_string"><span class="keyword">val</span> model_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> string</code></pre><div class="info">
Summary: Convert the given model into a string.<br>
</div>
<pre><span id="VALbenchmark_to_smtlib_string"><span class="keyword">val</span> benchmark_to_smtlib_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -> string -> string -> string -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> -> string</code></pre><div class="info">
Summary: Convert the given benchmark into SMT-LIB formatted string.<br>
</div>
<pre><span id="VALcontext_to_string"><span class="keyword">val</span> context_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string</code></pre><div class="info">
Summary: Convert the given logical context into a string.

<p>

       This function is mainly used for debugging purposes. It displays

       the internal structure of a logical context.<br>
</div>
<pre><span id="VALstatistics_to_string"><span class="keyword">val</span> statistics_to_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string</code></pre><div class="info">
Summary: Return runtime statistics as a string.

<p>

       This function is mainly used for debugging purposes. It displays

       statistics of the search activity.<br>
</div>
<pre><span id="VALget_context_assignment"><span class="keyword">val</span> get_context_assignment</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Extract satisfying assignment from context as a conjunction.

<p>

       This function can be used for debugging purposes. It returns a conjunction

       of formulas that are assigned to true in the current context.

       This conjunction will contain not only the assertions that are set to true

       under the current assignment, but will also include additional literals

       if there has been a call to <a href="Z3.html#VALcheck"><code class="code">Z3.check</code></a> or <a href="Z3.html#VALcheck_and_get_model"><code class="code">Z3.check_and_get_model</code></a>.<br>
</div>
<br>
<span id="2_Parserinterface"><h2><div align=left>Parser interface</div></h2></span><br>
<pre><span id="VALparse_smtlib_string"><span class="keyword">val</span> parse_smtlib_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> unit</code></pre><div class="info">
Summary: [ <code class="code"> parse_smtlib_string c str sort_names sorts decl_names decls </code> ]

       Parse the given string using the SMT-LIB parser. 

<p>

       The symbol table of the parser can be initialized using the given sorts and declarations. 

       The symbols in the arrays sort_names and decl_names don't need to match the names

       of the sorts and declarations in the arrays sorts and decls. This is an useful feature

       since we can use arbitrary names to reference sorts and declarations defined using the C API.

<p>

       The formulas, assumptions and declarations defined in str can be extracted using the functions:

       <a href="Z3.html#VALget_smtlib_num_formulas"><code class="code">Z3.get_smtlib_num_formulas</code></a>, <a href="Z3.html#VALget_smtlib_formula"><code class="code">Z3.get_smtlib_formula</code></a>, <a href="Z3.html#VALget_smtlib_num_assumptions"><code class="code">Z3.get_smtlib_num_assumptions</code></a>, <a href="Z3.html#VALget_smtlib_assumption"><code class="code">Z3.get_smtlib_assumption</code></a>, 

       <a href="Z3.html#VALget_smtlib_num_decls"><code class="code">Z3.get_smtlib_num_decls</code></a>, and <a href="Z3.html#VALget_smtlib_decl"><code class="code">Z3.get_smtlib_decl</code></a>.<br>
</div>
<pre><span id="VALparse_smtlib_file"><span class="keyword">val</span> parse_smtlib_file</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> unit</code></pre><div class="info">
Summary: Similar to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>, but reads the benchmark from a file.<br>
</div>
<pre><span id="VALget_smtlib_num_formulas"><span class="keyword">val</span> get_smtlib_num_formulas</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int</code></pre><div class="info">
Summary: Return the number of SMTLIB formulas parsed by the last call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.<br>
</div>
<pre><span id="VALget_smtlib_formula"><span class="keyword">val</span> get_smtlib_formula</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_smtlib_formula c i </code> ]

       Return the i-th formula parsed by the last call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_smtlib_num_formulas c</li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_num_assumptions"><span class="keyword">val</span> get_smtlib_num_assumptions</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int</code></pre><div class="info">
Summary: Return the number of SMTLIB assumptions parsed by <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.<br>
</div>
<pre><span id="VALget_smtlib_assumption"><span class="keyword">val</span> get_smtlib_assumption</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> get_smtlib_assumption c i </code> ]

       Return the i-th assumption parsed by the last call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_smtlib_num_assumptions c</li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_num_decls"><span class="keyword">val</span> get_smtlib_num_decls</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int</code></pre><div class="info">
Summary: Return the number of declarations parsed by <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.<br>
</div>
<pre><span id="VALget_smtlib_decl"><span class="keyword">val</span> get_smtlib_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: [ <code class="code"> get_smtlib_decl c i </code> ]

       Return the i-th declaration parsed by the last call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_smtlib_num_decls c</li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_num_sorts"><span class="keyword">val</span> get_smtlib_num_sorts</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int</code></pre><div class="info">
Summary: Return the number of sorts parsed by <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.<br>
</div>
<pre><span id="VALget_smtlib_sort"><span class="keyword">val</span> get_smtlib_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> int -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: [ <code class="code"> get_smtlib_sort c i </code> ]

       Return the i-th sort parsed by the last call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>
<ul>
<li><b>Precondition</b>: i &lt; get_smtlib_num_sorts c</li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_error"><span class="keyword">val</span> get_smtlib_error</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string</code></pre><div class="info">
Summary: [ <code class="code"> get_smtlib_error c </code> ]

       Retrieve that last error message information generated from parsing.<br>
</div>
<pre><span id="VALparse_z3_string"><span class="keyword">val</span> parse_z3_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> parse_z3_string c str </code> ]

       Parse the given string using the Z3 native parser.

<p>

       Return the conjunction of asserts made in the input.<br>
</div>
<pre><span id="VALparse_z3_file"><span class="keyword">val</span> parse_z3_file</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Similar to <a href="Z3.html#VALparse_z3_string"><code class="code">Z3.parse_z3_string</code></a>, but reads the benchmark from a file.<br>
</div>
<pre><span id="VALparse_smtlib2_string"><span class="keyword">val</span> parse_smtlib2_string</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: [ <code class="code"> parse_smtlib2_string c str </code> ]

       Parse the given string using the SMT-LIB2 parser. 

<p>

       It returns a formula comprising of the conjunction of assertions in the scope

       (up to push/pop) at the end of the string.<br>
</div>
<pre><span id="VALparse_smtlib2_file"><span class="keyword">val</span> parse_smtlib2_file</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Similar to <a href="Z3.html#VALparse_smtlib2_string"><code class="code">Z3.parse_smtlib2_string</code></a>, but reads the benchmark from a file.<br>
</div>
<br>
<span id="2_Miscellaneous"><h2><div align=left>Miscellaneous</div></h2></span><br>
<pre><span id="VALget_version"><span class="keyword">val</span> get_version</span> : <code class="type">unit -> int * int * int * int</code></pre><div class="info">
Summary: Return Z3 version number information.<br>
</div>
<pre><span id="VALreset_memory"><span class="keyword">val</span> reset_memory</span> : <code class="type">unit -> unit</code></pre><div class="info">
Summary: Reset all allocated resources. 

<p>

       Use this facility on out-of memory errors. 

       It allows discharging the previous state and resuming afresh.

       Any pointers previously returned by the API

       become invalid.<br>
</div>
<br>
<span id="2_ExternalTheoryPlugins"><h2><div align=left>External Theory Plugins</div></h2></span><br>
<pre><span id="VALtheory_mk_sort"><span class="keyword">val</span> theory_mk_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
Summary: Create an interpreted theory sort.<br>
</div>
<pre><span id="VALtheory_mk_value"><span class="keyword">val</span> theory_mk_value</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create an interpreted theory constant value. Values are assumed to be different from each other.<br>
</div>
<pre><span id="VALtheory_mk_constant"><span class="keyword">val</span> theory_mk_constant</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Create an interpreted constant for the given theory.<br>
</div>
<pre><span id="VALtheory_mk_func_decl"><span class="keyword">val</span> theory_mk_func_decl</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a></code></pre><div class="info">
Summary: Create an interpreted function declaration for the given theory.<br>
</div>
<pre><span id="VALtheory_get_context"><span class="keyword">val</span> theory_get_context</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEcontext">context</a></code></pre><div class="info">
Summary: Return the context where the given theory is installed.<br>
</div>
<pre><span id="VALtheory_assert_axiom"><span class="keyword">val</span> theory_assert_axiom</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit</code></pre><div class="info">
Summary: Assert a theory axiom/lemmas during the search.

<p>

       An axiom added at search level n will remain in the logical context until 

       level n is backtracked. 

<p>

       The callbacks for push (<a href="Z3.html#VALset_push_callback"><code class="code">Z3.set_push_callback</code></a>) and pop

       (<a href="Z3.html#VALset_pop_callback"><code class="code">Z3.set_pop_callback</code></a>) can be used to track when the search

       level is increased (i.e., new case-split) and decreased (i.e.,

       case-split is backtracked).

<p>

       Z3 tracks the theory axioms asserted. So, multiple assertions of the same axiom are

       ignored.<br>
</div>
<pre><span id="VALtheory_assume_eq"><span class="keyword">val</span> theory_assume_eq</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit</code></pre><div class="info">
Summary: Inform to the logical context that lhs and rhs have the same interpretation

       in the model being built by theory t. If lhs = rhs is inconsistent with other theories,

       then the logical context will backtrack.

<p>

       For more information, see the paper "Model-Based Theory Combination" in the Z3 website.<br>
</div>
<pre><span id="VALtheory_enable_axiom_simplification"><span class="keyword">val</span> theory_enable_axiom_simplification</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> bool -> unit</code></pre><div class="info">
Summary: Enable/disable the simplification of theory axioms asserted using <a href="Z3.html#VALtheory_assert_axiom"><code class="code">Z3.theory_assert_axiom</code></a>.

       By default, the simplification of theory specific operators is disabled. 

       That is, the reduce theory callbacks are not invoked for theory axioms.

       The default behavior is useful when asserting axioms stating properties of theory operators.<br>
</div>
<pre><span id="VALtheory_get_eqc_root"><span class="keyword">val</span> theory_get_eqc_root</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the root of the equivalence class containing n.<br>
</div>
<pre><span id="VALtheory_get_eqc_next"><span class="keyword">val</span> theory_get_eqc_next</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the next element in the equivalence class containing n.

<p>

       The elements in an equivalence class are organized in a circular list.

       You can traverse the list by calling this function multiple times 

       using the result from the previous call. This is illustrated in the

       code snippet below.

       <pre>

           ast curr = n;

           do

             curr = theory_get_eqc_next(theory, curr);

           while (curr != n);

       </pre><br>
</div>
<pre><span id="VALtheory_get_num_parents"><span class="keyword">val</span> theory_get_num_parents</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> int</code></pre><div class="info">
Summary: Return the number of parents of n that are operators of the given theory.<br>
</div>
<pre><span id="VALtheory_get_parent"><span class="keyword">val</span> theory_get_parent</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the i-th parent of n. 

       See <a href="Z3.html#VALtheory_get_num_parents"><code class="code">Z3.theory_get_num_parents</code></a>.<br>
</div>
<pre><span id="VALtheory_is_value"><span class="keyword">val</span> theory_is_value</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEast">ast</a> -> bool</code></pre><div class="info">
Summary: Return TRUE if n is an interpreted theory value.<br>
</div>
<pre><span id="VALtheory_is_decl"><span class="keyword">val</span> theory_is_decl</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> bool</code></pre><div class="info">
Summary: Return TRUE if d is an interpreted theory declaration.<br>
</div>
<pre><span id="VALtheory_get_num_elems"><span class="keyword">val</span> theory_get_num_elems</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> int</code></pre><div class="info">
Summary: Return the number of expressions of the given theory in

       the logical context. These are the expressions notified using the

       callback <a href="Z3.html#VALset_new_elem_callback"><code class="code">Z3.set_new_elem_callback</code></a>.<br>
</div>
<pre><span id="VALtheory_get_elem"><span class="keyword">val</span> theory_get_elem</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the i-th elem of the given theory in the logical context.

<p>

       \see theory_get_num_elems<br>
</div>
<pre><span id="VALtheory_get_num_apps"><span class="keyword">val</span> theory_get_num_apps</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> int</code></pre><div class="info">
Summary: Return the number of theory applications in the logical

       context. These are the expressions notified using the callback

       <a href="Z3.html#VALset_new_app_callback"><code class="code">Z3.set_new_app_callback</code></a>.<br>
</div>
<pre><span id="VALtheory_get_app"><span class="keyword">val</span> theory_get_app</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> int -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Return the i-th application of the given theory in the logical context.

<p>

       \see theory_get_num_apps<br>
</div>
<br>
<span id="2_FixedpointandDatalogfacilities"><h2><div align=left>Fixedpoint and Datalog facilities</div></h2></span><br>
<pre><span id="VALdatalog_add_rule"><span class="keyword">val</span> datalog_add_rule</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> unit</code></pre><div class="info">
Summary: Add a universal Horn clause as a named rule.

       The horn_rule should be of the form:

<p>

       <pre>

           horn_rule ::= (forall (bound-vars) horn_rule)

                      |  (=&gt; atoms horn_rule)

                      |  atom

       </pre><br>
</div>
<pre><span id="VALdatalog_query"><span class="keyword">val</span> datalog_query</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
Summary: Pose a query against the asserted rules.

<p>

        The query returns a formula that encodes the set of

        satisfying instances for the query.

<p>

        <pre>

           query ::= (exists (bound-vars) query)

                 |  literals 

        </pre><br>
</div>
<pre><span id="VALdatalog_set_predicate_representation"><span class="keyword">val</span> datalog_set_predicate_representation</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> unit</code></pre><div class="info">
Summary: Configure the predicate representation.

<p>

       It sets the predicate to use a set of domains given by the list of symbols.

       The domains given by the list of symbols must belong to a set

       of built-in domains.<br>
</div>
<pre><span id="VALdatalog_parse_file"><span class="keyword">val</span> datalog_parse_file</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> unit</code></pre><div class="info">
Summary: Parse a file in Datalog format and process the queries in it.<br>
</div>
<br>
Summary: The following utilities allows adding user-defined domains.<br>
<br>
<span id="2_MLExtensions"><h2><div align=left>ML Extensions</div></h2></span><br>
<pre><span id="VALmk_context_x"><span class="keyword">val</span> mk_context_x</span> : <code class="type">(string * string) array -> <a href="Z3.html#TYPEcontext">context</a></code></pre><div class="info">
[ <code class="code"> mk_context_x configs</code> ] is a shorthand for the context with configurations in <code class="code">configs</code>.<br>
</div>
<pre><span id="VALget_app_args"><span class="keyword">val</span> get_app_args</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEapp">app</a> -> <a href="Z3.html#TYPEast">ast</a> array</code></pre><div class="info">
[ <code class="code"> get_app_args c a </code> ] is the array of arguments of an application. If <code class="code">t</code> is a constant, then the array is empty.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_app_num_args"><code class="code">Z3.get_app_num_args</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_app_arg"><code class="code">Z3.get_app_arg</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_domains"><span class="keyword">val</span> get_domains</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEsort">sort</a> array</code></pre><div class="info">
[ <code class="code"> get_app_args c d </code> ] is the array of parameters of <code class="code">d</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_domain_size"><code class="code">Z3.get_domain_size</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_domain"><code class="code">Z3.get_domain</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_array_sort"><span class="keyword">val</span> get_array_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEsort">sort</a></code></pre><div class="info">
[ <code class="code"> get_array_sort c t </code> ] is the domain and the range of <code class="code">t</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_array_sort_domain"><code class="code">Z3.get_array_sort_domain</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_array_sort_range"><code class="code">Z3.get_array_sort_range</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_tuple_sort"><span class="keyword">val</span> get_tuple_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> get_tuple_sort c ty </code> ] is the pair <code class="code">(mk_decl, fields)</code> where <code class="code">mk_decl</code> is the constructor declaration of <code class="code">ty</code>, and <code class="code">fields</code> is the array of fields in <code class="code">ty</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_tuple_sort_mk_decl"><code class="code">Z3.get_tuple_sort_mk_decl</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_tuple_sort_num_fields"><code class="code">Z3.get_tuple_sort_num_fields</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_tuple_sort_field_decl"><code class="code">Z3.get_tuple_sort_field_decl</code></a></li>
</ul>
<br>
</div>
<br><code><span id="TYPEdatatype_constructor_refined"><span class="keyword">type</span> <code class="type"></code>datatype_constructor_refined</span> = {</code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>constructor&nbsp;: <code class="type"><a href="Z3.html#TYPEfunc_decl">func_decl</a></code>;</code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>recognizer&nbsp;: <code class="type"><a href="Z3.html#TYPEfunc_decl">func_decl</a></code>;</code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code>&nbsp;&nbsp;</code></td>
<td align="left" valign="top" >
<code>accessors&nbsp;: <code class="type"><a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code>;</code></td>

</tr></table>
}

<div class="info">
[ <code class="code"> datatype_constructor_refined </code> ] is the refinement of a datatype constructor.

<p>

  It contains the constructor declaration, recognizer, and list of accessor functions.<br>
</div>

<br>
[ <code class="code"> get_datatype_sort c ty </code> ] is the array of triples <code class="code">(constructor, recognizer, fields)</code> where <code class="code">constructor</code> is the constructor declaration of <code class="code">ty</code>, <code class="code">recognizer</code> is the recognizer for the <code class="code">constructor</code>, and <code class="code">fields</code> is the array of fields in <code class="code">ty</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_num_constructors"><code class="code">Z3.get_datatype_sort_num_constructors</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor"><code class="code">Z3.get_datatype_sort_constructor</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_recognizer"><code class="code">Z3.get_datatype_sort_recognizer</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_datatype_sort_constructor_accessor"><code class="code">Z3.get_datatype_sort_constructor_accessor</code></a></li>
</ul>
<br>
<pre><span id="VALget_datatype_sort"><span class="keyword">val</span> get_datatype_sort</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEdatatype_constructor_refined">datatype_constructor_refined</a> array</code></pre><pre><span id="VALget_model_constants"><span class="keyword">val</span> get_model_constants</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> get_model_constants c m </code> ] is the array of constants in the model <code class="code">m</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_constants"><code class="code">Z3.get_model_num_constants</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_constant"><code class="code">Z3.get_model_constant</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_entry"><span class="keyword">val</span> get_model_func_entry</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> int -> <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
[ <code class="code"> get_model_func_entry c m i j </code> ] is the <code class="code">j</code>'th entry in the <code class="code">i</code>'th function in the model <code class="code">m</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_num_args"><code class="code">Z3.get_model_func_entry_num_args</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_arg"><code class="code">Z3.get_model_func_entry_arg</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry_value"><code class="code">Z3.get_model_func_entry_value</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_func_entries"><span class="keyword">val</span> get_model_func_entries</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEmodel">model</a> -> int -> (<a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a>) array</code></pre><div class="info">
[ <code class="code"> get_model_func_entries c m i </code> ] is the array of entries in the <code class="code">i</code>'th function in the model <code class="code">m</code>.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_num_entries"><code class="code">Z3.get_model_func_num_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entry"><code class="code">Z3.get_model_func_entry</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_model_funcs"><span class="keyword">val</span> get_model_funcs</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       <a href="Z3.html#TYPEmodel">model</a> -> (<a href="Z3.html#TYPEsymbol">symbol</a> * (<a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a>) array * <a href="Z3.html#TYPEast">ast</a>) array</code></pre><div class="info">
[ <code class="code"> get_model_funcs c m </code> ] is the array of functions in the model <code class="code">m</code>. Each function is represented by the triple <code class="code">(decl, entries, else)</code>, where <code class="code">decl</code> is the declaration name for the function, <code class="code">entries</code> is the array of entries in the function, and <code class="code">else</code> is the default (else) value for the function.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALget_model_num_funcs"><code class="code">Z3.get_model_num_funcs</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_decl"><code class="code">Z3.get_model_func_decl</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_entries"><code class="code">Z3.get_model_func_entries</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_model_func_else"><code class="code">Z3.get_model_func_else</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_formulas"><span class="keyword">val</span> get_smtlib_formulas</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array</code></pre><div class="info">
[ <code class="code"> get_smtlib_formulas c </code> ] is the array of formulas created by a preceding call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>

  Recommend use <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a> or <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a> for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_num_formulas"><code class="code">Z3.get_smtlib_num_formulas</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_formula"><code class="code">Z3.get_smtlib_formula</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_assumptions"><span class="keyword">val</span> get_smtlib_assumptions</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array</code></pre><div class="info">
[ <code class="code">get_smtlib_assumptions c</code> ] is the array of assumptions created by a preceding call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>

  Recommend use <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a> or <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a> for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_num_assumptions"><code class="code">Z3.get_smtlib_num_assumptions</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_assumption"><code class="code">Z3.get_smtlib_assumption</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_decls"><span class="keyword">val</span> get_smtlib_decls</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> get_smtlib_decls c </code> ] is the array of declarations created by a preceding call to <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a> or <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>.

<p>

  Recommend use <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a> or <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a> for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_num_decls"><code class="code">Z3.get_smtlib_num_decls</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_decl"><code class="code">Z3.get_smtlib_decl</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALget_smtlib_parse_results"><span class="keyword">val</span> get_smtlib_parse_results</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> get_smtlib_parse_results c </code> ] is the triple <code class="code">(get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c)</code>.

<p>

  Recommend use <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a> or <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a> for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_formulas"><code class="code">Z3.get_smtlib_formulas</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_assumptions"><code class="code">Z3.get_smtlib_assumptions</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_decls"><code class="code">Z3.get_smtlib_decls</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALparse_smtlib_string_formula"><span class="keyword">val</span> parse_smtlib_string_formula</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
[ <code class="code"> parse_smtlib_string_formula c ... </code> ] calls <code class="code">(parse_smtlib_string c ...)</code> and returns the single formula produced. 

<p>

  Recommended for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_formula"><code class="code">Z3.parse_smtlib_file_formula</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALparse_smtlib_file_formula"><span class="keyword">val</span> parse_smtlib_file_formula</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -> <a href="Z3.html#TYPEsymbol">symbol</a> array -> <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> <a href="Z3.html#TYPEast">ast</a></code></pre><div class="info">
[ <code class="code"> parse_smtlib_file_formula c ... </code> ] calls <code class="code">(parse_smtlib_file c ...)</code> and returns the single formula produced. 

<p>

  Recommended for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_formula"><code class="code">Z3.parse_smtlib_file_formula</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALparse_smtlib_string_x"><span class="keyword">val</span> parse_smtlib_string_x</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> parse_smtlib_string_x c ... </code> ] is <code class="code">(parse_smtlib_string c ...; get_smtlib_parse_results c)</code>

<p>

  Recommended for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file_x"><code class="code">Z3.parse_smtlib_file_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string"><code class="code">Z3.parse_smtlib_string</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_parse_results"><code class="code">Z3.get_smtlib_parse_results</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALparse_smtlib_file_x"><span class="keyword">val</span> parse_smtlib_file_x</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -><br>       string -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEsort">sort</a> array -><br>       <a href="Z3.html#TYPEsymbol">symbol</a> array -><br>       <a href="Z3.html#TYPEfunc_decl">func_decl</a> array -> <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEast">ast</a> array * <a href="Z3.html#TYPEfunc_decl">func_decl</a> array</code></pre><div class="info">
[ <code class="code"> parse_smtlib_file_x c ... </code> ] is <code class="code">(parse_smtlib_file c ...; get_smtlib_parse_results c)</code>

<p>

  Recommended for functional style interface to the SMT-LIB parser.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_string_x"><code class="code">Z3.parse_smtlib_string_x</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALparse_smtlib_file"><code class="code">Z3.parse_smtlib_file</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_smtlib_parse_results"><code class="code">Z3.get_smtlib_parse_results</code></a></li>
</ul>
<br>
</div>
<br><code><span id="TYPEsymbol_refined"><span class="keyword">type</span> <code class="type"></code>symbol_refined</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Symbol_int</span> <span class="keyword">of</span> <code class="type">int</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Symbol_string</span> <span class="keyword">of</span> <code class="type">string</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Symbol_unknown</span></code></td>

</tr></table>

<div class="info">
[ <code class="code"> symbol_refined </code> ] is the refinement of a <a href="Z3.html#TYPEsymbol"><code class="code">Z3.symbol</code></a> .

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALsymbol_refine"><code class="code">Z3.symbol_refine</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_symbol_kind"><code class="code">Z3.get_symbol_kind</code></a></li>
</ul>
<br>
</div>

<pre><span id="VALsymbol_refine"><span class="keyword">val</span> symbol_refine</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsymbol">symbol</a> -> <a href="Z3.html#TYPEsymbol_refined">symbol_refined</a></code></pre><div class="info">
[ <code class="code"> symbol_refine c s </code> ] is the refined symbol of <code class="code">s</code>.

<p>
<ul>
<li><b>See also</b>:  <a href="Z3.html#TYPEsymbol_refined"><code class="code">Z3.symbol_refined</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_symbol_kind"><code class="code">Z3.get_symbol_kind</code></a></li>
</ul>
<br>
</div>
<br>
[ <code class="code"> sort_refined </code> ] is the refinement of a <a href="Z3.html#TYPEsort"><code class="code">Z3.sort</code></a> .

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALsort_refine"><code class="code">Z3.sort_refine</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
<br><code><span id="TYPEsort_refined"><span class="keyword">type</span> <code class="type"></code>sort_refined</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_uninterpreted</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEsymbol">symbol</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_bool</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_int</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_real</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_bv</span> <span class="keyword">of</span> <code class="type">int</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_array</span> <span class="keyword">of</span> <code class="type">(<a href="Z3.html#TYPEsort">sort</a> * <a href="Z3.html#TYPEsort">sort</a>)</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_datatype</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEdatatype_constructor_refined">datatype_constructor_refined</a> array</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_relation</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_finite_domain</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Sort_unknown</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEsymbol">symbol</a></code></code></td>

</tr></table>


<pre><span id="VALsort_refine"><span class="keyword">val</span> sort_refine</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEsort">sort</a> -> <a href="Z3.html#TYPEsort_refined">sort_refined</a></code></pre><div class="info">
[ <code class="code"> sort_refine c t </code> ] is the refined sort of <code class="code">t</code>.

<p>
<ul>
<li><b>See also</b>:  <a href="Z3.html#TYPEsort_refined"><code class="code">Z3.sort_refined</code></a>
</li>
<li><b>See also</b>: <a href="Z3.html#VALget_sort_kind"><code class="code">Z3.get_sort_kind</code></a></li>
</ul>
<br>
</div>
<br><code><span id="TYPEbinder_type"><span class="keyword">type</span> <code class="type"></code>binder_type</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Forall</span></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Exists</span></code></td>

</tr></table>

<div class="info">
[ <code class="code"> binder_type </code> ] is a universal or existential quantifier.

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#TYPEterm_refined"><code class="code">Z3.term_refined</code></a></li>
</ul>
<br>
</div>

<br><code><span id="TYPEnumeral_refined"><span class="keyword">type</span> <code class="type"></code>numeral_refined</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Numeral_small</span> <span class="keyword">of</span> <code class="type">int64 * int64</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Numeral_large</span> <span class="keyword">of</span> <code class="type">string</code></code></td>

</tr></table>

<div class="info">
[ <code class="code"> numeral_refined </code> ] is the refinement of a numeral .

<p>

  Numerals whose fractional representation can be fit with

  64 bit integers are treated as small.<br>
</div>

<br><code><span id="TYPEterm_refined"><span class="keyword">type</span> <code class="type"></code>term_refined</span> = </code><table class="typetable">
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Term_app</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEdecl_kind">decl_kind</a> * <a href="Z3.html#TYPEfunc_decl">func_decl</a> * <a href="Z3.html#TYPEast">ast</a> array</code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Term_quantifier</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEbinder_type">binder_type</a> * int * <a href="Z3.html#TYPEast">ast</a> array array * (<a href="Z3.html#TYPEsymbol">symbol</a> * <a href="Z3.html#TYPEsort">sort</a>) array<br>        * <a href="Z3.html#TYPEast">ast</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Term_numeral</span> <span class="keyword">of</span> <code class="type"><a href="Z3.html#TYPEnumeral_refined">numeral_refined</a> * <a href="Z3.html#TYPEsort">sort</a></code></code></td>

</tr>
<tr>
<td align="left" valign="top" >
<code><span class="keyword">|</span></code></td>
<td align="left" valign="top" >
<code><span class="constructor">Term_var</span> <span class="keyword">of</span> <code class="type">int * <a href="Z3.html#TYPEsort">sort</a></code></code></td>

</tr></table>

<div class="info">
[ <code class="code"> term_refined </code> ] is the refinement of a <a href="Z3.html#TYPEast"><code class="code">Z3.ast</code></a> .

<p>
<ul>
<li><b>See also</b>: <a href="Z3.html#VALterm_refine"><code class="code">Z3.term_refine</code></a></li>
</ul>
<br>
</div>

<pre><span id="VALterm_refine"><span class="keyword">val</span> term_refine</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEterm_refined">term_refined</a></code></pre><div class="info">
[ <code class="code"> term_refine c a </code> ] is the refined term of <code class="code">a</code>.

<p>
<ul>
<li><b>See also</b>:  <a href="Z3.html#TYPEterm_refined"><code class="code">Z3.term_refined</code></a></li>
</ul>
<br>
</div>
<pre><span id="VALmk_theory"><span class="keyword">val</span> mk_theory</span> : <code class="type"><a href="Z3.html#TYPEcontext">context</a> -> string -> <a href="Z3.html#TYPEtheory">theory</a></code></pre><div class="info">
[ <code class="code">mk_theory c name </code> ] create a custom theory.<br>
</div>
<pre><span id="VALset_delete_callback"><span class="keyword">val</span> set_delete_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_delete_callback th cb</code> ] set callback when theory gets deleted.<br>
</div>
<pre><span id="VALset_reduce_app_callback"><span class="keyword">val</span> set_reduce_app_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEfunc_decl">func_decl</a> -> <a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> option) -> unit</code></pre><div class="info">
[ <code class="code">set_reduce_app_callback th cb</code> ] set callback for simplifying theory terms.<br>
</div>
<pre><span id="VALset_reduce_eq_callback"><span class="keyword">val</span> set_reduce_eq_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> option) -> unit</code></pre><div class="info">
[ <code class="code">set_reduce_eq_callback th cb</code> ] set callback for simplifying equalities over theory terms.<br>
</div>
<pre><span id="VALset_reduce_distinct_callback"><span class="keyword">val</span> set_reduce_distinct_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> array -> <a href="Z3.html#TYPEast">ast</a> option) -> unit</code></pre><div class="info">
[ <code class="code">set_reduce_distinct_callback th cb</code> ] set callback for simplifying disequalities over theory terms.<br>
</div>
<pre><span id="VALset_new_app_callback"><span class="keyword">val</span> set_new_app_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_new_app_callback th cb</code> ] set callback for registering new application.<br>
</div>
<pre><span id="VALset_new_elem_callback"><span class="keyword">val</span> set_new_elem_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_new_elem_callback th cb</code> ] set callback for registering new element.

<p>
<ul>
<li><b>See also</b>: the help for the corresponding C API function.</li>
</ul>
<br>
</div>
<pre><span id="VALset_init_search_callback"><span class="keyword">val</span> set_init_search_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_init_search_callback th cb</code> ] set callback when Z3 starts searching for a satisfying assignment.<br>
</div>
<pre><span id="VALset_push_callback"><span class="keyword">val</span> set_push_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_push_callback th cb</code> ] set callback for a logical context push.<br>
</div>
<pre><span id="VALset_pop_callback"><span class="keyword">val</span> set_pop_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_pop_callback th cb</code> ] set callback for a logical context pop.<br>
</div>
<pre><span id="VALset_restart_callback"><span class="keyword">val</span> set_restart_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><div class="info">
[ <code class="code">set_restart_callback th cb</code> ] set callback for search restart.<br>
</div>
<pre><span id="VALset_reset_callback"><span class="keyword">val</span> set_reset_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> unit) -> unit</code></pre><pre><span id="VALset_final_check_callback"><span class="keyword">val</span> set_final_check_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (unit -> bool) -> unit</code></pre><pre><span id="VALset_new_eq_callback"><span class="keyword">val</span> set_new_eq_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit) -> unit</code></pre><pre><span id="VALset_new_diseq_callback"><span class="keyword">val</span> set_new_diseq_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> <a href="Z3.html#TYPEast">ast</a> -> unit) -> unit</code></pre><pre><span id="VALset_new_assignment_callback"><span class="keyword">val</span> set_new_assignment_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> bool -> unit) -> unit</code></pre><pre><span id="VALset_new_relevant_callback"><span class="keyword">val</span> set_new_relevant_callback</span> : <code class="type"><a href="Z3.html#TYPEtheory">theory</a> -> (<a href="Z3.html#TYPEast">ast</a> -> unit) -> unit</code></pre></body></html>