cadical 0.9.0

data/ext/cadical/cadical/src/lidruptracer.hpp

@@ -0,0 +1,122 @@
+#ifndef _lidruptracer_h_INCLUDED
+#define _lidruptracer_h_INCLUDED
+
+#include "file.hpp"
+#include "tracer.hpp"
+
+namespace CaDiCaL {
+
+struct LidrupClause {
+  LidrupClause *next; // collision chain link for hash table
+  uint64_t hash;      // previously computed full 64-bit hash
+  int64_t id;         // id of clause
+  std::vector<int64_t> chain;
+  std::vector<int> literals;
+};
+
+class LidrupTracer : public FileTracer {
+
+  Internal *internal;
+  File *file;
+  bool binary;
+  bool piping; // The 'file' is a pipe and needs eagerly flushing.
+
+  // hash table for conclusion
+  //
+  uint64_t num_clauses;   // number of clauses in hash table
+  uint64_t size_clauses;  // size of clause hash table
+  LidrupClause **clauses; // hash table of clauses
+  std::vector<int> imported_clause;
+  std::vector<int> assumptions;
+  std::vector<int64_t> imported_chain;
+  std::vector<int64_t> batch_weaken;
+  std::vector<int64_t> batch_delete;
+  std::vector<int64_t> batch_restore;
+
+  static const unsigned num_nonces = 4;
+
+  uint64_t nonces[num_nonces]; // random numbers for hashing
+  uint64_t last_hash;          // last computed hash value of clause
+  int64_t last_id;             // id of the last added clause
+  LidrupClause *last_clause;
+  uint64_t compute_hash (int64_t); // compute and save hash value of clause
+
+  LidrupClause *new_clause ();
+  void delete_clause (LidrupClause *);
+
+  static uint64_t reduce_hash (uint64_t hash, uint64_t size);
+
+  void enlarge_clauses (); // enlarge hash table for clauses
+  void insert ();          // insert clause in hash table
+  bool
+  find_and_delete (const int64_t); // find clause position in hash table
+
+#ifndef QUIET
+  int64_t added, deleted, weakened, restore, original, solved, batched;
+#endif
+
+  void flush_if_piping ();
+
+  void put_binary_zero ();
+  void put_binary_lit (int external_lit);
+  void put_binary_id (int64_t id, bool = true);
+
+  void lidrup_add_derived_clause (int64_t id,
+                                  const std::vector<int> &clause,
+                                  const std::vector<int64_t> &chain);
+  void
+  lidrup_delete_clause (int64_t id); //, const std::vector<int> &clause);
+  void lidrup_add_restored_clause (
+      int64_t id); //, const std::vector<int> &clause);
+  void lidrup_add_original_clause (int64_t id,
+                                   const std::vector<int> &clause);
+  void lidrup_conclude_and_delete (const std::vector<int64_t> &conclusion);
+  void lidrup_report_status (int status);
+  void lidrup_conclude_sat (const std::vector<int> &model);
+  void lidrup_conclude_unknown (const std::vector<int> &trail);
+  void lidrup_solve_query ();
+  void lidrup_batch_weaken_restore_and_delete ();
+
+public:
+  LidrupTracer (Internal *, File *file, bool);
+  ~LidrupTracer ();
+
+  // proof section:
+  void add_derived_clause (int64_t, bool, int, const std::vector<int> &,
+                           const std::vector<int64_t> &) override;
+  void add_assumption_clause (int64_t, const std::vector<int> &,
+                              const std::vector<int64_t> &) override;
+  void weaken_minus (int64_t, const std::vector<int> &) override;
+  void delete_clause (int64_t, bool, const std::vector<int> &) override;
+  void add_original_clause (int64_t, bool, const std::vector<int> &,
+                            bool = false) override;
+  void report_status (int, int64_t) override;
+  void conclude_sat (const std::vector<int> &) override;
+  void conclude_unsat (ConclusionType,
+                       const std::vector<int64_t> &) override;
+  void conclude_unknown (const std::vector<int> &) override;
+
+  void solve_query () override;
+  void add_assumption (int) override;
+  void reset_assumptions () override;
+
+  // skip
+  void begin_proof (int64_t) override {}
+  void finalize_clause (int64_t, const std::vector<int> &) override {}
+  void strengthen (int64_t) override {}
+  void add_constraint (const std::vector<int> &) override {}
+
+  // logging and file io
+  void connect_internal (Internal *i) override;
+
+#ifndef QUIET
+  void print_statistics ();
+#endif
+  bool closed () override;
+  void close (bool) override;
+  void flush (bool) override;
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/limit.cpp

@@ -0,0 +1,146 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+Limit::Limit () { memset (this, 0, sizeof *this); }
+
+/*------------------------------------------------------------------------*/
+
+double Internal::scale (double v) const {
+  const double ratio = clause_variable_ratio ();
+  const double factor = (ratio <= 2) ? 1.0 : log (ratio) / log (2);
+  double res = factor * v;
+  if (res < 1)
+    res = 1;
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+Last::Last () { memset (this, 0, sizeof *this); }
+
+/*------------------------------------------------------------------------*/
+
+Inc::Inc () {
+  memset (this, 0, sizeof *this);
+  ticks = decisions = conflicts = -1; // unlimited
+}
+
+void Internal::limit_terminate (int l) {
+  if (l <= 0 && !lim.terminate.forced) {
+    LOG ("keeping unbounded terminate limit");
+  } else if (l <= 0) {
+    LOG ("reset terminate limit to be unbounded");
+    lim.terminate.forced = 0;
+  } else {
+    lim.terminate.forced = l;
+    LOG ("new terminate limit of %d calls", l);
+  }
+}
+
+void Internal::limit_conflicts (int l) {
+  if (l < 0 && inc.conflicts < 0) {
+    LOG ("keeping unbounded conflict limit");
+  } else if (l < 0) {
+    LOG ("reset conflict limit to be unbounded");
+    inc.conflicts = -1;
+  } else {
+    inc.conflicts = l;
+    LOG ("new conflict limit of %d conflicts", l);
+  }
+}
+
+void Internal::limit_decisions (int l) {
+  if (l < 0 && inc.decisions < 0) {
+    LOG ("keeping unbounded decision limit");
+  } else if (l < 0) {
+    LOG ("reset decision limit to be unbounded");
+    inc.decisions = -1;
+  } else {
+    inc.decisions = l;
+    LOG ("new decision limit of %d decisions", l);
+  }
+}
+
+void Internal::limit_ticks (int64_t l) {
+  if (l < 0 && inc.ticks < 0) {
+    LOG ("keeping unbounded ticks limit");
+  } else if (l < 0) {
+    LOG ("reset ticks limit to be unbounded");
+    inc.ticks = -1;
+  } else {
+    inc.ticks = l;
+    LOG ("new ticks limit of %" PRId64 " ticks", l);
+  }
+}
+
+void Internal::limit_preprocessing (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid preprocessing limit %d", l);
+  } else if (!l) {
+    LOG ("reset preprocessing limit to no preprocessing");
+    inc.preprocessing = 0;
+  } else {
+    inc.preprocessing = l;
+    LOG ("new preprocessing limit of %d preprocessing rounds", l);
+  }
+}
+
+void Internal::limit_local_search (int l) {
+  if (l < 0) {
+    LOG ("ignoring invalid local search limit %d", l);
+  } else if (!l) {
+    LOG ("reset local search limit to no local search");
+    inc.localsearch = 0;
+  } else {
+    inc.localsearch = l;
+    LOG ("new local search limit of %d local search rounds", l);
+  }
+}
+
+bool Internal::is_valid_limit (const char *name) {
+  if (!strcmp (name, "terminate"))
+    return true;
+  if (!strcmp (name, "conflicts"))
+    return true;
+  if (!strcmp (name, "decisions"))
+    return true;
+  if (!strcmp (name, "preprocessing"))
+    return true;
+  if (!strcmp (name, "localsearch"))
+    return true;
+  if (!strcmp (name, "ticks"))
+    return true;
+  return false;
+}
+
+bool Internal::limit (const char *name, int l) {
+  bool res = true;
+  if (!strcmp (name, "terminate"))
+    limit_terminate (l);
+  else if (!strcmp (name, "conflicts"))
+    limit_conflicts (l);
+  else if (!strcmp (name, "decisions"))
+    limit_decisions (l);
+  else if (!strcmp (name, "preprocessing"))
+    limit_preprocessing (l);
+  else if (!strcmp (name, "localsearch"))
+    limit_local_search (l);
+  else if (!strcmp (name, "ticks"))
+    limit_ticks (l);
+  else
+    res = false;
+  return res;
+}
+
+void Internal::reset_limits () {
+  LOG ("reset limits");
+  limit_terminate (0);
+  limit_conflicts (-1);
+  limit_decisions (-1);
+  limit_preprocessing (0);
+  limit_local_search (0);
+  limit_ticks (-1);
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/limit.hpp

@@ -0,0 +1,168 @@
+#ifndef _limit_hpp_INCLUDED
+#define _limit_hpp_INCLUDED
+
+#include <cstdint>
+#include <limits>
+
+namespace CaDiCaL {
+
+struct Internal;
+
+struct Limit {
+
+  bool initialized;
+
+  int64_t conflicts;     // conflict limit if non-negative
+  int64_t decisions;     // decision limit if non-negative
+  int64_t preprocessing; // limit on preprocessing rounds
+  int64_t localsearch;   // limit on local search rounds
+  int64_t ticks;         // ticks limit if non-negative
+
+  int64_t compact;           // conflict limit for next 'compact'
+  int64_t condition;         // conflict limit for next 'condition'
+  int64_t elim;              // conflict limit for next 'elim'
+  int64_t flush;             // conflict limit for next 'flush'
+  int64_t inprobe;           // conflict limit for next 'inprobe'
+  int64_t reduce;            // conflict limit for next 'reduce'
+  int64_t rephase;           // conflict limit for next 'rephase'
+  int64_t report;            // report limit for header
+  int64_t restart;           // conflict limit for next 'restart'
+  int64_t stabilize;         // conflict/ticks limit for next 'stabilize'
+  int64_t incremental_decay; // conflict/ticks limit for next clause 'decay'
+                             // for incremental clauses
+  int64_t random_decision;   // randomized decision limit for conflicts
+
+  int keptsize;           // maximum kept size in 'reduce'
+  int keptglue;           // maximum kept glue in 'reduce'
+  int64_t recompute_tier; // conflict limit for next tier recomputation
+
+  // How often rephased during (1) or out (0) of stabilization.
+  //
+  int64_t rephased[2];
+
+  // Current elimination bound per eliminated variable.
+  //
+  int64_t elimbound;
+
+  struct {
+    int check;  // countdown to next terminator call
+    int forced; // forced termination for testing
+  } terminate;
+
+  Limit ();
+};
+
+struct Delay {
+  struct {
+    int64_t interval = 0, limit = 0;
+    bool bypass = 0;
+
+    bool delay () {
+      if (bypass)
+        return false;
+      if (limit) {
+        --limit;
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    void bump_delay () {
+      interval += interval < INT64_MAX;
+      limit = interval;
+    }
+
+    void reduce_delay () {
+      if (!interval)
+        return;
+      interval /= 2;
+      limit = interval;
+    }
+
+    void bypass_delay () { bypass = 1; }
+    void unbypass_delay () { bypass = 0; }
+  } bumpreasons;
+};
+
+struct Last {
+  struct {
+    int64_t propagations;
+  } transred;
+  struct {
+    int64_t ticks;
+  } backbone, probe, sweep, vivify, walk;
+  struct {
+    int64_t fixed, subsumephases, marked;
+  } elim;
+  struct {
+    int64_t reductions;
+  } inprobe;
+  struct {
+    int64_t conflicts;
+  } reduce, rephase;
+  struct {
+    int64_t ticks;
+    int64_t marked;
+  } ternary;
+  struct {
+    int64_t fixed;
+  } collect;
+  struct {
+    int64_t marked, ticks;
+  } factor;
+  struct {
+    int64_t conflicts;
+    int64_t ticks;
+    int64_t rephased;
+  } stabilize;
+  struct {
+    int64_t last_id;
+  } incremental_decay;
+  Last ();
+};
+
+struct Inc {
+  int64_t flush;         // flushing interval in terms of conflicts
+  int64_t stabilize;     // base ticks limit after first mode switch
+  int64_t conflicts;     // next conflict limit if non-negative
+  int64_t decisions;     // next decision limit if non-negative
+  int64_t ticks;         // next ticks limit if non-negative
+  int64_t preprocessing; // next preprocessing limit if non-negative
+  int64_t localsearch;   // next local search limit if non-negative
+  Inc ();
+};
+
+#define SET_EFFORT_LIMIT(LIMIT, NAME, THRESHHOLD) \
+  int64_t LIMIT; \
+  do { \
+    const int64_t OLD_LIMIT = stats.ticks.NAME; \
+    const int64_t TICKS = stats.ticks.search[0] + stats.ticks.search[1]; \
+    const int64_t LAST = last.NAME.ticks; \
+    int64_t REFERENCE = TICKS - LAST; \
+    if (!REFERENCE || !stats.conflicts) { \
+      VERBOSE (2, "last %" PRId64 " current %" PRId64 " delta %" PRId64, \
+               LAST, TICKS, REFERENCE); \
+      REFERENCE = opts.preprocessinit; \
+    } \
+    const double EFFORT = (double) opts.NAME##effort * 1e-3; \
+    const int64_t DELTA = EFFORT * REFERENCE; \
+    const int64_t THRESH = opts.NAME##thresh * clauses.size (); \
+    if (THRESHHOLD && DELTA < THRESH) { \
+      VERBOSE (2, \
+               "delaying %s with ticklimit %" PRId64 \
+               " and threshhold %" PRId64, \
+               #NAME, DELTA, THRESH); \
+      return false; \
+    } \
+    last.NAME.ticks = TICKS; \
+    const int64_t NEW_LIMIT = OLD_LIMIT + DELTA; \
+    LIMIT = NEW_LIMIT; \
+    VERBOSE (2, \
+             "new ticks limit %" PRId64 "= %" PRId64 " + %f * %" PRId64, \
+             NEW_LIMIT, OLD_LIMIT, EFFORT, REFERENCE); \
+  } while (0)
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/logging.cpp

@@ -0,0 +1,214 @@
+#ifdef LOGGING
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Logger::print_log_prefix (Internal *internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  fputs ("LOG ", stdout);
+  tout.magenta (true);
+  printf ("%d ", internal->level);
+  tout.normal ();
+}
+
+void Logger::log_empty_line (Internal *internal) {
+  internal->print_prefix ();
+  tout.magenta ();
+  const int len = internal->prefix.size (), max = 78 - len;
+  for (int i = 0; i < max; i++)
+    fputc ('-', stdout);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+void Logger::log (Internal *internal, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// It is hard to factor out the common part between the two clause loggers,
+// since they are also used in slightly different contexts.  Our attempt to
+// do so were not more readable than the current version.  See the header
+// for an explanation of the difference between the following two functions.
+
+void Logger::log (Internal *internal, const Clause *c, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (c) {
+    if (c->redundant)
+      printf (" glue %d redundant", c->glue);
+    else
+      printf (" irredundant");
+    printf (" size %d clause[%" PRId64 "]", c->size, c->id);
+    if (c->moved)
+      printf (" ... (moved)");
+    else {
+      if (internal->opts.logsort) {
+        vector<int> s;
+        for (const auto &lit : *c)
+          s.push_back (lit);
+        sort (s.begin (), s.end (), clause_lit_less_than ());
+        for (const auto &lit : s)
+          printf (" %d", lit);
+      } else {
+        for (const auto &lit : *c) {
+          printf (" %s", loglit (internal, lit).c_str ());
+        }
+      }
+    }
+  } else if (internal->level)
+    printf (" decision");
+  else
+    printf (" unit");
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+void Logger::log (Internal *internal, const Gate *g, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (g) {
+    printf ("%s%s gate[%" PRIu64 "] (arity: %zu) %s := %s",
+            special_gate_str (g->degenerated_gate).c_str (),
+            g->garbage ? " garbage" : "", g->id, g->arity (),
+            loglit (internal, g->lhs).c_str (),
+            string_of_gate (g->tag).c_str ());
+    for (const auto &lit : g->rhs) {
+      printf (" %s", loglit (internal, lit).c_str ());
+    }
+  } else
+    printf (" null gate");
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Same as above, but for the global clause 'c' (which is not a reason).
+
+void Logger::log (Internal *internal, const vector<int> &c, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (const auto &lit : c)
+      s.push_back (lit);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto &lit : s)
+      printf (" %d", lit);
+  } else {
+    for (const auto &lit : c)
+      printf (" %d", lit);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// Now for 'restore_clause' to avoid copying (without logging).
+
+void Logger::log (Internal *internal,
+                  const vector<int>::const_iterator &begin,
+                  const vector<int>::const_iterator &end, const char *fmt,
+                  ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  if (internal->opts.logsort) {
+    vector<int> s;
+    for (auto p = begin; p != end; p++)
+      s.push_back (*p);
+    sort (s.begin (), s.end (), clause_lit_less_than ());
+    for (const auto &lit : s)
+      printf (" %d", lit);
+  } else {
+    for (auto p = begin; p != end; p++)
+      printf (" %d", *p);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// for LRAT proof chains
+
+void Logger::log (Internal *internal, const vector<int64_t> &c,
+                  const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  for (const auto &id : c)
+    printf (" %" PRId64, id);
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+// for LRAT proof clauses
+
+void Logger::log (Internal *internal, const int *literals,
+                  const unsigned size, const char *fmt, ...) {
+  print_log_prefix (internal);
+  tout.magenta ();
+  va_list ap;
+  va_start (ap, fmt);
+  vprintf (fmt, ap);
+  va_end (ap);
+  for (unsigned i = 0; i < size; i++) {
+    const int lit = literals[i];
+    printf (" %d", lit);
+  }
+  fputc ('\n', stdout);
+  tout.normal ();
+  fflush (stdout);
+}
+
+string Logger::loglit (Internal *internal, int lit) {
+  std::string v = std::to_string (lit);
+  if (lit && -internal->max_var <= lit && internal->max_var >= lit) {
+    const int va = internal->val (lit);
+    if (va) {
+      v = v + "@" + std::to_string (internal->var (lit).level);
+      if (!internal->var (lit).reason)
+        v = v + "+";
+    }
+    if (va > 0)
+      v += "=1";
+    else if (va < 0)
+      v += "=-1";
+  }
+  return v;
+}
+} // namespace CaDiCaL
+
+#endif