* convert "attribute value types" into "table value types" and back
* again.
*
- * Each instantiation <T> is expected to have three members:
+ * Each instantiation < T > is expected to have three members:
*
* typename table_value_type
*
* than the (SAT and SMT) level at which it was asserted.
*
* @param node the formula to assert
+ * @param negated whether the node should be considered to be negated at the top level (or not)
+ * @param removable whether this lemma can be quietly removed based on an activity heuristic (or not)
*/
void assertLemma(TNode node, bool negated, bool removable);
-/** is k \in {LT, LEQ, EQ, GEQ, GT} */
+/** \f$ k \in {LT, LEQ, EQ, GEQ, GT} \f$ */
inline bool isRelationOperator(Kind k){
using namespace kind;
/**
* Returns the appropriate coefficient for the infinitesimal given the kind
* for an arithmetic atom inorder to represent strict inequalities as inequalities.
- * x < c becomes x <= c + (-1) * \delta
- * x > c becomes x >= x + ( 1) * \delta
+ * x < c becomes x <= c + (-1) * \f$ \delta \f$
+ * x > c becomes x >= x + ( 1) * \f$ \delta \f$
* Non-strict inequalities have a coefficient of zero.
*/
inline int deltaCoeff(Kind k){
*
* monomial := constant | var_list | (* constant' var_list')
* where
- * constant' \not\in {0,1}
+ * \f$ constant' \not\in {0,1} \f$
*
* polynomial := monomial' | (+ [monomial])
* where
/**
* Adds a row to the tableau.
* The new row is equivalent to:
- * basicVar = \sum_i coeffs[i] * variables[i]
+ * basicVar = \f$\sum_i\f$ coeffs[i] * variables[i]
* preconditions:
* basicVar is already declared to be basic
* basicVar does not have a row associated with it in the tableau.
}
}
-void TheoryEngine::propagate(TNode literal, TheoryId theory) {
+void TheoryEngine::propagate(TNode literal, theory::TheoryId theory) {
Debug("theory") << "EngineOutputChannel::propagate(" << literal << ")" << std::endl;
**
** From the paper:
**
- ** <pre>
+ ** <pre>\f[
** P := guess_permutations(phi)
** foreach {c_0, ..., c_n} \in P do
** if invariant_by_permutations(phi, {c_0, ..., c_n}) then
** T := select_terms(phi, {c_0, ..., c_n})
** cts := \empty
- ** while T != \empty && |cts| <= n do
+ ** while T != \empty \land |cts| <= n do
** t := select_most_promising_term(T, phi)
** T := T \ {t}
** cts := cts \cup used_in(t, {c_0, ..., c_n})
** end
** end
** return phi
- ** </pre>
+ ** \f]</pre>
**/
#include "theory/uf/symmetry_breaker.h"
**
** From the paper:
**
- ** <pre>
+ ** <pre>\f[
** P := guess_permutations(phi)
** foreach {c_0, ..., c_n} \in P do
** if invariant_by_permutations(phi, {c_0, ..., c_n}) then
** T := select_terms(phi, {c_0, ..., c_n})
** cts := \empty
- ** while T != \empty && |cts| <= n do
+ ** while T != \empty \land |cts| <= n do
** t := select_most_promising_term(T, phi)
** T := T \ {t}
** cts := cts \cup used_in(t, {c_0, ..., c_n})
** end
** end
** return phi
- ** </pre>
+ ** \f]</pre>
**/
#include "cvc4_private.h"
* Returns whether a node q is propositionally satisfiable.
*
* @param q Node to be checked for satisfiability.
- * @param e A number representing the effort to use between 0 (minimum effort),
- * and 1 (maximum effort).
* @pre q is a ground formula.
* @pre effort is between 0 and 1.
*/
* Returns whether a node q is a propositional tautology.
*
* @param q Node to be checked for satisfiability.
- * @param e A number representing the effort to use between 0 (minimum effort),
- * and 1 (maximum effort).
* @pre q is a ground formula.
* @pre effort is between 0 and 1.
*/