All Downloads are FREE. Search and download functionalities are using the official Maven repository.

cvc5-cvc5-1.2.0.src.prop.sat_solver.h Maven / Gradle / Ivy

The newest version!
/******************************************************************************
 * Top contributors (to current version):
 *   Dejan Jovanovic, Mathias Preiner, Aina Niemetz
 *
 * This file is part of the cvc5 project.
 *
 * Copyright (c) 2009-2024 by the authors listed in the file AUTHORS
 * in the top-level source directory and their institutional affiliations.
 * All rights reserved.  See the file COPYING in the top-level source
 * directory for licensing information.
 * ****************************************************************************
 *
 * SAT Solver.
 */

#include "cvc5_private.h"

#ifndef CVC5__PROP__SAT_SOLVER_H
#define CVC5__PROP__SAT_SOLVER_H

#include 

#include "context/cdlist.h"
#include "context/context.h"
#include "expr/node.h"
#include "proof/clause_id.h"
#include "prop/prop_proof_manager.h"
#include "prop/sat_solver_types.h"
#include "util/statistics_stats.h"

namespace cvc5::internal {

namespace prop {

class SatProofManager;
class TheoryProxy;

class SatSolver {

public:

  /** Virtual destructor */
  virtual ~SatSolver() { }

  /** Assert a clause in the solver. */
  virtual ClauseId addClause(SatClause& clause,
                             bool removable) = 0;

  /** Return true if the solver supports native xor resoning */
  virtual bool nativeXor() { return false; }

  /** Add a clause corresponding to rhs = l1 xor .. xor ln  */
  virtual ClauseId addXorClause(SatClause& clause, bool rhs, bool removable) = 0;

  /**
   * Create a new boolean variable in the solver.
   * @param isTheoryAtom is this a theory atom that needs to be asserted to
   * theory
   * @param canErase whether the sat solver can safely eliminate this variable
   *
   */
  virtual SatVariable newVar(bool isTheoryAtom, bool canErase) = 0;

  /** Create a new (or return an existing) boolean variable representing the constant true */
  virtual SatVariable trueVar() = 0;

  /** Create a new (or return an existing) boolean variable representing the constant false */
  virtual SatVariable falseVar() = 0;

  /** Check the satisfiability of the added clauses */
  virtual SatValue solve() = 0;

  /** Check the satisfiability of the added clauses */
  virtual SatValue solve(long unsigned int&) = 0;

  /** Check satisfiability under assumptions */
  virtual SatValue solve(const std::vector& assumptions)
  {
    Unimplemented() << "Solving under assumptions not implemented";
    return SAT_VALUE_UNKNOWN;
  };

  /**
   * Tell SAT solver to only do propagation on next solve().
   *
   * @return true if feature is supported, otherwise false.
   */
  virtual bool setPropagateOnly() { return false; }

  /** Interrupt the solver */
  virtual void interrupt() = 0;

  /** Call value() during the search.*/
  virtual SatValue value(SatLiteral l) = 0;

  /** Call modelValue() when the search is done.*/
  virtual SatValue modelValue(SatLiteral l) = 0;

  /** Get the current assertion level */
  virtual uint32_t getAssertionLevel() const = 0;

  /** Check if the solver is in an inconsistent state */
  virtual bool ok() const = 0;

  /**
   * Get list of unsatisfiable assumptions.
   *
   * The returned assumptions are a subset of the assumptions provided to
   * the solve method.
   * Can only be called if satisfiability check under assumptions was used and
   * if it returned SAT_VALUE_FALSE.
   */
  virtual void getUnsatAssumptions(std::vector& unsat_assumptions)
  {
    Unimplemented() << "getUnsatAssumptions not implemented";
  }

};/* class SatSolver */

class CDCLTSatSolver : public SatSolver
{
 public:
  virtual ~CDCLTSatSolver(){};

  virtual void initialize(context::Context* context,
                          prop::TheoryProxy* theoryProxy,
                          context::UserContext* userContext,
                          PropPfManager* ppm) = 0;

  virtual void push() = 0;

  virtual void pop() = 0;

  /**
   * Reset the decisions in the DPLL(T) SAT solver at the current assertion
   * level.
   */
  virtual void resetTrail() = 0;

  /**
   * Configure the preferred phase for a decision literal.
   *
   * @note This phase is always enforced when the SAT solver decides to make a
   *       decision on this variable on its own. If a decision is injected into
   *       the SAT solver via TheoryProxy::getNextDecisionRequest(), the
   *       preferred phase will only be considered if the decision was derived
   *       by the decision engine. It will be ignored if the decision was
   *       derived from a theory (the phase enforced by the theory overrides
   *       the preferred phase).
   *
   * @param lit The literal.
   */
  virtual void preferPhase(SatLiteral lit) = 0;

  virtual bool isDecision(SatVariable decn) const = 0;

  /**
   * Return whether variable has a fixed assignment.
   */
  virtual bool isFixed(SatVariable var) const = 0;

  /**
   * Return the current list of decisions made by the SAT solver.
   */
  virtual std::vector getDecisions() const = 0;

  /**
   * Return the order heap of the SAT solver, which is a priority queueue
   * of literals ordered with respect to variable activity.
   */
  virtual std::vector getOrderHeap() const = 0;

  /**
   * Get proof, which is used if option prop-proof-mode is PROOF.
   * @return a complete proof computed by this SAT solver.
   */
  virtual std::shared_ptr getProof() = 0;

  /**
   * Get proof sketch, which is used if option prop-proof-mode is SKETCH.
   * Get a rule r and additional arguments args such that the final proof
   * will be:
   *   (r :premises (c1..cn) :args (F args))
   * where F is a string corresponding to the file name of a DIMACs file
   * for an unsat core of derived clauses (input or theory lemma) c1...cn.
   * @return The above rule and arguments packaged as a std::pair.
   */
  virtual std::pair> getProofSketch() = 0;

}; /* class CDCLTSatSolver */

inline std::ostream& operator <<(std::ostream& out, prop::SatLiteral lit) {
  out << lit.toString();
  return out;
}

inline std::ostream& operator <<(std::ostream& out, const prop::SatClause& clause) {
  out << "clause:";
  for(unsigned i = 0; i < clause.size(); ++i) {
    out << " " << clause[i];
  }
  out << ";";
  return out;
}

inline std::ostream& operator <<(std::ostream& out, prop::SatValue val) {
  std::string str;
  switch(val) {
  case prop::SAT_VALUE_UNKNOWN:
    str = "_";
    break;
  case prop::SAT_VALUE_TRUE:
    str = "1";
    break;
  case prop::SAT_VALUE_FALSE:
    str = "0";
    break;
  default:
    str = "Error";
    break;
  }

  out << str;
  return out;
}

}  // namespace prop
}  // namespace cvc5::internal

#endif /* CVC5__PROP__SAT_MODULE_H */




© 2015 - 2024 Weber Informatics LLC | Privacy Policy