This PR does some more cleanup of the includes.
#include <functional>
#include <iterator>
#include <unordered_map>
-#include <vector>
#include "base/check.h"
#include "context/cdhashmap_forward.h"
#include <cstring>
#include <iterator>
-#include <memory>
#include <string>
-#include <sstream>
#include "base/check.h"
#include "context/cdlist_forward.h"
#ifndef CVC4__CONTEXT__CDTRAIL_QUEUE_H
#define CVC4__CONTEXT__CDTRAIL_QUEUE_H
-#include "context/context.h"
#include "context/cdlist.h"
+#include "context/cdo.h"
namespace CVC4 {
namespace context {
+class Context;
template <class T>
class CDTrailQueue {
**/
#include <cstdlib>
-#include <vector>
#include <deque>
+#include <limits>
#include <new>
+#include <ostream>
+#include <vector>
#ifdef CVC4_VALGRIND
#include <valgrind/memcheck.h>
d_freeChunks.pop_front();
}
}
+#else
+
+unsigned ContextMemoryManager::getMaxAllocationSize()
+{
+ return std::numeric_limits<unsigned>::max();
+}
#endif /* CVC4_DEBUG_CONTEXT_MEMORY_MANAGER */
#ifndef CVC4__CONTEXT__CONTEXT_MM_H
#define CVC4__CONTEXT__CONTEXT_MM_H
+#ifndef CVC4_DEBUG_CONTEXT_MEMORY_MANAGER
#include <deque>
-#include <limits>
+#endif
#include <vector>
namespace CVC4 {
class ContextMemoryManager
{
public:
- static unsigned getMaxAllocationSize()
- {
- return std::numeric_limits<unsigned>::max();
- }
+ static unsigned getMaxAllocationSize();
ContextMemoryManager() { d_allocations.push_back(std::vector<char*>()); }
~ContextMemoryManager()
#include "expr/kind.h"
#include "expr/metakind.h"
#include "expr/node_value.h"
-#include "options/options.h"
namespace CVC4 {
#include "expr/node_manager.h"
#include "options/smt_options.h"
+#include "expr/lazy_proof.h"
#include "proof/proof_manager.h"
#include "smt/preprocess_proof_generator.h"
#include "theory/builtin/proof_checker.h"
#include "printer/let_binding.h"
+#include <sstream>
+
namespace CVC4 {
LetBinding::LetBinding(uint32_t thresh)
class ResourceManager;
class DecisionEngine;
class OutputManager;
+class ProofNodeManager;
class TheoryEngine;
namespace prop {
#include "smt/assertions.h"
+#include <sstream>
+
#include "expr/node_algorithm.h"
#include "options/base_options.h"
#include "options/language.h"
#include <memory>
#include <vector>
-#include "context/context.h"
#include "expr/node.h"
namespace CVC4 {
#ifndef CVC4__SMT__PREPROCESS_PROOF_GENERATOR_H
#define CVC4__SMT__PREPROCESS_PROOF_GENERATOR_H
-#include <map>
-
#include "context/cdhashmap.h"
#include "expr/lazy_proof.h"
+#include "expr/proof.h"
#include "expr/proof_set.h"
#include "expr/proof_generator.h"
-#include "expr/proof_node_manager.h"
#include "theory/trust_node.h"
namespace CVC4 {
+
+class LazyCDProof;
+class ProofNodeManager;
+
namespace smt {
/**
#include "smt/preprocessor.h"
#include "options/smt_options.h"
+#include "preprocessing/preprocessing_pass_context.h"
#include "printer/printer.h"
#include "smt/abstract_values.h"
#include "smt/assertions.h"
namespace smt {
class AbstractValues;
+class PreprocessProofGenerator;
/**
* The preprocessor module of an SMT engine.
#include "smt/process_assertions.h"
-#include <stack>
#include <utility>
#include "expr/node_manager_attributes.h"
#include "options/strings_options.h"
#include "options/uf_options.h"
#include "preprocessing/assertion_pipeline.h"
+#include "preprocessing/preprocessing_pass.h"
#include "preprocessing/preprocessing_pass_registry.h"
#include "printer/printer.h"
+#include "smt/assertions.h"
#include "smt/defined_function.h"
#include "smt/dump.h"
#include "smt/expand_definitions.h"
#include "context/cdlist.h"
#include "expr/node.h"
-#include "expr/type_node.h"
-#include "preprocessing/preprocessing_pass.h"
-#include "preprocessing/preprocessing_pass_context.h"
-#include "smt/assertions.h"
#include "util/resource_manager.h"
namespace CVC4 {
class SmtEngine;
+namespace preprocessing {
+class AssertionPipeline;
+class PreprocessingPass;
+class PreprocessingPassContext;
+}
+
namespace smt {
+class Assertions;
class ExpandDefs;
struct SmtEngineStatistics;
#include "smt/dump_manager.h"
#include "smt/interpolation_solver.h"
#include "smt/listeners.h"
+#include "smt/logic_exception.h"
#include "smt/model_blocker.h"
#include "smt/model_core_builder.h"
#include "smt/node_command.h"
#ifndef CVC4__SMT_ENGINE_H
#define CVC4__SMT_ENGINE_H
+#include <map>
+#include <memory>
#include <string>
#include <vector>
-#include <map>
#include "context/cdhashmap_forward.h"
-#include "context/cdlist_forward.h"
#include "options/options.h"
#include "smt/output_manager.h"
#include "smt/smt_mode.h"
class SmtEngineState;
class AbstractValues;
class Assertions;
-class ExprNames;
class DumpManager;
class ResourceOutListener;
class SmtNodeManagerListener;
struct SmtEngineStatistics;
class SmtScope;
-class ProcessAssertions;
class PfManager;
class UnsatCoreManager;
/* -------------------------------------------------------------------------- */
namespace theory {
- class TheoryModel;
class Rewriter;
class QuantifiersEngine;
}/* CVC4::theory namespace */
#include "smt/smt_engine.h"
#include "smt/smt_engine_state.h"
#include "smt/smt_engine_stats.h"
+#include "theory/logic_info.h"
#include "theory/theory_engine.h"
#include "theory/theory_traits.h"
#ifndef CVC4__SMT__UNSAT_CORE_MANAGER_H
#define CVC4__SMT__UNSAT_CORE_MANAGER_H
-#include "context/cdhashmap.h"
#include "context/cdlist.h"
#include "expr/node.h"
#include "expr/proof_node.h"
#include <unordered_set>
-#include "expr/node_manager.h"
#include "expr/proof.h"
#include "expr/proof_generator.h"
#include "expr/term_conversion_proof_generator.h"
#include "theory/arith/cut_log.h"
#include "theory/arith/matrix.h"
#include "theory/arith/normal_form.h"
+#include "theory/eager_proof_generator.h"
using namespace std;
class TreeLog;
class ArithVariables;
class CutInfo;
-class RowsDeleted;
class ApproximateSimplex{
public:
#include "theory/arith/arith_preprocess.h"
+#include "theory/arith/arith_state.h"
#include "theory/arith/inference_manager.h"
+#include "theory/skolem_lemma.h"
namespace CVC4 {
namespace theory {
#define CVC4__THEORY__ARITH__ARITH_PREPROCESS_H
#include "context/cdhashmap.h"
-#include "theory/arith/arith_state.h"
-#include "theory/arith/inference_manager.h"
#include "theory/arith/operator_elim.h"
#include "theory/logic_info.h"
-#include "theory/skolem_lemma.h"
namespace CVC4 {
namespace theory {
+
+class SkolemLemma;
+
namespace arith {
+class ArithState;
+class InferenceManager;
+
/**
* This module can be used for (on demand) elimination of extended arithmetic
* operators like div, mod, to_int, is_int, sqrt, and so on. It uses the
#ifndef CVC4__THEORY__ARITH__ARITH_STATIC_LEARNER_H
#define CVC4__THEORY__ARITH__ARITH_STATIC_LEARNER_H
-#include <set>
-
#include "context/cdhashmap.h"
-#include "context/context.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/delta_rational.h"
#include "util/statistics_registry.h"
namespace CVC4 {
+namespace context {
+class Context;
+}
namespace theory {
namespace arith {
#include "arith_utilities.h"
+#include <cmath>
+
using namespace CVC4::kind;
namespace CVC4 {
Rational cr = c.getConst<Rational>();
unsigned lower = 0;
- unsigned upper = pow(10, prec);
+ unsigned upper = std::pow(10, prec);
Rational den = Rational(upper);
if (cr.getDenominator() < den.getNumerator())
#ifndef CVC4__THEORY__ARITH__ARITH_UTILITIES_H
#define CVC4__THEORY__ARITH__ARITH_UTILITIES_H
-#include <math.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "context/cdhashset.h"
#include "expr/node.h"
#include "theory/arith/arithvar.h"
-#include "theory/arith/delta_rational.h"
#include "util/dense_map.h"
#include "util/integer.h"
#include "util/rational.h"
#include "smt/smt_statistics_registry.h"
#include "theory/arith/constraint.h"
#include "theory/arith/error_set.h"
+#include "theory/arith/linear_equality.h"
+#include "theory/arith/tableau.h"
using namespace std;
#include "theory/arith/callbacks.h"
+#include "expr/proof_node.h"
#include "theory/arith/proof_macros.h"
#include "theory/arith/theory_arith_private.h"
#pragma once
#include "expr/node.h"
-#include "expr/proof_node.h"
#include "theory/arith/arithvar.h"
#include "theory/arith/bound_counts.h"
#include "theory/arith/constraint_forward.h"
#include "util/rational.h"
namespace CVC4 {
+
+class ProofNode;
+
namespace theory {
namespace arith {
#include "theory/arith/congruence_manager.h"
#include "base/output.h"
+#include "expr/proof_node.h"
+#include "expr/proof_node_manager.h"
#include "smt/smt_statistics_registry.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/constraint.h"
+#include "theory/arith/partial_model.h"
+#include "theory/ee_setup_info.h"
+#include "theory/rewriter.h"
+#include "theory/uf/equality_engine.h"
+#include "theory/uf/proof_equality_engine.h"
#include "options/arith_options.h"
namespace CVC4 {
#pragma once
+#include "context/cdhashmap.h"
#include "context/cdlist.h"
#include "context/cdmaybe.h"
-#include "context/cdo.h"
#include "context/cdtrail_queue.h"
-#include "context/context.h"
-#include "expr/proof_node_manager.h"
#include "theory/arith/arithvar.h"
+#include "theory/arith/arith_utilities.h"
+#include "theory/arith/callbacks.h"
#include "theory/arith/constraint_forward.h"
-#include "theory/arith/partial_model.h"
-#include "theory/eager_proof_generator.h"
-#include "theory/ee_setup_info.h"
#include "theory/trust_node.h"
-#include "theory/uf/equality_engine.h"
-#include "theory/uf/proof_equality_engine.h"
+#include "theory/uf/equality_engine_notify.h"
#include "util/dense_map.h"
#include "util/statistics_registry.h"
namespace CVC4 {
+
+class ProofNodeManager;
+
+namespace context {
+class Context;
+class UserContext;
+}
+
namespace theory {
+
+class EagerProofGenerator;
+struct EeSetupInfo;
+
+namespace eq {
+class ProofEqEngine;
+class EqualityEngine;
+}
+
namespace arith {
+class ArithVariables;
+
class ArithCongruenceManager {
private:
context::CDRaised d_inConflict;
#include <unordered_set>
#include "base/output.h"
+#include "expr/proof_node_manager.h"
#include "smt/smt_statistics_registry.h"
+#include "theory/eager_proof_generator.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/congruence_manager.h"
#include "theory/arith/normal_form.h"
+#include "theory/arith/partial_model.h"
+#include "theory/rewriter.h"
using namespace std;
#ifndef CVC4__THEORY__ARITH__CONSTRAINT_H
#define CVC4__THEORY__ARITH__CONSTRAINT_H
-#include <list>
-#include <set>
#include <unordered_map>
#include <vector>
#include "base/configuration_private.h"
#include "context/cdlist.h"
#include "context/cdqueue.h"
-#include "context/context.h"
#include "expr/node.h"
-#include "expr/proof_node_manager.h"
#include "theory/arith/arithvar.h"
#include "theory/arith/callbacks.h"
-#include "theory/arith/congruence_manager.h"
#include "theory/arith/constraint_forward.h"
#include "theory/arith/delta_rational.h"
#include "theory/arith/proof_macros.h"
#include "theory/trust_node.h"
+#include "util/statistics_registry.h"
namespace CVC4 {
-namespace theory {
-namespace arith {
-class Comparison;
-}
-}
+
+class ProofNodeManager;
+
+namespace context {
+class Context;
}
-namespace CVC4 {
namespace theory {
+
+class EagerProofGenerator;
+
namespace arith {
+class Comparison;
+class ArithCongruenceManager;
+class ArithVariables;
+
/**
* Logs the types of different proofs.
* Current, proof types:
#include <unordered_map>
#include <map>
#include <set>
-#include <vector>
#include "expr/kind.h"
#include "theory/arith/arithvar.h"
#include "theory/arith/constraint_forward.h"
#include "util/dense_map.h"
-#include "util/statistics_registry.h"
namespace CVC4 {
namespace theory {
};
std::ostream& operator<<(std::ostream& os, const NodeLog& nl);
-class ApproximateSimplex;
class TreeLog {
private:
int next_exec_ord;
#include "base/output.h"
#include "options/arith_options.h"
#include "smt/smt_statistics_registry.h"
+#include "theory/arith/partial_model.h"
using namespace std;
#include <utility>
#include <vector>
-#include "base/output.h"
#include "context/cdlist.h"
#include "context/cdmaybe.h"
#include "context/cdo.h"
#include "context/cdqueue.h"
-#include "context/context.h"
#include "theory/arith/normal_form.h"
-#include "theory/arith/partial_model.h"
#include "util/rational.h"
#include "util/statistics_registry.h"
namespace CVC4 {
+namespace context {
+class Context;
+}
namespace theory {
namespace arith {
#include "smt/smt_statistics_registry.h"
#include "theory/arith/constraint.h"
#include "theory/arith/error_set.h"
+#include "theory/arith/linear_equality.h"
using namespace std;
class ErrorSet;
-class ErrorInfoMap;
class ComparatorPivotRule {
private:
#pragma once
#include "theory/arith/error_set.h"
+#include "theory/arith/linear_equality.h"
#include "theory/arith/simplex.h"
+#include "theory/arith/simplex_update.h"
#include "util/dense_map.h"
#include "util/statistics_registry.h"
#include "expr/node.h"
#include "theory/arith/delta_rational.h"
-#include "theory/theory.h"
#include "util/integer.h"
#include "util/maybe.h"
#include "util/rational.h"
#include "theory/arith/inference_manager.h"
#include "options/arith_options.h"
+#include "theory/arith/arith_state.h"
#include "theory/arith/theory_arith.h"
#include "theory/rewriter.h"
#ifndef CVC4__THEORY__ARITH__INFERENCE_MANAGER_H
#define CVC4__THEORY__ARITH__INFERENCE_MANAGER_H
-#include <map>
#include <vector>
-#include "theory/arith/arith_state.h"
#include "theory/inference_id.h"
-#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/inference_manager_buffered.h"
namespace CVC4 {
namespace theory {
namespace arith {
+class ArithState;
class TheoryArith;
/**
#include <poly/polyxx.h>
-#include <map>
#include <tuple>
#include <vector>
-#include "expr/kind.h"
-#include "expr/node_manager_attributes.h"
#include "theory/arith/nl/poly_conversion.h"
namespace CVC4 {
#include <poly/polyxx.h>
-#include <algorithm>
-#include <iostream>
#include <vector>
namespace CVC4 {
#include "expr/node.h"
#include "expr/proof_checker.h"
-#include "expr/proof_node.h"
namespace CVC4 {
namespace theory {
#ifdef CVC4_POLY_IMP
+#include "theory/lazy_tree_proof_generator.h"
+#include "theory/arith/nl/poly_conversion.h"
+
namespace CVC4 {
namespace theory {
namespace arith {
#include <vector>
-#include "context/cdlist.h"
#include "expr/node.h"
-#include "expr/proof_generator.h"
#include "expr/proof_set.h"
#include "theory/arith/nl/cad/cdcac_utils.h"
-#include "theory/arith/nl/poly_conversion.h"
#include "theory/lazy_tree_proof_generator.h"
namespace CVC4 {
+
+class ProofGenerator;
+
namespace theory {
namespace arith {
namespace nl {
+
+struct VariableMapper;
+
namespace cad {
/**
#include "theory/arith/nl/cad/proof_checker.h"
namespace CVC4 {
+
+class ProofNodeManager;
+
namespace theory {
namespace arith {
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/nl/ext/monomial.h"
using namespace CVC4::kind;
#include "expr/kind.h"
#include "expr/node.h"
-#include "theory/arith/nl/ext/monomial.h"
namespace CVC4 {
namespace theory {
namespace arith {
namespace nl {
+class MonomialDb;
+
/** constraint information
*
* The struct ( d_rhs, d_coeff, d_type ) represents that a literal is of the
#include "theory/arith/inference_manager.h"
#include "theory/arith/nl/ext/monomial.h"
#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/nl_lemma_utils.h"
+
namespace CVC4 {
namespace theory {
#include "theory/arith/arith_msum.h"
#include "theory/arith/inference_manager.h"
#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
namespace CVC4 {
#include <vector>
#include "expr/node.h"
-#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
+
+class CDProof;
+
namespace theory {
namespace arith {
namespace nl {
+struct ExtState;
+
class FactoringCheck
{
public:
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/inference_manager.h"
+#include "theory/arith/nl/ext/ext_state.h"
#include "theory/arith/nl/nl_model.h"
#include "theory/rewriter.h"
#include "expr/node.h"
#include "theory/arith/nl/ext/constraint.h"
-#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
namespace theory {
namespace arith {
namespace nl {
+struct ExtState;
+
class MonomialBoundsCheck
{
public:
#include "theory/arith/arith_msum.h"
#include "theory/arith/inference_manager.h"
#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/nl_lemma_utils.h"
+#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
namespace theory {
#define CVC4__THEORY__ARITH__NL__EXT__MONOMIAL_CHECK_H
#include "expr/node.h"
+#include "theory/arith/nl/ext/monomial.h"
#include "theory/theory_inference.h"
-#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
namespace theory {
namespace arith {
namespace nl {
+struct ExtState;
+
class MonomialCheck
{
public:
#include "theory/arith/arith_msum.h"
#include "theory/arith/inference_manager.h"
#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
namespace CVC4 {
#include "expr/node.h"
#include "context/cdhashset.h"
-#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
namespace theory {
namespace arith {
namespace nl {
+struct ExtState;
+
class SplitZeroCheck
{
public:
#include "theory/arith/arith_msum.h"
#include "theory/arith/inference_manager.h"
#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/ext/ext_state.h"
#include "theory/rewriter.h"
namespace CVC4 {
#ifndef CVC4__THEORY__ARITH__NL__EXT__TANGENT_PLANE_CHECK_H
#define CVC4__THEORY__ARITH__NL__EXT__TANGENT_PLANE_CHECK_H
+#include <map>
+
#include "expr/node.h"
-#include "theory/arith/nl/ext/ext_state.h"
namespace CVC4 {
namespace theory {
namespace arith {
namespace nl {
+struct ExtState;
+
class TangentPlaneCheck
{
public:
namespace CVC4 {
namespace theory {
+namespace eq {
+class EqualityEngine;
+}
namespace arith {
namespace nl {
#include "context/cdhashset.h"
#include "expr/node.h"
#include "theory/arith/nl/iand_utils.h"
-#include "theory/arith/nl/nl_lemma_utils.h"
namespace CVC4 {
namespace theory {
#define CVC4__THEORY__ARITH__IAND_TABLE_H
#include <map>
-#include <vector>
#include "expr/node.h"
#include "options/theory_options.h"
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/theory_model.h"
#include "theory/rewriter.h"
#include "expr/kind.h"
#include "expr/node.h"
-#include "theory/arith/nl/nl_lemma_utils.h"
namespace CVC4 {
namespace arith {
namespace nl {
+class NlLemma;
class NonlinearExtension;
/** Non-linear model finder
#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/arith/theory_arith.h"
#include "theory/ext_theory.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
using namespace CVC4::kind;
#include "expr/node.h"
#include "theory/arith/nl/cad_solver.h"
+#include "theory/arith/nl/ext/ext_state.h"
#include "theory/arith/nl/ext/factoring_check.h"
#include "theory/arith/nl/ext/monomial_bounds_check.h"
#include "theory/arith/nl/ext/monomial_check.h"
#include "theory/arith/nl/strategy.h"
#include "theory/arith/nl/transcendental/transcendental_solver.h"
#include "theory/ext_theory.h"
+#include "theory/theory.h"
namespace CVC4 {
namespace theory {
namespace arith {
class InferenceManager;
+class TheoryArith;
namespace nl {
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/inference_manager.h"
+#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
namespace CVC4 {
#define CVC4__THEORY__ARITH__NL__TRANSCENDENTAL__EXPONENTIAL_SOLVER_H
#include <map>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
#include "expr/node.h"
-#include "theory/arith/nl/transcendental/transcendental_state.h"
namespace CVC4 {
namespace theory {
namespace nl {
namespace transcendental {
+struct TranscendentalState;
+
/** Transcendental solver class
*
* This class implements model-based refinement schemes
#include "options/arith_options.h"
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/inference_manager.h"
+#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/rewriter.h"
namespace CVC4 {
#define CVC4__THEORY__ARITH__NL__TRANSCENDENTAL__SINE_SOLVER_H
#include <map>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
#include "expr/node.h"
#include "theory/arith/nl/transcendental/transcendental_state.h"
#include "theory/arith/arith_msum.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/inference_manager.h"
+#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
#include "expr/proof.h"
#include "theory/arith/arith_utilities.h"
+#include "theory/arith/inference_manager.h"
+#include "theory/arith/nl/nl_model.h"
#include "theory/arith/nl/transcendental/taylor_generator.h"
#include "theory/rewriter.h"
#include "expr/node.h"
#include "expr/proof_set.h"
-#include "theory/arith/inference_manager.h"
-#include "theory/arith/nl/nl_model.h"
+#include "theory/arith/nl/nl_lemma_utils.h"
#include "theory/arith/nl/transcendental/proof_checker.h"
#include "theory/arith/nl/transcendental/taylor_generator.h"
class CDProof;
namespace theory {
namespace arith {
+
+class InferenceManager;
+
namespace nl {
+
+class NlModel;
+
namespace transcendental {
/**
#define CVC4__THEORY__ARITH__NORMAL_FORM_H
#include <algorithm>
-#include <list>
#include "base/output.h"
#include "expr/node.h"
#include "expr/attribute.h"
#include "expr/bound_var_manager.h"
#include "expr/skolem_manager.h"
+#include "expr/term_conversion_proof_generator.h"
#include "options/arith_options.h"
#include "smt/logic_exception.h"
#include "theory/arith/arith_utilities.h"
#include <map>
#include "expr/node.h"
-#include "expr/term_conversion_proof_generator.h"
#include "theory/eager_proof_generator.h"
#include "theory/logic_info.h"
#include "theory/skolem_lemma.h"
namespace CVC4 {
+
+class TConvProofGenerator;
+
namespace theory {
namespace arith {
#ifndef CVC4__THEORY__ARITH__PARTIAL_MODEL_H
#define CVC4__THEORY__ARITH__PARTIAL_MODEL_H
-#include <list>
#include <vector>
#include "context/cdlist.h"
-#include "context/context.h"
#include "expr/node.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/arithvar.h"
#include "theory/arith/delta_rational.h"
namespace CVC4 {
+namespace context {
+class Context;
+}
namespace theory {
namespace arith {
#include "expr/node.h"
#include "expr/proof_checker.h"
-#include "expr/proof_node.h"
namespace CVC4 {
namespace theory {
** \todo document this file
**/
+#include "theory/arith/simplex.h"
+
#include "base/output.h"
#include "options/arith_options.h"
#include "theory/arith/constraint.h"
#include "theory/arith/error_set.h"
-#include "theory/arith/simplex.h"
-
+#include "theory/arith/linear_equality.h"
+#include "theory/arith/tableau.h"
using namespace std;
#include <unordered_map>
+#include "options/arith_options.h"
#include "theory/arith/arithvar.h"
-#include "theory/arith/delta_rational.h"
-#include "theory/arith/linear_equality.h"
#include "theory/arith/partial_model.h"
-#include "theory/arith/tableau.h"
#include "util/dense_map.h"
#include "util/result.h"
+#include "util/statistics_registry.h"
namespace CVC4 {
namespace theory {
namespace arith {
class ErrorSet;
+class LinearEqualityModule;
+class Tableau;
class SimplexDecisionProcedure {
protected:
#include "smt/smt_statistics_registry.h"
#include "theory/arith/constraint.h"
#include "theory/arith/error_set.h"
+#include "theory/arith/tableau.h"
#include "util/statistics_registry.h"
using namespace std;
#pragma once
+#include "theory/arith/linear_equality.h"
#include "theory/arith/simplex.h"
+#include "theory/arith/simplex_update.h"
#include "util/dense_map.h"
#include "util/statistics_registry.h"
#include "theory/arith/nl/nonlinear_extension.h"
#include "theory/arith/theory_arith_private.h"
#include "theory/ext_theory.h"
+#include "theory/rewriter.h"
+#include "theory/theory_model.h"
using namespace std;
using namespace CVC4::kind;
#include "theory/arith/arith_rewriter.h"
#include "theory/arith/arith_state.h"
#include "theory/arith/inference_manager.h"
-#include "theory/arith/operator_elim.h"
#include "theory/theory.h"
namespace CVC4 {
#pragma once
#include <map>
-#include <queue>
#include <vector>
#include "context/cdhashset.h"
#include "context/cdinsert_hashmap.h"
#include "context/cdlist.h"
#include "context/cdqueue.h"
-#include "context/context.h"
#include "expr/kind.h"
-#include "expr/metakind.h"
#include "expr/node.h"
#include "expr/node_builder.h"
-#include "expr/proof_generator.h"
-#include "options/arith_options.h"
-#include "smt/logic_exception.h"
-#include "smt_util/boolean_simplification.h"
#include "theory/arith/arith_static_learner.h"
#include "theory/arith/arith_utilities.h"
#include "theory/arith/arithvar.h"
#include "theory/arith/normal_form.h"
#include "theory/arith/partial_model.h"
#include "theory/arith/proof_checker.h"
-#include "theory/arith/simplex.h"
#include "theory/arith/soi_simplex.h"
#include "theory/arith/theory_arith.h"
-#include "theory/eager_proof_generator.h"
-#include "theory/rewriter.h"
-#include "theory/theory_model.h"
#include "theory/trust_node.h"
#include "theory/valuation.h"
#include "util/dense_map.h"
namespace CVC4 {
namespace theory {
+
+class EagerProofGenerator;
+class TheoryModel;
+
namespace arith {
class BranchCutInfo;
#ifndef CVC4__THEORY__ARRAYS__ARRAY_INFO_H
#define CVC4__THEORY__ARRAYS__ARRAY_INFO_H
-#include <iostream>
-#include <map>
#include <tuple>
#include <unordered_map>
#include "context/backtrackable.h"
#include "context/cdlist.h"
-#include "context/cdhashmap.h"
#include "expr/node.h"
#include "util/statistics_registry.h"
#include "expr/node.h"
#include "expr/proof_checker.h"
-#include "expr/proof_node.h"
namespace CVC4 {
namespace theory {
#include "theory/theory.h"
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
-#include "theory/uf/proof_equality_engine.h"
#include "util/statistics_registry.h"
namespace CVC4 {
#pragma once
#include "expr/node.h"
-#include "theory/theory.h"
+#include "theory/theory_id.h"
#include "context/cdlist.h"
#include "context/cdhashset.h"
#include "context/cdhashmap.h"
#include "theory/bags/bag_solver.h"
#include "theory/bags/inference_generator.h"
+#include "theory/bags/inference_manager.h"
+#include "theory/bags/normal_form.h"
+#include "theory/bags/solver_state.h"
+#include "theory/bags/term_registry.h"
#include "theory/uf/equality_engine_iterator.h"
using namespace std;
#ifndef CVC4__THEORY__BAG__SOLVER_H
#define CVC4__THEORY__BAG__SOLVER_H
-#include "context/cdhashset.h"
-#include "context/cdlist.h"
-#include "theory/bags/infer_info.h"
#include "theory/bags/inference_generator.h"
-#include "theory/bags/inference_manager.h"
-#include "theory/bags/normal_form.h"
-#include "theory/bags/solver_state.h"
-#include "theory/bags/term_registry.h"
namespace CVC4 {
namespace theory {
namespace bags {
+class InferenceManager;
+class SolverState;
+class TermRegistry;
+
/** The solver for the theory of bags
*
*/
#define CVC4__THEORY__BAGS__THEORY_BAGS_REWRITER_H
#include "theory/bags/rewrites.h"
-#include "theory/rewriter.h"
+#include "theory/theory_rewriter.h"
#include "util/statistics_registry.h"
namespace CVC4 {
#ifndef CVC4__THEORY__BAGS_STATISTICS_H
#define CVC4__THEORY__BAGS_STATISTICS_H
-#include "expr/kind.h"
#include "theory/bags/rewrites.h"
#include "util/statistics_registry.h"
#include "expr/attribute.h"
#include "expr/bound_var_manager.h"
#include "expr/skolem_manager.h"
+#include "theory/bags/inference_manager.h"
+#include "theory/bags/solver_state.h"
#include "theory/uf/equality_engine.h"
namespace CVC4 {
#ifndef CVC4__THEORY__BAGS__INFERENCE_GENERATOR_H
#define CVC4__THEORY__BAGS__INFERENCE_GENERATOR_H
-#include <map>
-#include <vector>
-
#include "expr/node.h"
#include "infer_info.h"
-#include "theory/bags/inference_manager.h"
-#include "theory/bags/solver_state.h"
namespace CVC4 {
namespace theory {
namespace bags {
+class InferenceManager;
+class SolverState;
+
/**
* An inference generator class. This class is used by the core solver to
* generate lemmas
#include "theory/bags/inference_manager.h"
+#include "theory/bags/solver_state.h"
+
using namespace std;
using namespace CVC4::kind;
#ifndef CVC4__THEORY__BAGS__INFERENCE_MANAGER_H
#define CVC4__THEORY__BAGS__INFERENCE_MANAGER_H
-#include "theory/bags/infer_info.h"
-#include "theory/bags/solver_state.h"
#include "theory/inference_manager_buffered.h"
namespace CVC4 {
namespace theory {
namespace bags {
+class SolverState;
+
/** Inference manager
*
* This class manages inferences produced by the theory of bags. It manages
#define CVC4__THEORY__BAGS__THEORY_SOLVER_STATE_H
#include <map>
-#include <vector>
#include "theory/theory_state.h"
#include "theory/bags/term_registry.h"
+#include "theory/bags/inference_manager.h"
+#include "theory/bags/solver_state.h"
+
using namespace std;
using namespace CVC4::kind;
#define CVC4__THEORY__BAGS__TERM_REGISTRY_H
#include <map>
-#include <vector>
#include "context/cdhashmap.h"
-#include "theory/bags/inference_manager.h"
-#include "theory/bags/solver_state.h"
+#include "expr/node.h"
namespace CVC4 {
namespace theory {
namespace bags {
+class InferenceManager;
+class SolverState;
+
/**
* Term registry, the purpose of this class is to maintain a database of
* commonly used terms, and mappings from bags to their "proxy variables".
#include "theory/bags/theory_bags.h"
+#include "smt/logic_exception.h"
+#include "theory/bags/normal_form.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
using namespace CVC4::kind;
#ifndef CVC4__THEORY__BAGS__THEORY_BAGS_H
#define CVC4__THEORY__BAGS__THEORY_BAGS_H
-#include <memory>
-
#include "theory/bags/bag_solver.h"
#include "theory/bags/bags_rewriter.h"
#include "theory/bags/bags_statistics.h"
#include "theory/bags/inference_generator.h"
#include "theory/bags/inference_manager.h"
#include "theory/bags/solver_state.h"
+#include "theory/bags/term_registry.h"
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
-#include "theory/uf/equality_engine.h"
namespace CVC4 {
namespace theory {
#include <vector>
#include "expr/node_algorithm.h"
+#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
#include "theory/booleans/proof_circuit_propagator.h"
+#include "theory/eager_proof_generator.h"
+#include "theory/theory.h"
+#include "util/hash.h"
#include "util/utility.h"
using namespace std;
#ifndef CVC4__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H
#define CVC4__THEORY__BOOLEANS__CIRCUIT_PROPAGATOR_H
-#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>
#include "context/context.h"
#include "expr/lazy_proof_chain.h"
#include "expr/node.h"
-#include "expr/proof_generator.h"
-#include "expr/proof_node.h"
-#include "theory/eager_proof_generator.h"
-#include "theory/theory.h"
#include "theory/trust_node.h"
-#include "util/hash.h"
namespace CVC4 {
+
+class ProofGenerator;
+class ProofNode;
+
namespace theory {
+
+class EagerProofGenerator;
+
namespace booleans {
/**
#include "expr/node.h"
#include "expr/proof_checker.h"
-#include "expr/proof_node.h"
namespace CVC4 {
namespace theory {
#include <sstream>
+#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
namespace CVC4 {
#include <memory>
#include "expr/node.h"
-#include "expr/proof_node.h"
+#include "expr/proof_rule.h"
namespace CVC4 {
+
+class ProofNode;
+class ProofNodeManager;
+
namespace theory {
namespace booleans {
#ifndef CVC4__THEORY__BUILTIN__THEORY_BUILTIN_REWRITER_H
#define CVC4__THEORY__BUILTIN__THEORY_BUILTIN_REWRITER_H
-#include "theory/theory.h"
#include "theory/theory_rewriter.h"
namespace CVC4 {
#include "expr/node.h"
#include "expr/type_node.h"
-#include "theory/rewriter.h"
#include "theory/builtin/theory_builtin_rewriter.h" // for array and lambda representation
#include <sstream>
#include "theory/builtin/type_enumerator.h"
+#include "theory/builtin/theory_builtin_rewriter.h"
+
namespace CVC4 {
namespace theory {
namespace builtin {
#include "expr/kind.h"
#include "expr/type_node.h"
#include "expr/uninterpreted_constant.h"
-#include "theory/builtin/theory_builtin_rewriter.h"
#include "theory/type_enumerator.h"
#include "util/integer.h"
#include "cvc4_private.h"
#include "options/bv_options.h"
#include "prop/cnf_stream.h"
+#include "prop/sat_solver.h"
#include "prop/sat_solver_factory.h"
#include "smt/smt_statistics_registry.h"
#define CVC4__THEORY__BV__BITBLAST__AIG_BITBLASTER_H
#include "theory/bv/bitblast/bitblaster.h"
-#include "prop/sat_solver.h"
class Abc_Obj_t_;
typedef Abc_Obj_t_ Abc_Obj_t;
typedef Cnf_Dat_t_ Cnf_Dat_t;
namespace CVC4 {
+namespace prop {
+class SatSolver;
+}
namespace theory {
namespace bv {
#ifndef CVC4__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
#define CVC4__THEORY__BV__BITBLAST__EAGER_BITBLASTER_H
+#include <memory>
#include <unordered_set>
#include "theory/bv/bitblast/bitblaster.h"
-#include "prop/cnf_stream.h"
#include "prop/sat_solver.h"
namespace CVC4 {
#include "context/cdhashmap.h"
#include "context/cdlist.h"
-#include "prop/cnf_stream.h"
-#include "prop/registrar.h"
#include "prop/bv_sat_solver_notify.h"
#include "theory/bv/abstraction.h"
namespace CVC4 {
+namespace prop {
+class CnfStream;
+class NullRegistrat;
+}
namespace theory {
namespace bv {
#ifndef CVC4__THEORY__BV__BV_EAGER_SOLVER_H
#define CVC4__THEORY__BV__BV_EAGER_SOLVER_H
-#include <unordered_set>
-#include <vector>
-
#include "expr/node.h"
#include "theory/bv/bv_solver_lazy.h"
#include "theory/theory_model.h"
#ifndef CVC4__THEORY__BV__BV_INEQUALITY__GRAPH_H
#define CVC4__THEORY__BV__BV_INEQUALITY__GRAPH_H
-#include <list>
#include <queue>
#include <unordered_map>
#include <unordered_set>
+#include "context/cdhashmap.h"
#include "context/cdhashset.h"
+#include "context/cdo.h"
#include "context/cdqueue.h"
#include "context/context.h"
-#include "theory/theory.h"
-#include "theory/uf/equality_engine.h"
namespace CVC4 {
namespace theory {
#ifndef CVC4__THEORY__BV__BV_SOLVER_SIMPLE_H
#define CVC4__THEORY__BV__BV_SOLVER_SIMPLE_H
-#include <unordered_map>
-
#include "theory/bv/bitblast/proof_bitblaster.h"
#include "theory/bv/bv_solver.h"
#include "theory/bv/proof_checker.h"
#include "theory/bv/bv_quick_check.h"
#include "theory/bv/bv_solver_lazy.h"
#include "theory/bv/theory_bv_utils.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
using namespace CVC4::context;
#include <unordered_map>
#include <unordered_set>
-#include "context/cdhashmap.h"
#include "context/cdhashset.h"
#include "theory/bv/bv_subtheory.h"
#include "theory/ext_theory.h"
#include "smt/smt_statistics_registry.h"
#include "theory/bv/bv_solver_lazy.h"
#include "theory/bv/theory_bv_utils.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
using namespace std;
**/
#include "theory/bv/slicer.h"
+#include <sstream>
+
#include "theory/bv/theory_bv_utils.h"
#include "theory/rewriter.h"
#ifndef CVC4__THEORY__BV__THEORY_BV_H
#define CVC4__THEORY__BV__THEORY_BV_H
-#include <unordered_map>
-
#include "theory/bv/theory_bv_rewriter.h"
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
#define CVC4__THEORY__BV__THEORY_BV_REWRITER_H
#include "theory/theory_rewriter.h"
-#include "util/statistics_registry.h"
namespace CVC4 {
namespace theory {
namespace bv {
-struct AllRewriteRules;
typedef RewriteResponse (*RewriteFunction) (TNode, bool);
class TheoryBVRewriter : public TheoryRewriter
#pragma once
#include <set>
-#include <sstream>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include "expr/node_visitor.h"
#include "prop/prop_engine.h"
#include "theory/care_graph.h"
+#include "theory/model_manager.h"
#include "theory/theory_engine.h"
namespace CVC4 {
#include "expr/node_visitor.h"
#include "theory/care_graph.h"
+#include "theory/eager_proof_generator.h"
#include "theory/ee_manager_distributed.h"
+#include "theory/model_manager.h"
#include "theory/model_manager_distributed.h"
+#include "theory/shared_solver.h"
#include "theory/shared_solver_distributed.h"
#include "theory/theory_engine.h"
#include <vector>
#include <memory>
-#include "theory/eager_proof_generator.h"
#include "theory/ee_manager.h"
-#include "theory/model_manager.h"
-#include "theory/shared_solver.h"
#include "theory/valuation.h"
namespace CVC4 {
namespace theory {
+class EagerProofGenerator;
+class ModelManager;
+class SharedSolver;
+
/**
* Manager for doing theory combination. This class is responsible for:
* (1) Initializing the various components of theory combination (equality
#ifndef CVC4__THEORY__DATATYPES__DATATYPES_REWRITER_H
#define CVC4__THEORY__DATATYPES__DATATYPES_REWRITER_H
-#include "expr/node_manager_attributes.h"
#include "theory/theory_rewriter.h"
-#include "theory/type_enumerator.h"
namespace CVC4 {
namespace theory {
#include "theory/datatypes/infer_proof_cons.h"
#include "expr/proof.h"
+#include "expr/proof_checker.h"
#include "theory/datatypes/theory_datatypes_utils.h"
+#include "theory/model_manager.h"
#include "theory/rewriter.h"
using namespace CVC4::kind;
#ifndef CVC4__THEORY__DATATYPES__INFER_PROOF_CONS_H
#define CVC4__THEORY__DATATYPES__INFER_PROOF_CONS_H
-#include <vector>
-
+#include "context/cdhashmap.h"
#include "expr/node.h"
#include "expr/proof_generator.h"
#include "theory/datatypes/inference.h"
-#include "theory/theory_proof_step_buffer.h"
namespace CVC4 {
+
+class ProofNodeManager;
+
namespace theory {
namespace datatypes {
#ifndef CVC4__THEORY__DATATYPES__INFERENCE_H
#define CVC4__THEORY__DATATYPES__INFERENCE_H
-#include "context/cdhashmap.h"
#include "expr/node.h"
-#include "theory/inference_manager_buffered.h"
#include "theory/inference_id.h"
+#include "theory/theory_inference.h"
+#include "theory/trust_node.h"
namespace CVC4 {
namespace theory {
#ifndef CVC4__THEORY__DATATYPES__INFERENCE_MANAGER_H
#define CVC4__THEORY__DATATYPES__INFERENCE_MANAGER_H
-#include "context/cdhashmap.h"
#include "expr/node.h"
#include "theory/datatypes/infer_proof_cons.h"
-#include "theory/datatypes/inference.h"
#include "theory/inference_manager_buffered.h"
namespace CVC4 {
#include "options/datatypes_options.h"
#include "options/quantifiers_options.h"
#include "printer/printer.h"
+#include "smt/logic_exception.h"
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/datatypes/theory_datatypes_utils.h"
+#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/sygus_explain.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
using namespace CVC4;
#include "context/cdhashmap.h"
#include "context/cdhashset.h"
-#include "context/cdlist.h"
-#include "context/cdo.h"
#include "context/context.h"
-#include "expr/dtype.h"
#include "expr/node.h"
#include "theory/datatypes/sygus_simple_sym.h"
#include "theory/decision_manager.h"
-#include "theory/quantifiers/sygus/sygus_explain.h"
-#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/quantifiers/term_database.h"
namespace CVC4 {
namespace theory {
+namespace quantifiers {
+class SynthConjecture;
+}
namespace datatypes {
class InferenceManager;
#ifndef CVC4__THEORY__DATATYPES__SIMPLE_SYM_BREAK_H
#define CVC4__THEORY__DATATYPES__SIMPLE_SYM_BREAK_H
-#include <map>
#include "expr/dtype.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "options/quantifiers_options.h"
#include "options/smt_options.h"
#include "options/theory_options.h"
+#include "smt/logic_exception.h"
#include "theory/datatypes/datatypes_rewriter.h"
#include "theory/datatypes/theory_datatypes_type_rules.h"
#include "theory/datatypes/theory_datatypes_utils.h"
+#include "theory/logic_info.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "theory/theory_model.h"
+#include "theory/theory_state.h"
#include "theory/type_enumerator.h"
#include "theory/valuation.h"
#include "theory/datatypes/sygus_extension.h"
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
+#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
#include "util/hash.h"
#ifndef CVC4__THEORY__DECISION_STRATEGY__H
#define CVC4__THEORY__DECISION_STRATEGY__H
-#include <map>
#include "context/cdo.h"
#include "expr/node.h"
#include "theory/valuation.h"
#include "theory/eager_proof_generator.h"
#include "expr/proof.h"
+#include "expr/proof_node.h"
#include "expr/proof_node_manager.h"
namespace CVC4 {
#include "context/cdhashmap.h"
#include "expr/node.h"
#include "expr/proof_generator.h"
-#include "expr/proof_node.h"
+#include "expr/proof_rule.h"
#include "theory/trust_node.h"
namespace CVC4 {
+
+class ProofNode;
+class ProofNodeManager;
+
namespace theory {
/**
#include "theory/quantifiers_engine.h"
#include "theory/shared_solver.h"
#include "theory/theory_engine.h"
+#include "theory/uf/equality_engine.h"
namespace CVC4 {
namespace theory {
#ifndef CVC4__THEORY__EE_MANAGER_DISTRIBUTED__H
#define CVC4__THEORY__EE_MANAGER_DISTRIBUTED__H
-#include <map>
#include <memory>
#include "theory/ee_manager.h"
-#include "theory/uf/equality_engine.h"
namespace CVC4 {
namespace theory {
+namespace eq {
+class EqualityEngine;
+}
+
/**
* The (distributed) equality engine manager. This encapsulates an architecture
* in which all theories maintain their own copy of an equality engine.
#include "expr/node.h"
#include "theory/output_channel.h"
-#include "theory/theory.h"
+#include "theory/theory_id.h"
#include "util/statistics_registry.h"
namespace CVC4 {
namespace theory {
+class Theory;
+
/**
* An output channel for Theory that passes messages back to a TheoryEngine
* for a given Theory.
#define CVC4__THEORY__EXT_THEORY_H
#include <map>
-#include <set>
#include "context/cdhashmap.h"
#include "context/cdhashset.h"
+#include "context/cdo.h"
#include "context/context.h"
#include "expr/node.h"
-#include "theory/theory.h"
namespace CVC4 {
namespace theory {
+class OutputChannel;
+
/**
* A callback class for ExtTheory below. This class is responsible for
* determining how to apply context-dependent simplification.
#include <vector>
+#include "base/check.h"
+#include "expr/node_builder.h"
#include "theory/theory.h" // theory.h Only needed for the leaf test
#include "util/floatingpoint.h"
#include "util/floatingpoint_literal_symfpu.h"
#ifndef CVC4__THEORY__FP__FP_CONVERTER_H
#define CVC4__THEORY__FP__FP_CONVERTER_H
-#include "base/check.h"
#include "context/cdhashmap.h"
#include "context/cdlist.h"
#include "expr/node.h"
-#include "expr/node_builder.h"
#include "expr/type_node.h"
#include "theory/valuation.h"
#include "util/bitvector.h"
#include "cvc4_private.h"
+#include <iosfwd>
+
#ifndef CVC4__THEORY__INFERENCE_ID_H
#define CVC4__THEORY__INFERENCE_ID_H
-#include <map>
-#include <vector>
-
-#include "util/safe_print.h"
-
namespace CVC4 {
namespace theory {
#ifndef CVC4__THEORY__INFERENCE_MANAGER_BUFFERED_H
#define CVC4__THEORY__INFERENCE_MANAGER_BUFFERED_H
-#include "context/cdhashmap.h"
#include "expr/node.h"
#include "theory/theory_inference.h"
#include "theory/theory_inference_manager.h"
#include <string>
#include <vector>
-#include "expr/kind.h"
+
+#include "theory/theory_id.h"
namespace CVC4 {
#include "options/theory_options.h"
#include "prop/prop_engine.h"
#include "theory/quantifiers_engine.h"
+#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/fmf/model_builder.h"
#include "theory/theory_engine.h"
#include "theory/ee_manager.h"
#include "theory/logic_info.h"
-#include "theory/theory_model.h"
-#include "theory/theory_model_builder.h"
namespace CVC4 {
namespace theory {
+class TheoryEngineModelBuilder;
+class TheoryModel;
+
/**
* A base class for managing models. Its main feature is to implement a
* buildModel command. Overall, its behavior is specific to the kind of equality
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
+#include "theory/theory_model_builder.h"
namespace CVC4 {
namespace theory {
#ifndef CVC4__THEORY__MODEL_MANAGER_DISTRIBUTED__H
#define CVC4__THEORY__MODEL_MANAGER_DISTRIBUTED__H
-#include <memory>
-
#include "theory/ee_manager.h"
#include "theory/model_manager.h"
#ifndef CVC4__THEORY__OUTPUT_CHANNEL_H
#define CVC4__THEORY__OUTPUT_CHANNEL_H
-#include <memory>
-
-#include "expr/proof_node.h"
-#include "smt/logic_exception.h"
-#include "theory/interrupted.h"
#include "theory/trust_node.h"
#include "util/resource_manager.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4::kind;
#ifndef CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_DATABASE_H
#define CVC4__THEORY__QUANTIFIERS__CANDIDATE_REWRITE_DATABASE_H
-#include <map>
-#include <memory>
-#include <unordered_set>
#include <vector>
+
#include "theory/quantifiers/candidate_rewrite_filter.h"
#include "theory/quantifiers/expr_miner.h"
#include "theory/quantifiers/sygus_sampler.h"
#include "theory/arith/theory_arith_private.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "util/random.h"
using namespace std;
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4::kind;
#include "theory/quantifiers/term_enumeration.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "util/random.h"
using namespace CVC4;
**/
#include "theory/quantifiers/ematching/inst_match_generator_multi_linear.h"
+#include "options/quantifiers_options.h"
#include "theory/quantifiers_engine.h"
#include "theory/quantifiers/ematching/trigger_trie.h"
#include "theory/quantifiers/term_util.h"
**/
#include "theory/quantifiers/ematching/inst_match_generator_simple.h"
+#include "options/quantifiers_options.h"
#include "theory/quantifiers/ematching/trigger_term_info.h"
#include "theory/quantifiers/ematching/trigger_trie.h"
#include "theory/quantifiers/instantiate.h"
#include "theory/quantifiers/ematching/trigger.h"
#include "expr/skolem_manager.h"
+#include "options/quantifiers_options.h"
#include "theory/quantifiers/ematching/candidate_generator.h"
#include "theory/quantifiers/ematching/ho_trigger.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
#include "theory/quantifiers/ematching/inst_match_generator_simple.h"
#include "theory/quantifiers/ematching/pattern_term_selector.h"
#include "theory/quantifiers/ematching/trigger_trie.h"
+#include "theory/quantifiers/inst_match.h"
#include "theory/quantifiers/instantiate.h"
#include "theory/quantifiers/quantifiers_attributes.h"
#include "theory/quantifiers/quantifiers_inference_manager.h"
#include "theory/quantifiers/quantifiers_state.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/valuation.h"
using namespace CVC4::kind;
#ifndef CVC4__THEORY__QUANTIFIERS__TRIGGER_H
#define CVC4__THEORY__QUANTIFIERS__TRIGGER_H
-#include <map>
-
#include "expr/node.h"
-#include "options/quantifiers_options.h"
-#include "theory/quantifiers/inst_match.h"
-#include "theory/valuation.h"
namespace CVC4 {
namespace theory {
class QuantifiersEngine;
+class Valuation;
namespace quantifiers {
class QuantifiersState;
namespace inst {
class IMGenerator;
+class InstMatch;
class InstMatchGenerator;
/** A collection of nodes representing a trigger.
*
#ifndef CVC4__THEORY__QUANTIFIERS__VAR_MATCH_GENERATOR_H
#define CVC4__THEORY__QUANTIFIERS__VAR_MATCH_GENERATOR_H
-#include <map>
#include "expr/node.h"
#include "theory/quantifiers/ematching/inst_match_generator.h"
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4;
#include "theory/quantifiers/fmf/model_engine.h"
#include "theory/quantifiers/instantiate.h"
#include "theory/quantifiers/quant_rep_bound_ext.h"
+#include "theory/quantifiers/quantifiers_state.h"
#include "theory/quantifiers_engine.h"
#include "theory/uf/equality_engine.h"
#define CVC4__THEORY__QUANTIFIERS__MODEL_BUILDER_H
#include "expr/node.h"
-#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/inst_match.h"
-#include "theory/quantifiers/quantifiers_state.h"
#include "theory/theory_model_builder.h"
namespace CVC4 {
namespace theory {
namespace quantifiers {
+class FirstOrderModel;
+class QuantifiersState;
class QModelBuilder : public TheoryEngineModelBuilder
{
#ifndef CVC4__INST_STRATEGY_ENUMERATIVE_H
#define CVC4__INST_STRATEGY_ENUMERATIVE_H
-#include "context/context.h"
-#include "context/context_mm.h"
#include "theory/quantifiers/quant_module.h"
-#include "theory/quantifiers/relevant_domain.h"
namespace CVC4 {
namespace theory {
namespace quantifiers {
+class RelevantDomain;
+
/** Enumerative instantiation
*
* This class implements enumerative instantiation described
#include "theory/quantifiers/instantiate.h"
+#include "expr/lazy_proof.h"
#include "expr/node_algorithm.h"
#include "expr/proof_node_manager.h"
#include "options/printer_options.h"
#include "options/quantifiers_options.h"
#include "options/smt_options.h"
#include "proof/proof_manager.h"
+#include "smt/logic_exception.h"
#include "smt/smt_statistics_registry.h"
#include "theory/quantifiers/cegqi/inst_strategy_cegqi.h"
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers/term_enumeration.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
using namespace CVC4::context;
#include <map>
#include "context/cdhashset.h"
-#include "expr/lazy_proof.h"
#include "expr/node.h"
#include "expr/proof.h"
#include "theory/quantifiers/inst_match_trie.h"
#include "util/statistics_registry.h"
namespace CVC4 {
+
+class LazyCDProof;
+
namespace theory {
class QuantifiersEngine;
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
using namespace std;
#include "options/quantifiers_options.h"
#include "theory/quantifiers_engine.h"
+#include "theory/quantifiers/relevant_domain.h"
namespace CVC4 {
namespace theory {
#include "theory/quantifiers/sygus/ce_guided_single_inv.h"
#include "options/quantifiers_options.h"
+#include "smt/logic_exception.h"
#include "smt/smt_engine.h"
#include "smt/smt_engine_scope.h"
#include "smt/smt_statistics_registry.h"
#include "theory/quantifiers/term_enumeration.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
using namespace CVC4::kind;
#include "theory/quantifiers/term_enumeration.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
using namespace std;
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4::kind;
#include "theory/quantifiers/sygus/transition_inference.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
#include "util/random.h"
#include "theory/quantifiers/sygus/cegis_unif.h"
+#include "expr/sygus_datatype.h"
#include "options/base_options.h"
#include "options/quantifiers_options.h"
#include "printer/printer.h"
#ifndef CVC4__THEORY__QUANTIFIERS__EXAMPLE_INFER_H
#define CVC4__THEORY__QUANTIFIERS__EXAMPLE_INFER_H
-#include "context/cdhashmap.h"
-#include "theory/quantifiers/sygus/sygus_module.h"
#include "theory/quantifiers/sygus/sygus_unif_io.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "expr/node_algorithm.h"
#include "options/datatypes_options.h"
#include "options/quantifiers_options.h"
+#include "smt/logic_exception.h"
#include "theory/datatypes/theory_datatypes_utils.h"
#include "theory/quantifiers/sygus/synth_engine.h"
+#include "theory/quantifiers/sygus/type_node_id_trie.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
#include "expr/dtype.h"
#include "expr/dtype_cons.h"
+#include "smt/logic_exception.h"
#include "theory/datatypes/theory_datatypes_utils.h"
+#include "theory/quantifiers/sygus/sygus_invariance.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
using namespace CVC4::kind;
#include <vector>
#include "expr/node.h"
-#include "theory/quantifiers/sygus/sygus_invariance.h"
namespace CVC4 {
namespace theory {
namespace quantifiers {
+class SygusInvarianceTest;
+class TermDbSygus;
+
/** Recursive term builder
*
* This is a utility used to generate variants
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
+#include "theory/rewriter.h"
#include "theory/strings/word.h"
using namespace CVC4::kind;
#include <map>
#include <memory>
-#include <string>
#include <vector>
#include "expr/node.h"
#include "theory/quantifiers/sygus/sygus_pbe.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
using namespace std;
#ifndef CVC4__THEORY__QUANTIFIERS__SYGUS_MODULE_H
#define CVC4__THEORY__QUANTIFIERS__SYGUS_MODULE_H
-#include <map>
#include <vector>
#include "expr/node.h"
#include "options/quantifiers_options.h"
#include "theory/quantifiers/sygus/example_infer.h"
+#include "theory/quantifiers/sygus/sygus_unif_io.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
#ifndef CVC4__THEORY__QUANTIFIERS__SYGUS_PBE_H
#define CVC4__THEORY__QUANTIFIERS__SYGUS_PBE_H
-#include "context/cdhashmap.h"
#include "theory/quantifiers/sygus/sygus_module.h"
-#include "theory/quantifiers/sygus/sygus_unif_io.h"
namespace CVC4 {
namespace theory {
namespace quantifiers {
+class SygusUnifIo;
class SynthConjecture;
/** SygusPbe
#ifndef CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_QE_PREPROC_H
#define CVC4__THEORY__QUANTIFIERS__SYGUS__SYGUS_QE_PREPROC_H
-#include <string>
-#include <vector>
#include "expr/node.h"
-#include "expr/type_node.h"
namespace CVC4 {
namespace theory {
#include "smt/smt_engine_scope.h"
#include "smt/smt_statistics_registry.h"
#include "theory/datatypes/theory_datatypes_utils.h"
+#include "theory/logic_info.h"
#include "theory/quantifiers/cegqi/ceg_instantiator.h"
#include "theory/quantifiers/sygus/sygus_grammar_norm.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include <unordered_set>
#include "expr/node.h"
-#include "theory/logic_info.h"
namespace CVC4 {
+
+class LogicInfo;
+
namespace theory {
class QuantifiersEngine;
namespace quantifiers {
-class CegConjecture;
class TermDbSygus;
/** SygusRepairConst
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "theory/strings/word.h"
#include "util/random.h"
#include "printer/printer.h"
#include "theory/quantifiers/sygus/synth_conjecture.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
+#include "theory/rewriter.h"
#include "util/random.h"
#include <math.h>
#include "options/datatypes_options.h"
#include "options/quantifiers_options.h"
#include "printer/printer.h"
+#include "smt/logic_exception.h"
#include "smt/smt_engine_scope.h"
#include "smt/smt_statistics_registry.h"
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/quantifiers/sygus/sygus_enumerator.h"
#include "theory/quantifiers/sygus/sygus_enumerator_basic.h"
#include "theory/quantifiers/sygus/synth_engine.h"
+#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
+#include "theory/quantifiers/sygus/sygus_pbe.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
#include "theory/smt_engine_subsolver.h"
using namespace CVC4::kind;
#include <memory>
-#include "theory/decision_manager.h"
#include "theory/quantifiers/expr_miner_manager.h"
#include "theory/quantifiers/sygus/ce_guided_single_inv.h"
#include "theory/quantifiers/sygus/cegis.h"
#include "theory/quantifiers/sygus/cegis_unif.h"
#include "theory/quantifiers/sygus/example_eval_cache.h"
#include "theory/quantifiers/sygus/example_infer.h"
-#include "theory/quantifiers/sygus/sygus_grammar_cons.h"
-#include "theory/quantifiers/sygus/sygus_pbe.h"
#include "theory/quantifiers/sygus/sygus_process_conj.h"
#include "theory/quantifiers/sygus/sygus_repair_const.h"
#include "theory/quantifiers/sygus/sygus_stats.h"
namespace theory {
namespace quantifiers {
+class CegGrammarConstructor;
+class SygusPbe;
class SygusStatistics;
/**
#include "expr/node_algorithm.h"
#include "theory/arith/arith_msum.h"
#include "theory/quantifiers/term_util.h"
+#include "theory/rewriter.h"
using namespace CVC4::kind;
#include "expr/sygus_datatype.h"
#include "theory/datatypes/sygus_datatype_utils.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
+#include "theory/quantifiers/sygus/type_node_id_trie.h"
using namespace CVC4::kind;
#define CVC4__THEORY__QUANTIFIERS__SYGUS__TYPE_INFO_H
#include <map>
-#include <unordered_set>
#include "expr/node.h"
-#include "theory/quantifiers/sygus/type_node_id_trie.h"
namespace CVC4 {
namespace theory {
namespace theory {
namespace quantifiers {
-class TermDbSygus;
-
/**
* A trie indexed by types that assigns unique identifiers to nodes based on
* a vector of types.
#include "theory/quantifiers/sygus/synth_engine.h"
#include "theory/quantifiers/term_util.h"
#include "theory/quantifiers_engine.h"
+#include "theory/rewriter.h"
namespace CVC4 {
namespace theory {
#define CVC4__THEORY__QUANTIFIERS__TERM_DATABASE_H
#include <map>
-#include <unordered_set>
+#include <unordered_map>
#include "context/cdhashmap.h"
#include "context/cdhashset.h"
#include "theory/quantifiers/quantifiers_rewriter.h"
#include "theory/quantifiers/quantifiers_state.h"
#include "theory/quantifiers/quant_module.h"
+#include "theory/quantifiers/relevant_domain.h"
#include "theory/quantifiers/skolemize.h"
#include "theory/quantifiers/sygus/term_database_sygus.h"
#include "theory/quantifiers/term_util.h"
#include "theory/relevance_manager.h"
+#include <sstream>
+
using namespace CVC4::kind;
namespace CVC4 {
#include "expr/node_algorithm.h"
#include "options/sets_options.h"
#include "smt/logic_exception.h"
+#include "theory/rewriter.h"
#include "theory/sets/normal_form.h"
#include "theory/theory_model.h"
#include "theory/valuation.h"
#include "theory/sets/inference_manager.h"
#include "options/sets_options.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4::kind;
#include <memory>
+#include "smt/logic_exception.h"
#include "theory/sets/inference_manager.h"
#include "theory/sets/skolem_cache.h"
#include "theory/sets/solver_state.h"
#include "theory/shared_solver.h"
#include "expr/node_visitor.h"
+#include "theory/ee_setup_info.h"
+#include "theory/logic_info.h"
#include "theory/theory_engine.h"
namespace CVC4 {
#define CVC4__THEORY__SHARED_SOLVER__H
#include "expr/node.h"
-#include "expr/proof_node_manager.h"
-#include "theory/ee_setup_info.h"
-#include "theory/logic_info.h"
#include "theory/shared_terms_database.h"
#include "theory/term_registration_visitor.h"
#include "theory/valuation.h"
namespace CVC4 {
+class LogicInfo;
+class ProofNodeManager;
class TheoryEngine;
namespace theory {
+struct EeSetupInfo;
+
/**
* A base class for shared solver. The shared solver is the component of theory
* engine that behaves like a theory solver, and whose purpose is to ensure the
#ifndef CVC4__THEORY__SMT_ENGINE_SUBSOLVER_H
#define CVC4__THEORY__SMT_ENGINE_SUBSOLVER_H
-#include <map>
#include <memory>
#include <vector>
#ifndef CVC4__SORT_INFERENCE_H
#define CVC4__SORT_INFERENCE_H
-#include <iostream>
-#include <string>
-#include <vector>
#include <map>
+#include <vector>
+
#include "expr/node.h"
#include "expr/type_node.h"
#include "expr/sequence.h"
#include "options/strings_options.h"
+#include "theory/rewriter.h"
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
#include "base/configuration.h"
#include "options/strings_options.h"
+#include "smt/logic_exception.h"
+#include "theory/rewriter.h"
#include "theory/strings/sequences_rewriter.h"
#include "theory/strings/strings_entail.h"
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/infer_proof_cons.h"
+#include "expr/proof_node_manager.h"
#include "expr/skolem_manager.h"
#include "options/smt_options.h"
#include "options/strings_options.h"
#include <cmath>
#include "options/strings_options.h"
+#include "smt/logic_exception.h"
#include "theory/ext_theory.h"
#include "theory/strings/theory_strings_utils.h"
#include "theory/theory_model.h"
#include "theory/strings/solver_state.h"
+#include "theory/rewriter.h"
#include "theory/strings/theory_strings_utils.h"
#include "theory/strings/word.h"
#include "base/configuration.h"
#include "options/quantifiers_options.h"
+#include "smt/logic_exception.h"
#include "theory/theory_engine.h"
using namespace CVC4::theory;
#include "prop/prop_engine.h"
#include "smt/dump.h"
#include "smt/logic_exception.h"
+#include "smt/output_manager.h"
#include "theory/combination_care_graph.h"
#include "theory/decision_manager.h"
#include "theory/quantifiers/first_order_model.h"
#include "theory/quantifiers_engine.h"
#include "theory/relevance_manager.h"
#include "theory/rewriter.h"
+#include "theory/shared_solver.h"
#include "theory/theory.h"
#include "theory/theory_engine_proof_generator.h"
#include "theory/theory_id.h"
using namespace std;
-using namespace CVC4::preprocessing;
using namespace CVC4::theory;
namespace CVC4 {
#ifndef CVC4__THEORY__THEORY_ID_H
#define CVC4__THEORY__THEORY_ID_H
-#include <iostream>
+#include <iosfwd>
namespace CVC4 {
namespace theory {
#include "smt/smt_statistics_registry.h"
#include "theory/output_channel.h"
+#include "theory/rewriter.h"
#include "theory/theory.h"
#include "theory/theory_state.h"
#include "theory/uf/equality_engine.h"
#include "context/cdhashset.h"
#include "expr/node.h"
+#include "expr/proof_rule.h"
#include "theory/inference_id.h"
#include "theory/output_channel.h"
#include "theory/trust_node.h"
#include "options/theory_options.h"
#include "options/uf_options.h"
#include "smt/smt_engine.h"
+#include "theory/rewriter.h"
using namespace std;
using namespace CVC4::kind;
#include "options/smt_options.h"
#include "options/theory_options.h"
#include "options/uf_options.h"
+#include "theory/rewriter.h"
#include "theory/uf/theory_uf_model.h"
using namespace std;
#include "expr/lazy_proof.h"
#include "expr/skolem_manager.h"
+#include "smt/logic_exception.h"
#include "theory/logic_info.h"
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
#include "options/smt_options.h"
#include "options/uf_options.h"
+#include "smt/logic_exception.h"
+#include "theory/decision_manager.h"
#include "theory/quantifiers/term_database.h"
#include "theory/quantifiers_engine.h"
#include "theory/theory_engine.h"
#include "context/cdhashmap.h"
#include "context/context.h"
+#include "theory/decision_strategy.h"
#include "theory/theory.h"
#include "util/statistics_registry.h"
-#include "theory/decision_manager.h"
-
namespace CVC4 {
namespace theory {
namespace uf {
#include "theory/uf/equality_engine.h"
+#include "base/output.h"
#include "options/smt_options.h"
#include "proof/proof_manager.h"
#include "smt/smt_statistics_registry.h"
+#include "theory/rewriter.h"
+#include "theory/uf/eq_proof.h"
namespace CVC4 {
namespace theory {
#include <deque>
#include <queue>
-#include <memory>
#include <unordered_map>
#include <vector>
-#include "base/output.h"
#include "context/cdhashmap.h"
#include "context/cdo.h"
#include "expr/kind_map.h"
#include "expr/node.h"
-#include "theory/rewriter.h"
#include "theory/theory_id.h"
-#include "theory/uf/eq_proof.h"
#include "theory/uf/equality_engine_iterator.h"
#include "theory/uf/equality_engine_notify.h"
#include "theory/uf/equality_engine_types.h"
class EqClassesIterator;
class EqClassIterator;
+class EqProof;
/**
* Class for keeping an incremental congruence closure over a set of terms. It provides
#include "theory/uf/proof_equality_engine.h"
#include "expr/lazy_proof_chain.h"
+#include "expr/proof_node.h"
+#include "expr/proof_node_manager.h"
#include "theory/rewriter.h"
+#include "theory/uf/eq_proof.h"
+#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_checker.h"
using namespace CVC4::kind;
#ifndef CVC4__THEORY__UF__PROOF_EQUALITY_ENGINE_H
#define CVC4__THEORY__UF__PROOF_EQUALITY_ENGINE_H
-#include <map>
#include <vector>
#include "context/cdhashmap.h"
#include "expr/buffered_proof_generator.h"
#include "expr/lazy_proof.h"
#include "expr/node.h"
-#include "expr/proof_node.h"
-#include "expr/proof_node_manager.h"
#include "theory/eager_proof_generator.h"
-#include "theory/uf/equality_engine.h"
namespace CVC4 {
+
+class ProofNode;
+class ProofNodeManager;
+
namespace theory {
namespace eq {
+class EqualityEngine;
+
/**
* A layer on top of an EqualityEngine. The goal of this class is manage the
* use of an EqualityEngine object in such a way that the proper proofs are
#include "options/smt_options.h"
#include "options/theory_options.h"
#include "options/uf_options.h"
+#include "smt/logic_exception.h"
#include "theory/theory_model.h"
#include "theory/type_enumerator.h"
#include "theory/uf/cardinality_extension.h"
#ifndef CVC4__THEORY__UF__THEORY_UF_H
#define CVC4__THEORY__UF__THEORY_UF_H
-#include "context/cdo.h"
#include "expr/node.h"
#include "expr/node_trie.h"
#include "theory/theory.h"
#include "theory/theory_eq_notify.h"
#include "theory/theory_state.h"
-#include "theory/uf/equality_engine.h"
#include "theory/uf/proof_checker.h"
-#include "theory/uf/proof_equality_engine.h"
#include "theory/uf/symmetry_breaker.h"
#include "theory/uf/theory_uf_rewriter.h"
#include "expr/attribute.h"
#include "theory/quantifiers/first_order_model.h"
+#include "theory/rewriter.h"
+#include "theory/theory_model.h"
using namespace CVC4::kind;
#include <vector>
#include "expr/node.h"
-#include "theory/theory_model.h"
namespace CVC4 {
namespace theory {
+
+class TheoryModel;
+
namespace uf {
class UfModelTreeNode
#include "expr/node.h"
#include "options/theory_options.h"
#include "prop/prop_engine.h"
+#include "theory/assertion.h"
#include "theory/rewriter.h"
#include "theory/theory_engine.h"
#include "theory/theory_model.h"
#include "context/cdlist.h"
#include "expr/node.h"
#include "options/theory_options.h"
-#include "theory/assertion.h"
namespace CVC4 {
namespace theory {
+struct Assertion;
class TheoryModel;
class SortInference;