simon/sidekick
1
0
Fork 0
mirror of https://github.com/c-cube/sidekick.git synced 2026-01-21 16:56:41 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

deploy: e7e8873295

Browse source
This commit is contained in:
c-cube 2021-08-27 13:29:59 +00:00
parent 1fad70d0ae
commit e9675743b0
51 changed files with 51 additions and 51 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
dev/sidekick-base/Sidekick_base/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base.Lit)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-base</a> &#x00BB; <a href="../index.html">Sidekick_base</a> &#x00BB; Lit</nav><h1>Module <code>Sidekick_base.Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../index.html#module-Solver_arg">Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-Solver_arg">Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base.Lit)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-base</a> &#x00BB; <a href="../index.html">Sidekick_base</a> &#x00BB; Lit</nav><h1>Module <code>Sidekick_base.Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../index.html#module-Solver_arg">Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-Solver_arg">Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>

2
dev/sidekick-base/Sidekick_base__/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base__.Lit)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-base</a> &#x00BB; <a href="../index.html">Sidekick_base__</a> &#x00BB; Lit</nav><h1>Module <code>Sidekick_base__.Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base__.Lit)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-base</a> &#x00BB; <a href="../index.html">Sidekick_base__</a> &#x00BB; Lit</nav><h1>Module <code>Sidekick_base__.Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>

