cadical 0.9.0

data/ext/cadical/cadical/src/tier.cpp

@@ -0,0 +1,189 @@
+#include "internal.hpp"
+#include "util.hpp"
+#include <string>
+
+namespace CaDiCaL {
+
+void Internal::recompute_tier () {
+  if (!opts.recomputetier)
+    return;
+
+  ++stats.tierecomputed;
+  const int64_t delta =
+      stats.tierecomputed >= 16 ? 1u << 16 : (1u << stats.tierecomputed);
+  lim.recompute_tier = stats.conflicts + delta;
+  LOG ("rescheduling in %" PRId64 " at %" PRId64 " (conflicts at %" PRId64
+       ")",
+       delta, lim.recompute_tier, stats.conflicts);
+#ifndef NDEBUG
+  uint64_t total_used = 0;
+  for (auto u : stats.used[stable])
+    total_used += u;
+  assert (total_used == stats.bump_used[stable]);
+#endif
+
+  if (!stats.bump_used[stable]) {
+    tier1[stable] = opts.reducetier1glue;
+    tier2[stable] = opts.reducetier2glue;
+    LOG ("tier1 limit = %d", tier1[stable]);
+    LOG ("tier2 limit = %d", tier2[stable]);
+    return;
+  } else {
+    uint64_t accumulated_tier1_limit =
+        stats.bump_used[stable] * opts.tier1limit / 100;
+    uint64_t accumulated_tier2_limit =
+        stats.bump_used[stable] * opts.tier2limit / 100;
+    tier1[stable] = 1;
+    tier2[stable] = 1;
+    uint64_t accumulated_used = stats.used[stable][0];
+    size_t glue = 1;
+    for (; glue < stats.used[stable].size (); ++glue) {
+      const uint64_t u = stats.used[stable][glue];
+      accumulated_used += u;
+      if (accumulated_used >= accumulated_tier1_limit) {
+        tier1[stable] = glue;
+        break;
+      }
+    }
+    for (; glue < stats.used[stable].size (); ++glue) {
+      const uint64_t u = stats.used[stable][glue];
+      accumulated_used += u;
+      if (accumulated_used >= accumulated_tier2_limit) {
+        tier2[stable] = glue;
+        break;
+      }
+    }
+  }
+
+  assert (tier1[stable] > 0);
+
+  assert (tier1[stable]);
+  assert (tier2[stable]);
+
+  if (tier1[stable] < opts.tier1minglue) {
+    LOG ("tier1 limit of %d is too low, setting %d instead", tier1[stable],
+         opts.tier1minglue);
+    tier1[stable] = opts.tier1minglue;
+  }
+  if (tier2[stable] < opts.tier2minglue) {
+    LOG ("tier2 limit of %d is too low, setting %d instead", tier2[stable],
+         opts.tier2minglue);
+    tier2[stable] = opts.tier2minglue;
+  }
+  if (tier1[stable] >= tier2[stable])
+    tier2[stable] = tier1[stable] + 1;
+  assert (tier2[stable] > tier1[stable]);
+
+  PHASE ("retiered", stats.tierecomputed,
+         "tier1 limit = %d in %s mode, tier2 limit = %d in %s mode",
+         tier1[stable], stable ? "stable" : "focused", tier2[stable],
+         stable ? "stable" : "focused");
+}
+
+void Internal::print_tier_usage_statistics () {
+  recompute_tier ();
+
+  for (auto stable : {false, true}) {
+    unsigned total_used = 0;
+    for (size_t glue = 0; glue < stats.used[stable].size (); ++glue)
+      total_used += stats.used[stable][glue];
+
+    const std::string mode = stable ? "stable" : "focused";
+    const size_t tier1 = internal->tier1[stable];
+    const size_t tier2 = internal->tier2[stable];
+    if (tier1 > tier2 && opts.reducetier1glue > opts.reducetier2glue) {
+      MSG ("tier1 > tier 2 due to the options, giving up");
+      break;
+    }
+    assert (tier1 <= tier2);
+    unsigned prefix, suffix;
+    unsigned span = tier2 - tier1 + 1;
+    const unsigned max_printed = 5;
+    assert (max_printed & 1), assert (max_printed / 2 > 0);
+    if (span > max_printed) {
+      prefix = tier1 + max_printed / 2 - 1;
+      suffix = tier2 - max_printed / 2 + 1;
+    } else
+      prefix = UINT_MAX, suffix = 0;
+
+    uint64_t accumulated_middle = 0;
+    int glue_digits = 1, clauses_digits = 1;
+    for (unsigned glue = 0; glue <= stats.used[stable].size (); glue++) {
+      if (glue < tier1)
+        continue;
+      uint64_t used = stats.used[stable][glue];
+      int tmp_glue = 0, tmp_clauses = 0;
+      if (glue <= prefix || suffix <= glue) {
+        tmp_glue = glue;
+        tmp_clauses = used;
+      } else {
+        accumulated_middle += used;
+        if (glue + 1 == suffix) {
+          tmp_glue = (prefix + 1) + (glue) + 1;
+          tmp_clauses = (accumulated_middle);
+        }
+      }
+      if (tmp_glue > glue_digits)
+        glue_digits = tmp_glue;
+      if (tmp_clauses > clauses_digits)
+        clauses_digits = tmp_clauses;
+      if (glue == tier2)
+        break;
+    }
+
+    accumulated_middle = 0;
+    uint64_t accumulated = 0;
+    std::string output;
+    for (unsigned glue = 0; glue <= stats.used[stable].size (); glue++) {
+      uint64_t used = stats.used[stable][glue];
+      accumulated += used;
+      if (glue < tier1)
+        continue;
+      if (glue <= prefix || suffix <= glue + 1) {
+        output += mode + " glue ";
+      }
+      if (glue <= prefix || suffix <= glue) {
+        std::string glue_str = std::to_string (glue);
+        output += glue_str;
+        output += " used " + std::to_string (used);
+        output +=
+            " clauses " +
+            std::to_string (percent (used, total_used)).substr (0, 5) + "%";
+        output += " accumulated " +
+                  std::to_string (percent (accumulated, total_used))
+                      .substr (0, 5) +
+                  "%";
+        if (glue == tier1)
+          output += " tier1";
+        if (glue == tier2)
+          output += " tier2";
+        MSG ("%s", output.c_str ());
+        output.clear ();
+      } else {
+        accumulated_middle += used;
+        if (glue + 1 == suffix) {
+          std::string glue_str = std::to_string (prefix + 1) + "-" +
+                                 std::to_string (suffix - 1);
+          output +=
+              glue_str + " used " + std::to_string (accumulated_middle);
+          output +=
+              " clauses " +
+              std::to_string (percent (accumulated_middle, total_used))
+                  .substr (0, 5) +
+              "%";
+          output += " accumulated " +
+                    std::to_string (percent (accumulated, total_used))
+                        .substr (0, 5) +
+                    "%";
+          MSG ("%s", output.c_str ());
+          output.clear ();
+        }
+      }
+      if (glue == tier2)
+        break;
+    }
+
+    LINE ();
+  }
+}
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/tracer.hpp

@@ -0,0 +1,186 @@
+#ifndef _tracer_hpp_INCLUDED
+#define _tracer_hpp_INCLUDED
+
+#include <cstdint>
+#include <vector>
+
+namespace CaDiCaL {
+
+struct Internal;
+
+enum ConclusionType { CONFLICT = 1, ASSUMPTIONS = 2, CONSTRAINT = 4 };
+
+// Proof tracer class to observer all possible proof events,
+// such as added or deleted clauses.
+// An implementation can decide on which events to act.
+//
+class Tracer {
+
+public:
+  Tracer () {}
+  virtual ~Tracer () {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                            Basic Events */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the tracer that a original clause has been added.
+  // Includes ID and whether the clause is redundant or irredundant
+  // Arguments: ID, redundant, clause, restored
+  //
+  virtual void add_original_clause (int64_t, bool, const std::vector<int> &,
+                                    bool = false) {}
+
+  // Notify the observer that a new clause has been derived.
+  // Includes ID and whether the clause is redundant or irredundant
+  // If antecedents are derived they will be included here.
+  // If witness != 0 it is a RAT clause.
+  // Arguments: ID, redundant, clause, witness, antecedents
+  //
+  virtual void add_derived_clause (int64_t, bool, int,
+                                   const std::vector<int> &,
+                                   const std::vector<int64_t> &) {}
+
+  // Notify the observer that a clause is deleted.
+  // Includes ID and redundant/irredundant
+  // Arguments: ID, redundant, clause
+  //
+  virtual void delete_clause (int64_t, bool, const std::vector<int> &) {}
+
+  // Notify the observer that a clause is deleted.
+  // Includes ID and redundant/irredundant
+  // Arguments: ID, redundant, clause
+  //
+  virtual void demote_clause (uint64_t, const std::vector<int> &) {}
+
+  // Notify the observer to remember that the clause might be restored later
+  // Arguments: ID, clause
+  //
+  virtual void weaken_minus (int64_t, const std::vector<int> &) {}
+
+  // Notify the observer that a clause is strengthened
+  // Arguments: ID
+  //
+  virtual void strengthen (int64_t) {}
+
+  // Notify the observer that the solve call ends with status StatusType
+  // If the status is UNSAT and an empty clause has been derived, the second
+  // argument will contain its id.
+  // Note that the empty clause is already added through add_derived_clause
+  // and finalized with finalize_clause
+  // Arguments: int, ID
+  //
+  virtual void report_status (int, int64_t) {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                   Specifically non-incremental */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the observer that a clause is finalized.
+  // Arguments: ID, clause
+  //
+  virtual void finalize_clause (int64_t, const std::vector<int> &) {}
+
+  // Notify the observer that the proof begins with a set of reserved ids
+  // for original clauses. Given ID is the first derived clause ID.
+  // Arguments: ID
+  //
+  virtual void begin_proof (int64_t) {}
+
+  /*------------------------------------------------------------------------*/
+  /*                                                                        */
+  /*                      Specifically incremental */
+  /*                                                                        */
+  /*------------------------------------------------------------------------*/
+
+  // Notify the observer that an assumption has been added
+  // Arguments: assumption_literal
+  //
+  virtual void solve_query () {}
+
+  // Notify the observer that an assumption has been added
+  // Arguments: assumption_literal
+  //
+  virtual void add_assumption (int) {}
+
+  // Notify the observer that a constraint has been added
+  // Arguments: constraint_clause
+  //
+  virtual void add_constraint (const std::vector<int> &) {}
+
+  // Notify the observer that assumptions and constraints are reset
+  //
+  virtual void reset_assumptions () {}
+
+  // Notify the observer that this clause could be derived, which
+  // is the negation of a core of failing assumptions/constraints.
+  // If antecedents are derived they will be included here.
+  // Arguments: ID, clause, antecedents
+  //
+  virtual void add_assumption_clause (int64_t, const std::vector<int> &,
+                                      const std::vector<int64_t> &) {}
+
+  // Notify the observer that conclude unsat was requested.
+  // will give either the id of the empty clause, the id of a failing
+  // assumption clause or the ids of the failing constrain clauses
+  // Arguments: conclusion_type, clause_ids
+  //
+  virtual void conclude_unsat (ConclusionType,
+                               const std::vector<int64_t> &) {}
+
+  // Notify the observer that conclude sat was requested.
+  // will give the complete model as a vector.
+  //
+  virtual void conclude_sat (const std::vector<int> &) {}
+
+  // Notify the observer that conclude unknown was requested.
+  // will give the current trail as a vector.
+  //
+  virtual void conclude_unknown (const std::vector<int> &) {}
+
+  // Notify the observer that two literals are equivalent
+  //
+  // You receive literals, not variables. You can also get notified
+  // multiple times. You can also get notified of BVA variables, aka
+  // variables you did not declare.
+  virtual void notify_equivalence (int, int) {}
+};
+
+/*--------------------------------------------------------------------------*/
+
+// Following tracers for internal use.
+
+struct InternalTracer : public Tracer {
+public:
+  InternalTracer () {}
+  virtual ~InternalTracer () {}
+
+  virtual void connect_internal (Internal *) {}
+};
+
+class StatTracer : public InternalTracer {
+public:
+  StatTracer () {}
+  virtual ~StatTracer () {}
+
+  virtual void print_stats () {}
+};
+
+class FileTracer : public InternalTracer {
+
+public:
+  FileTracer () {}
+  virtual ~FileTracer () {}
+
+  virtual bool closed () = 0;
+  virtual void close (bool print = false) = 0;
+  virtual void flush (bool print = false) = 0;
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/transred.cpp

@@ -0,0 +1,253 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Implement transitive reduction in the binary implication graph.  This is
+// important for hyper binary resolution, which has the risk to produce too
+// many hyper binary resolvents otherwise.  This algorithm only works on
+// binary clauses and is usually pretty fast.  It will also find some failed
+// literals (in the binary implication graph).
+
+void Internal::transred () {
+  if (!opts.transred)
+    return;
+  if (unsat)
+    return;
+  if (terminated_asynchronously ())
+    return;
+  if (!stats.current.redundant && !stats.current.irredundant)
+    return;
+
+  assert (opts.transred);
+  assert (!level);
+
+  START_SIMPLIFIER (transred, TRANSRED);
+  stats.transreds++;
+
+  // Transitive reduction can not be run to completion for larger formulas
+  // with many binary clauses.  We bound it in the same way as 'probe_core'.
+  //
+  int64_t limit = stats.propagations.search;
+  limit -= last.transred.propagations;
+  limit *= 1e-3 * opts.transredeffort;
+  if (limit < opts.transredmineff)
+    limit = opts.transredmineff;
+  if (limit > opts.transredmaxeff)
+    limit = opts.transredmaxeff;
+
+  PHASE ("transred", stats.transreds,
+         "transitive reduction limit of %" PRId64 " propagations", limit);
+
+  const auto end = clauses.end ();
+  auto i = clauses.begin ();
+
+  // Find first clause not checked for being transitive yet.
+  //
+  for (; i != end; i++) {
+    Clause *c = *i;
+    if (c->garbage)
+      continue;
+    if (c->size != 2)
+      continue;
+    if (c->redundant && c->hyper)
+      continue;
+    if (!c->transred)
+      break;
+  }
+
+  // If all candidate clauses have been checked reschedule all.
+  //
+  if (i == end) {
+
+    PHASE ("transred", stats.transreds,
+           "rescheduling all clauses since no clauses to check left");
+    for (i = clauses.begin (); i != end; i++) {
+      Clause *c = *i;
+      if (c->transred)
+        c->transred = false;
+    }
+    i = clauses.begin ();
+  }
+
+  // Move watches of binary clauses to the front. Thus we can stop iterating
+  // watches as soon a long clause is found during watch traversal.
+  //
+  sort_watches ();
+
+  // This working stack plays the same role as the 'trail' during standard
+  // propagation.
+  //
+  vector<int> work;
+
+  int64_t propagations = 0, units = 0, removed = 0;
+
+  while (!unsat && i != end && !terminated_asynchronously () &&
+         propagations < limit) {
+    Clause *c = *i++;
+
+    // A clause is a candidate for being transitive if it is binary, and not
+    // the result of hyper binary resolution.  The reason for excluding
+    // those, is that they come in large numbers, most of them are reduced
+    // away anyhow and further are non-transitive at the point they are
+    // added (see the code in 'hyper_binary_resolve' in 'prope.cpp' and
+    // also check out our CPAIOR paper on tree-based look ahead).
+    //
+    if (c->garbage)
+      continue;
+    if (c->size != 2)
+      continue;
+    if (c->redundant && c->hyper)
+      continue;
+    if (c->transred)
+      continue;         // checked before?
+    c->transred = true; // marked as checked
+
+    LOG (c, "checking transitive reduction of");
+
+    // Find a different path from 'src' to 'dst' in the binary implication
+    // graph, not using 'c'.  Since this is the same as checking whether
+    // there is a path from '-dst' to '-src', we can do the reverse search
+    // if the number of watches of '-dst' is larger than those of 'src'.
+    //
+    int src = -c->literals[0];
+    int dst = c->literals[1];
+    if (val (src) || val (dst))
+      continue;
+    if (watches (-src).size () < watches (dst).size ()) {
+      int tmp = dst;
+      dst = -src;
+      src = -tmp;
+    }
+
+    LOG ("searching path from %d to %d", src, dst);
+
+    // If the candidate clause is irredundant then we can not use redundant
+    // binary clauses in the implication graph.  See our inprocessing rules
+    // paper, why this restriction is required.
+    //
+    const bool irredundant = !c->redundant;
+
+    assert (work.empty ());
+    mark (src);
+    work.push_back (src);
+    LOG ("transred assign %d", src);
+
+    bool transitive = false; // found path from 'src' to 'dst'?
+    bool failed = false;     // 'src' failed literal?
+
+    size_t j = 0; // 'propagated' in BFS
+
+    assert (lrat_chain.empty ());
+    assert (mini_chain.empty ());
+    vector<int> parents;
+
+    while (!transitive && !failed && j < work.size ()) {
+      const int lit = work[j++];
+      assert (marked (lit) > 0);
+      LOG ("transred propagating %d", lit);
+      propagations++;
+      const Watches &ws = watches (-lit);
+      const const_watch_iterator eow = ws.end ();
+      const_watch_iterator k;
+      for (k = ws.begin (); !transitive && !failed && k != eow; k++) {
+        const Watch &w = *k;
+        if (!w.binary ())
+          break; // since we sorted watches above
+        Clause *d = w.clause;
+        if (d == c)
+          continue;
+        if (irredundant && d->redundant)
+          continue;
+        if (d->garbage)
+          continue;
+        const int other = w.blit;
+        if (other == dst)
+          transitive = true; // 'dst' reached
+        else {
+          const int tmp = marked (other);
+          if (tmp > 0)
+            continue;
+          else if (tmp < 0) {
+            if (lrat) {
+              parents.push_back (lit);
+              mini_chain.push_back (d->id);
+              work.push_back (other);
+            }
+            LOG ("found both %d and %d reachable", -other, other);
+            failed = true;
+          } else {
+            if (lrat) {
+              parents.push_back (lit);
+              mini_chain.push_back (d->id);
+            }
+            mark (other);
+            work.push_back (other);
+            LOG ("transred assign %d", other);
+          }
+        }
+      }
+    }
+
+    int failed_lit = work.back ();
+    int next_pos = 0;
+    int next_neg = 0;
+
+    // Unassign all assigned literals (same as '[bp]acktrack').
+    //
+    while (!work.empty ()) {
+      const int lit = work.back ();
+      work.pop_back ();
+      if (lrat && failed && !work.empty ()) {
+        assert (!parents.empty () && !mini_chain.empty ());
+        LOG ("transred LRAT current lit %d next pos %d next neg %d", lit,
+             next_pos, next_neg);
+        if (lit == failed_lit || lit == next_pos) {
+          lrat_chain.push_back (mini_chain.back ());
+          next_pos = parents.back ();
+        } else if (lit == -failed_lit || lit == next_neg) {
+          lrat_chain.push_back (mini_chain.back ());
+          next_neg = parents.back ();
+        }
+        parents.pop_back ();
+        mini_chain.pop_back ();
+      }
+      unmark (lit);
+    }
+    mini_chain.clear ();
+    assert (mini_chain.empty ());
+    if (lrat && failed) {
+      reverse (lrat_chain.begin (), lrat_chain.end ());
+    }
+
+    if (transitive) {
+      removed++;
+      stats.transitive++;
+      LOG (c, "transitive redundant");
+      mark_garbage (c);
+    } else if (failed) {
+      units++;
+      LOG ("found failed literal %d during transitive reduction", src);
+      stats.failed++;
+      stats.transredunits++;
+      assign_unit (-src);
+      if (!propagate ()) {
+        VERBOSE (1, "propagating new unit results in conflict");
+        learn_empty_clause ();
+      }
+    }
+    lrat_chain.clear ();
+  }
+
+  last.transred.propagations = stats.propagations.search;
+  stats.propagations.transred += propagations;
+  erase_vector (work);
+
+  PHASE ("transred", stats.transreds,
+         "removed %" PRId64 " transitive clauses, found %" PRId64 " units",
+         removed, units);
+
+  STOP_SIMPLIFIER (transred, TRANSRED);
+  report ('t', !opts.reportall && !(removed + units));
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/unstable.cpp

@@ -0,0 +1,29 @@
+#ifdef PROFILE_MODE
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+bool Internal::propagate_unstable () {
+  assert (!stable);
+  START (propunstable);
+  bool res = propagate ();
+  STOP (propunstable);
+  return res;
+}
+
+void Internal::analyze_unstable () {
+  assert (!stable);
+  START (analyzeunstable);
+  analyze ();
+  STOP (analyzeunstable);
+}
+
+int Internal::decide_unstable () {
+  assert (!stable);
+  return decide ();
+}
+
+}; // namespace CaDiCaL
+#else
+int unstable_if_no_profile_mode;
+#endif