2
dev/sidekick-base/Sidekick_base__Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sidekick_base__Lit (sidekick-base.Sidekick_base__Lit)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">sidekick-base</a> &#x00BB; Sidekick_base__Lit</nav><h1>Module <code>Sidekick_base__Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sidekick_base__Lit (sidekick-base.Sidekick_base__Lit)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">sidekick-base</a> &#x00BB; Sidekick_base__Lit</nav><h1>Module <code>Sidekick_base__Lit</code></h1></header><div><div class="spec include"><div class="doc"><details open="open"><summary><span class="def"><code><span class="keyword">include</span> <a href="../../sidekick/Sidekick_core/index.html#module-type-LIT">Sidekick_core.LIT</a> <span class="keyword">with</span> <span class="keyword">module</span> <a href="../../sidekick/Sidekick_core/module-type-LIT/T/index.html">T</a> = <a href="../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></span></summary><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../Sidekick_base/index.html#module-Solver_arg">Sidekick_base.Solver_arg</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></details></div></div></div></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Solver/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick-base</a> &#x00BB; <a href="../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick-base</a> &#x00BB; <a href="../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Actions/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Solver</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Solver</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/CC/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Solver</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Solver</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Solver/Solver_internal/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../index.html">Solver</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Solver.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../index.html">Solver</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_bool</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_bool</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Actions/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/CC/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_bool/A/S/Solver_internal/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_bool.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_bool</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_data</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_data</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Actions/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_data</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_data</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/CC/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_data</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_data</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_data/A/S/Solver_internal/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_data</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_data.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_data</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_lra</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../index.html">Th_lra</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../../../../Sidekick_base/Lit/index.html#type-t">Solver_arg.Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Actions/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Actions.Lit)</title><link rel="stylesheet" href="../../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../../../index.html">A</a> &#x00BB; <a href="../../../../index.html">S</a> &#x00BB; <a href="../../../index.html">Solver_internal</a> &#x00BB; <a href="../../index.html">CC</a> &#x00BB; <a href="../index.html">Actions</a> &#x00BB; Lit</nav><h1>Module <code>Actions.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/CC/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.CC.Lit)</title><link rel="stylesheet" href="../../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../../index.html">A</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">Solver_internal</a> &#x00BB; <a href="../index.html">CC</a> &#x00BB; Lit</nav><h1>Module <code>CC.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-base/Sidekick_base_solver/Th_lra/A/S/Solver_internal/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-base.Sidekick_base_solver.Th_lra.A.S.Solver_internal.Lit)</title><link rel="stylesheet" href="../../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../../index.html">sidekick-base</a> &#x00BB; <a href="../../../../../index.html">Sidekick_base_solver</a> &#x00BB; <a href="../../../../index.html">Th_lra</a> &#x00BB; <a href="../../../index.html">A</a> &#x00BB; <a href="../../index.html">S</a> &#x00BB; <a href="../index.html">Solver_internal</a> &#x00BB; Lit</nav><h1>Module <code>Solver_internal.Lit</code></h1></header><div class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code><code> = <a href="../../Lit/index.html#type-t">Lit.t</a></code></dt></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib/Process/Solver/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib.Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../../index.html">Sidekick_smtlib</a> &#x00BB; <a href="../../index.html">Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib.Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../../index.html">Sidekick_smtlib</a> &#x00BB; <a href="../../index.html">Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib/Process/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Process (sidekick-bin.Sidekick_smtlib.Process)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-bin</a> &#x00BB; <a href="../index.html">Sidekick_smtlib</a> &#x00BB; Process</nav><h1>Module <code>Sidekick_smtlib.Process</code></h1><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;proof_file:string</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Process (sidekick-bin.Sidekick_smtlib.Process)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-bin</a> &#x00BB; <a href="../index.html">Sidekick_smtlib</a> &#x00BB; Process</nav><h1>Module <code>Sidekick_smtlib.Process</code></h1><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib__/Process/Solver/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib__.Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../../index.html">Sidekick_smtlib__</a> &#x00BB; <a href="../../index.html">Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib__.Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../../index.html">Sidekick_smtlib__</a> &#x00BB; <a href="../../index.html">Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib__/Process/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Process (sidekick-bin.Sidekick_smtlib__.Process)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-bin</a> &#x00BB; <a href="../index.html">Sidekick_smtlib__</a> &#x00BB; Process</nav><h1>Module <code>Sidekick_smtlib__.Process</code></h1><nav class="toc"><ul><li><a href="#process-statements">Process Statements</a></li></ul></nav></header><section><header><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;proof_file:string</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></section></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Process (sidekick-bin.Sidekick_smtlib__.Process)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick-bin</a> &#x00BB; <a href="../index.html">Sidekick_smtlib__</a> &#x00BB; Process</nav><h1>Module <code>Sidekick_smtlib__.Process</code></h1><nav class="toc"><ul><li><a href="#process-statements">Process Statements</a></li></ul></nav></header><section><header><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></section></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib__Process/Solver/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib__Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../index.html">Sidekick_smtlib__Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick-bin.Sidekick_smtlib__Process.Solver.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick-bin</a> &#x00BB; <a href="../../index.html">Sidekick_smtlib__Process</a> &#x00BB; <a href="../index.html">Solver</a> &#x00BB; Lit</nav><h1>Module <code>Solver.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../sidekick/Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick-bin/Sidekick_smtlib__Process/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sidekick_smtlib__Process (sidekick-bin.Sidekick_smtlib__Process)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">sidekick-bin</a> &#x00BB; Sidekick_smtlib__Process</nav><h1>Module <code>Sidekick_smtlib__Process</code></h1><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;proof_file:string</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Sidekick_smtlib__Process (sidekick-bin.Sidekick_smtlib__Process)</title><link rel="stylesheet" href="../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../index.html">sidekick-bin</a> &#x00BB; Sidekick_smtlib__Process</nav><h1>Module <code>Sidekick_smtlib__Process</code></h1><h2 id="process-statements"><a href="#process-statements" class="anchor"></a>Process Statements</h2></header><div class="spec module" id="module-Solver"><a href="#module-Solver" class="anchor"></a><code><span class="keyword">module</span> <a href="Solver/index.html">Solver</a> : <a href="../../sidekick/Sidekick_smt_solver/index.html#module-type-S">Sidekick_smt_solver.S</a> <span class="keyword">with</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-t">T.Term.t</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-t">Sidekick_base.Term.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Term/index.html#type-store">T.Term.store</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Term/index.html#type-store">Sidekick_base.Term.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-t">T.Ty.t</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-t">Sidekick_base.Ty.t</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/T/Ty/index.html#type-store">T.Ty.store</a> = <a href="../../sidekick-base/Sidekick_base__Base_types/Ty/index.html#type-store">Sidekick_base.Ty.store</a> <span class="keyword">and</span> <span class="keyword">type</span> <a href="../../sidekick/Sidekick_smt_solver/module-type-S/index.html#type-proof">proof</a> = <a href="../../sidekick-base/Sidekick_base/Proof_stub/index.html#type-t">Sidekick_base.Proof_stub.t</a></code></div><dl><dt class="spec value" id="val-th_bool"><a href="#val-th_bool" class="anchor"></a><code><span class="keyword">val</span> th_bool : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_data"><a href="#val-th_data" class="anchor"></a><code><span class="keyword">val</span> th_data : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt><dt class="spec value" id="val-th_lra"><a href="#val-th_lra" class="anchor"></a><code><span class="keyword">val</span> th_lra : <a href="Solver/index.html#type-theory">Solver.theory</a></code></dt></dl><dl><dt class="spec type" id="type-or_error"><a href="#type-or_error" class="anchor"></a><code><span class="keyword">type</span> <span>'a or_error</span></code><code> = <span><span>(<span class="type-var">'a</span>, string)</span> CCResult.t</span></code></dt></dl><div class="spec module" id="module-Check_cc"><a href="#module-Check_cc" class="anchor"></a><code><span class="keyword">module</span> <a href="Check_cc/index.html">Check_cc</a> : <span class="keyword">sig</span> ... <span class="keyword">end</span></code></div><dl><dt class="spec value" id="val-process_stmt"><a href="#val-process_stmt" class="anchor"></a><code><span class="keyword">val</span> process_stmt : <span>?&#8288;gc:bool</span> <span>&#45;&gt;</span> <span>?&#8288;restarts:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_cnf:bool</span> <span>&#45;&gt;</span> <span>?&#8288;pp_model:bool</span> <span>&#45;&gt;</span> <span>?&#8288;check:bool</span> <span>&#45;&gt;</span> <span>?&#8288;time:float</span> <span>&#45;&gt;</span> <span>?&#8288;memory:float</span> <span>&#45;&gt;</span> <span>?&#8288;progress:bool</span> <span>&#45;&gt;</span> <a href="Solver/index.html#type-t">Solver.t</a> <span>&#45;&gt;</span> <a href="../../sidekick-base/Sidekick_base__Base_types/Statement/index.html#type-t">Sidekick_base.Statement.t</a> <span>&#45;&gt;</span> <span>unit <a href="index.html#type-or_error">or_error</a></span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_arith_lra/module-type-ARG/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_arith_lra/module-type-S/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_arith_lra.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_arith_lra</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_cc/Make/argument-1-A/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_cc.Make.1-A.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_cc</a> &#x00BB; <a href="../../index.html">Make</a> &#x00BB; <a href="../index.html">1-A</a> &#x00BB; Lit</nav><h1>Module <code>1-A.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_cc.Make.1-A.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_cc</a> &#x00BB; <a href="../../index.html">Make</a> &#x00BB; <a href="../index.html">1-A</a> &#x00BB; Lit</nav><h1>Module <code>1-A.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_cc/module-type-S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_cc.S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_cc</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_cc.S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_cc</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/Monoid_of_repr/argument-1-M/SI/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_core</a> &#x00BB; <a href="../../../index.html">Monoid_of_repr</a> &#x00BB; <a href="../../index.html">1-M</a> &#x00BB; <a href="../index.html">SI</a> &#x00BB; Lit</nav><h1>Module <code>SI.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.Monoid_of_repr.1-M.SI.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_core</a> &#x00BB; <a href="../../../index.html">Monoid_of_repr</a> &#x00BB; <a href="../../index.html">1-M</a> &#x00BB; <a href="../index.html">SI</a> &#x00BB; Lit</nav><h1>Module <code>SI.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-CC_ACTIONS/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_ACTIONS.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_ACTIONS</a> &#x00BB; Lit</nav><h1>Module <code>CC_ACTIONS.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_ACTIONS.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_ACTIONS</a> &#x00BB; Lit</nav><h1>Module <code>CC_ACTIONS.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-CC_ARG/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_ARG.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_ARG</a> &#x00BB; Lit</nav><h1>Module <code>CC_ARG.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_ARG.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_ARG</a> &#x00BB; Lit</nav><h1>Module <code>CC_ARG.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-CC_S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_S</a> &#x00BB; Lit</nav><h1>Module <code>CC_S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.CC_S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">CC_S</a> &#x00BB; Lit</nav><h1>Module <code>CC_S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-LIT/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>LIT (sidekick.Sidekick_core.LIT)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick</a> &#x00BB; <a href="../index.html">Sidekick_core</a> &#x00BB; LIT</nav><h1>Module type <code>Sidekick_core.LIT</code></h1><p>Literals</p><p>Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.</p><p>The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.</p></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <a href="../index.html#module-type-TERM">TERM</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>LIT (sidekick.Sidekick_core.LIT)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick</a> &#x00BB; <a href="../index.html">Sidekick_core</a> &#x00BB; LIT</nav><h1>Module type <code>Sidekick_core.LIT</code></h1><p>Literals</p><p>Literals are a pair of a boolean-sorted term, and a sign. Positive literals are the same as their term, and negative literals are the negation of their term.</p><p>The SAT solver deals only in literals and clauses (sets of literals). Everything else belongs in the SMT solver.</p></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> <a href="T/index.html">T</a> : <a href="../index.html#module-type-TERM">TERM</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-MONOID_ARG/SI/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.MONOID_ARG.SI.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_core</a> &#x00BB; <a href="../../index.html">MONOID_ARG</a> &#x00BB; <a href="../index.html">SI</a> &#x00BB; Lit</nav><h1>Module <code>SI.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.MONOID_ARG.SI.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_core</a> &#x00BB; <a href="../../index.html">MONOID_ARG</a> &#x00BB; <a href="../index.html">SI</a> &#x00BB; Lit</nav><h1>Module <code>SI.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-SOLVER/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.SOLVER.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">SOLVER</a> &#x00BB; Lit</nav><h1>Module <code>SOLVER.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.SOLVER.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">SOLVER</a> &#x00BB; Lit</nav><h1>Module <code>SOLVER.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_core/module-type-SOLVER_INTERNAL/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.SOLVER_INTERNAL.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">SOLVER_INTERNAL</a> &#x00BB; Lit</nav><h1>Module <code>SOLVER_INTERNAL.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_core.SOLVER_INTERNAL.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_core</a> &#x00BB; <a href="../index.html">SOLVER_INTERNAL</a> &#x00BB; Lit</nav><h1>Module <code>SOLVER_INTERNAL.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../index.html#module-Fmt">Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_lit/Make/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (sidekick.Sidekick_lit.Make)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick</a> &#x00BB; <a href="../index.html">Sidekick_lit</a> &#x00BB; Make</nav><h1>Module <code>Sidekick_lit.Make</code></h1></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-T/index.html">T</a> : <a href="../../Sidekick_core/index.html#module-type-TERM">Sidekick_core.TERM</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="index.html#argument-1-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Make (sidekick.Sidekick_lit.Make)</title><link rel="stylesheet" href="../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../index.html">sidekick</a> &#x00BB; <a href="../index.html">Sidekick_lit</a> &#x00BB; Make</nav><h1>Module <code>Sidekick_lit.Make</code></h1></header><h3 class="heading">Parameters</h3><ul><li><code><a href="argument-1-T/index.html">T</a> : <a href="../../Sidekick_core/index.html#module-type-TERM">Sidekick_core.TERM</a></code></li></ul><h3 class="heading">Signature</h3><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="index.html#argument-1-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_smt_solver/Make/argument-1-A/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.Make.1-A.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../../index.html">Make</a> &#x00BB; <a href="../index.html">1-A</a> &#x00BB; Lit</nav><h1>Module <code>1-A.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.Make.1-A.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../../index.html">Make</a> &#x00BB; <a href="../index.html">1-A</a> &#x00BB; Lit</nav><h1>Module <code>1-A.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_smt_solver/module-type-ARG/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.ARG.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../index.html">ARG</a> &#x00BB; Lit</nav><h1>Module <code>ARG.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.ARG.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../index.html">ARG</a> &#x00BB; Lit</nav><h1>Module <code>ARG.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_smt_solver/module-type-S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_smt_solver.S.Lit)</title><link rel="stylesheet" href="../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../index.html">sidekick</a> &#x00BB; <a href="../../index.html">Sidekick_smt_solver</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_bool_static/Make/argument-1-A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_bool_static/module-type-ARG/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_bool_static/module-type-S/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_bool_static.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_bool_static</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_cstor/Make/argument-1-A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_cstor/module-type-ARG/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_cstor/module-type-S/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_cstor.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_cstor</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_data/Make/argument-1-A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.Make.1-A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../../index.html">Make</a> &#x00BB; <a href="../../index.html">1-A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_data/module-type-ARG/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.ARG.S.Lit)</title><link rel="stylesheet" href="../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../index.html">sidekick</a> &#x00BB; <a href="../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../index.html">ARG</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>

2
dev/sidekick/Sidekick_th_data/module-type-S/A/S/Lit/index.html
View file

@ -1,2 +1,2 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>
<html xmlns="http://www.w3.org/1999/xhtml"><head><title>Lit (sidekick.Sidekick_th_data.S.A.S.Lit)</title><link rel="stylesheet" href="../../../../../../odoc.css"/><meta charset="utf-8"/><meta name="generator" content="odoc 1.5.3"/><meta name="viewport" content="width=device-width,initial-scale=1.0"/><script src="../../../../../../highlight.pack.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div class="content"><header><nav><a href="../index.html">Up</a> – <a href="../../../../../index.html">sidekick</a> &#x00BB; <a href="../../../../index.html">Sidekick_th_data</a> &#x00BB; <a href="../../../index.html">S</a> &#x00BB; <a href="../../index.html">A</a> &#x00BB; <a href="../index.html">S</a> &#x00BB; Lit</nav><h1>Module <code>S.Lit</code></h1></header><dl><dt class="spec module" id="module-T"><a href="#module-T" class="anchor"></a><code><span class="keyword">module</span> T = <a href="../index.html#module-T">T</a></code></dt><dd><p>Literals depend on terms</p></dd></dl><dl><dt class="spec type" id="type-t"><a href="#type-t" class="anchor"></a><code><span class="keyword">type</span> t</code></dt><dd><p>A literal</p></dd></dl><dl><dt class="spec value" id="val-term"><a href="#val-term" class="anchor"></a><code><span class="keyword">val</span> term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a></code></dt><dd><p>Get the (positive) term</p></dd></dl><dl><dt class="spec value" id="val-sign"><a href="#val-sign" class="anchor"></a><code><span class="keyword">val</span> sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dd><p>Get the sign. A negated literal has sign <code>false</code>.</p></dd></dl><dl><dt class="spec value" id="val-neg"><a href="#val-neg" class="anchor"></a><code><span class="keyword">val</span> neg : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p>Take negation of literal. <code>sign (neg lit) = not (sign lit)</code>.</p></dd></dl><dl><dt class="spec value" id="val-abs"><a href="#val-abs" class="anchor"></a><code><span class="keyword">val</span> abs : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>abs lit</code> is like <code>lit</code> but always positive, i.e. <code>sign (abs lit) = true</code></p></dd></dl><dl><dt class="spec value" id="val-signed_term"><a href="#val-signed_term" class="anchor"></a><code><span class="keyword">val</span> signed_term : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> * bool</code></dt><dd><p>Return the atom and the sign</p></dd></dl><dl><dt class="spec value" id="val-atom"><a href="#val-atom" class="anchor"></a><code><span class="keyword">val</span> atom : <span>?&#8288;sign:bool</span> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-store">T.Term.store</a> <span>&#45;&gt;</span> <a href="T/Term/index.html#type-t">T.Term.t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a></code></dt><dd><p><code>atom store t</code> makes a literal out of a term, possibly normalizing its sign in the process.</p><dl><dt>parameter sign</dt><dd><p>if provided, and <code>sign=false</code>, negate the resulting lit.</p></dd></dl></dd></dl><dl><dt class="spec value" id="val-norm_sign"><a href="#val-norm_sign" class="anchor"></a><code><span class="keyword">val</span> norm_sign : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> * bool</code></dt><dd><p><code>norm_sign (+t)</code> is <code>+t, true</code>, and <code>norm_sign (-t)</code> is <code>+t, false</code>. In both cases the term is positive, and the boolean reflects the initial sign.</p></dd></dl><dl><dt class="spec value" id="val-equal"><a href="#val-equal" class="anchor"></a><code><span class="keyword">val</span> equal : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> bool</code></dt><dt class="spec value" id="val-hash"><a href="#val-hash" class="anchor"></a><code><span class="keyword">val</span> hash : <a href="index.html#type-t">t</a> <span>&#45;&gt;</span> int</code></dt><dt class="spec value" id="val-pp"><a href="#val-pp" class="anchor"></a><code><span class="keyword">val</span> pp : <span><a href="index.html#type-t">t</a> <a href="../../../../../Sidekick_core/index.html#module-Fmt">Sidekick_core.Fmt</a>.printer</span></code></dt></dl></div></body></html>