cadical 0.9.0

data/ext/cadical/cadical/src/ema.cpp

@@ -0,0 +1,95 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Updating an exponential moving average is placed here since we want to
+// log both updates and phases of initialization, thus need 'LOG'.
+//
+// We now use initialization bias correction as in the ADAM method
+// [KingmaBa-ICLR'15] instead of our ad-hoc initialization method used
+// before.  Our old variant used exponentially decreasing alphas:
+//
+//   1,
+//   1/2, 1/2,
+//   1/4, 1/4, 1/4, 1/4
+//   1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8, 1/8,
+//   ...
+//   2^-n, ..., 2^-n                          'n' times
+//   alpha, alpha, ...                        now 'alpha' forever.
+//
+//   where 2^-n is the smallest negative power of two above 'alpha'
+//
+// This old method is better than the initializations described in our
+// [BiereFroehlich-POS'15] paper and actually faster than the ADAM method,
+// but less precise.  We consider this old method obsolete now but it
+// could still be useful for implementations relying on integers instead
+// of floating points because it only needs shifts and integer arithmetic.
+//
+// Our new method for unbiased initialization of the exponential averages
+// works as follows.  First the biased moving average is computed as usual.
+// Note that (as already before) we use the simpler equation
+//
+//   new_biased = old_biased + alpha * (y - old_biased);
+//
+// which in principle (and thus easy to remember) can be implemented as
+//
+//   biased += alpha * (y - biased);
+//
+// The original formulation in the ADAM paper (with 'alpha = 1 - beta') is
+//
+//   new_biased = beta * old_biased + (1 - beta) * y
+//
+// To show that these are equivalent (modulo floating point issues)
+// consider the following equivalent expressions:
+//
+//   old_biased + alpha * (y - old_biased)
+//   old_biased + alpha * y - alpha * old_biased
+//   (1 - alpha) * old_biased + alpha * y
+//   beta * old_biased + (1 - beta) * y
+//
+// The real new idea taken from the ADAM paper is however to fix the biased
+// moving average with a correction term '1.0 / (1.0 - pow (beta, updated))'
+// by multiplication to obtain an unbiased moving average (called simply
+// 'value' in our 'code').  In order to avoid computing 'pow' every time, we
+// use 'exp' which is multiplied in every update with 'beta'.
+
+void EMA::update (Internal *internal, double y, const char *name) {
+#ifdef LOGGING
+  updated++;
+  const double old_value = value;
+#endif
+  const double old_biased = biased;
+  const double delta = y - old_biased;
+  const double scaled_delta = alpha * delta;
+  const double new_biased = old_biased + scaled_delta;
+  LOG ("update %" PRIu64 " of biased %s EMA %g with %g (delta %g) "
+       "yields %g (scaled delta %g)",
+       updated, name, old_biased, y, delta, new_biased, scaled_delta);
+  biased = new_biased;
+  const double old_exp = exp;
+  double new_exp, div, new_value;
+  if (old_exp) {
+    new_exp = old_exp * beta;
+    assert (new_exp < 1);
+    exp = new_exp;
+    div = 1 - new_exp;
+    assert (div > 0);
+    new_value = new_biased / div;
+  } else {
+    new_value = new_biased;
+#ifdef LOGGING
+    new_exp = 0;
+    div = 1;
+#endif
+  }
+  value = new_value;
+  LOG ("update %" PRIu64 " of corrected %s EMA %g with %g (delta %g) "
+       "yields %g (exponent %g, divisor %g)",
+       updated, name, old_value, y, delta, new_value, new_exp, div);
+#ifndef LOGGING
+  (void) internal;
+  (void) name;
+#endif
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/ema.hpp

@@ -0,0 +1,68 @@
+#ifndef _ema_hpp_INCLUDED
+#define _ema_hpp_INCLUDED
+
+#include <cstdint>
+
+namespace CaDiCaL {
+
+struct Internal;
+
+// This is a more complex generic exponential moving average class to
+// support more robust initialization (see comments in the 'update'
+// implementation).
+
+struct EMA {
+
+#ifdef LOGGING
+  uint64_t updated;
+#endif
+  double value;  // unbiased (corrected) moving average
+  double biased; // biased initialized moving average
+  double alpha;  // input scaling with 'alpha = 1 - beta'
+  double beta;   // decay of 'biased' with 'beta = 1 - alpha'
+  double exp;    // 'exp = pow (beta, updated)'
+
+  EMA ()
+      :
+#ifdef LOGGING
+        updated (0),
+#endif
+        value (0), biased (0), alpha (0), beta (0), exp (0) {
+  }
+
+  EMA (double a)
+      :
+#ifdef LOGGING
+        updated (0),
+#endif
+        value (0), biased (0), alpha (a), beta (1 - a), exp (!!beta) {
+    assert (beta >= 0);
+  }
+
+  operator double () const { return value; }
+  void update (Internal *, double y, const char *name);
+};
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// Compact average update and initialization macros for better logging.
+
+#define UPDATE_AVERAGE(A, Y) \
+  do { \
+    A.update (internal, (Y), #A); \
+  } while (0)
+
+#define INIT_EMA(E, WINDOW) \
+  do { \
+    assert ((WINDOW) >= 1); \
+    double ALPHA = 1.0 / (double) (WINDOW); \
+    E = EMA (ALPHA); \
+    LOG ("init " #E " EMA target alpha %g window %d", ALPHA, \
+         (int) WINDOW); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+#endif

data/ext/cadical/cadical/src/extend.cpp

@@ -0,0 +1,289 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void External::push_zero_on_extension_stack () {
+  extension.push_back (0);
+  LOG ("pushing 0 on extension stack");
+}
+
+void External::push_id_on_extension_stack (int64_t id) {
+  const uint32_t higher_bits = static_cast<int> (id << 32);
+  const uint32_t lower_bits = (id & (((int64_t) 1 << 32) - 1));
+  extension.push_back (higher_bits);
+  extension.push_back (lower_bits);
+  LOG ("pushing id %" PRIu64 " = %d + %d", id, higher_bits, lower_bits);
+}
+
+void External::push_clause_literal_on_extension_stack (int ilit) {
+  assert (ilit);
+  const int elit = internal->externalize (ilit);
+  const int eidx = abs (elit);
+  const bool is_extension_var = ervars[eidx];
+  Flags &f = internal->flags (ilit);
+  if (is_extension_var) {
+    f.factored_but_on_reconstruction_stack = true;
+    LOG ("marking lit %s as tainted", LOGLIT (ilit));
+  }
+
+  assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing clause literal %d on extension stack (internal %d)", elit,
+       ilit);
+}
+
+void External::push_witness_literal_on_extension_stack (int ilit) {
+  assert (ilit);
+  const int elit = internal->externalize (ilit);
+  assert (elit);
+  extension.push_back (elit);
+  LOG ("pushing witness literal %d on extension stack (internal %d)", elit,
+       ilit);
+  if (marked (witness, elit))
+    return;
+  LOG ("marking witness %d", elit);
+  mark (witness, elit);
+}
+
+// The extension stack allows to reconstruct a satisfying assignment for the
+// original formula after removing eliminated clauses.  This was pioneered
+// by Niklas Soerensson in MiniSAT and for instance is described in our
+// inprocessing paper, published at IJCAR'12.  This first function adds a
+// clause to this stack.  First the blocking or eliminated literal is added,
+// and then the rest of the clause.
+
+void External::push_clause_on_extension_stack (Clause *c) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += c->size;
+  push_zero_on_extension_stack ();
+  push_id_on_extension_stack (c->id);
+  push_zero_on_extension_stack ();
+  for (const auto &lit : *c)
+    push_clause_literal_on_extension_stack (lit);
+}
+
+void External::push_clause_on_extension_stack (Clause *c, int pivot) {
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_clause_on_extension_stack (c);
+}
+
+void External::push_binary_clause_on_extension_stack (int64_t id, int pivot,
+                                                      int other) {
+  internal->stats.weakened++;
+  internal->stats.weakenedlen += 2;
+  push_zero_on_extension_stack ();
+  push_witness_literal_on_extension_stack (pivot);
+  push_zero_on_extension_stack ();
+  push_id_on_extension_stack (id);
+  push_zero_on_extension_stack ();
+  push_clause_literal_on_extension_stack (pivot);
+  push_clause_literal_on_extension_stack (other);
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::push_external_clause_and_witness_on_extension_stack (
+    const vector<int> &c, const vector<int> &w, int64_t id) {
+  assert (id);
+  extension.push_back (0);
+  for (const auto &elit : w) {
+    assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+    mark (witness, elit);
+  }
+  extension.push_back (0);
+  const uint32_t higher_bits = static_cast<int> (id << 32);
+  const uint32_t lower_bits = (id & (((int64_t) 1 << 32) - 1));
+  extension.push_back (higher_bits);
+  extension.push_back (lower_bits);
+  extension.push_back (0);
+  for (const auto &elit : c) {
+    assert (elit != INT_MIN);
+    init (abs (elit));
+    extension.push_back (elit);
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// This is the actual extension process. It goes backward over the clauses
+// on the extension stack and flips the assignment of one of the blocking
+// literals in the conditional autarky stored before the clause.  In the
+// original algorithm for witness construction for variable elimination and
+// blocked clause removal the conditional autarky consists of a single
+// literal from the removed clause, while in general the autarky witness can
+// contain an arbitrary set of literals.  We are using the more general
+// witness reconstruction here which for instance would also work for
+// super-blocked or set-blocked clauses.
+
+void External::extend () {
+
+  assert (!extended);
+  START (extend);
+  internal->stats.extensions++;
+
+  PHASE ("extend", internal->stats.extensions,
+         "mapping internal %d assignments to %d assignments",
+         internal->max_var, max_var);
+
+#ifndef QUIET
+  int64_t updated = 0;
+#endif
+  for (unsigned i = 1; i <= (unsigned) max_var; i++) {
+    const int ilit = e2i[i];
+    if (!ilit)
+      continue;
+    if (i >= vals.size ())
+      vals.resize (i + 1, false);
+    vals[i] = (internal->val (ilit) > 0);
+#ifndef QUIET
+    updated++;
+#endif
+  }
+  PHASE ("extend", internal->stats.extensions,
+         "updated %" PRId64 " external assignments", updated);
+  PHASE ("extend", internal->stats.extensions,
+         "extending through extension stack of size %zd",
+         extension.size ());
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+#ifndef QUIET
+  int64_t flipped = 0;
+#endif
+  while (i != begin) {
+    bool satisfied = false;
+    int lit;
+    assert (i != begin);
+    while ((lit = *--i)) {
+      if (satisfied)
+        continue;
+      if (ival (lit) == lit)
+        satisfied = true;
+      assert (i != begin);
+    }
+    assert (i != begin);
+    LOG ("id=%" PRId64, ((int64_t) *i << 32) + *(i - 1));
+    assert (*i || *(i - 1));
+    --i;
+    assert (i != begin);
+    --i;
+    assert (i != begin);
+    assert (!*i);
+    --i;
+    assert (i != begin);
+    if (satisfied)
+      while (*--i)
+        assert (i != begin);
+    else {
+      while ((lit = *--i)) {
+        const int tmp = ival (lit); // not 'signed char'!!!
+        if (tmp != lit) {
+          LOG ("flipping blocking literal %d", lit);
+          assert (lit);
+          assert (lit != INT_MIN);
+          size_t idx = abs (lit);
+          if (idx >= vals.size ())
+            vals.resize (idx + 1, false);
+          vals[idx] = !vals[idx];
+          internal->stats.extended++;
+#ifndef QUIET
+          flipped++;
+#endif
+        }
+        assert (i != begin);
+      }
+    }
+  }
+  PHASE ("extend", internal->stats.extensions,
+         "flipped %" PRId64 " literals during extension", flipped);
+  extended = true;
+  LOG ("extended");
+  STOP (extend);
+}
+
+/*------------------------------------------------------------------------*/
+
+bool External::traverse_witnesses_backward (WitnessIterator &it) {
+  if (internal->unsat)
+    return true;
+  vector<int> clause, witness;
+  const auto begin = extension.begin ();
+  auto i = extension.end ();
+  while (i != begin) {
+    int lit;
+    while ((lit = *--i))
+      clause.push_back (lit);
+    assert (!lit);
+    --i;
+    const int64_t id =
+        ((int64_t) * (i - 1) << 32) + static_cast<int64_t> (*i);
+    assert (id);
+    i -= 2;
+    assert (!*i);
+    assert (i != begin);
+    while ((lit = *--i))
+      witness.push_back (lit);
+    reverse (clause.begin (), clause.end ());
+    reverse (witness.begin (), witness.end ());
+    LOG (clause, "traversing clause");
+    if (!it.witness (clause, witness, id))
+      return false;
+    clause.clear ();
+    witness.clear ();
+  }
+  return true;
+}
+
+bool External::traverse_witnesses_forward (WitnessIterator &it) {
+  if (internal->unsat)
+    return true;
+  vector<int> clause, witness;
+  const auto end = extension.end ();
+  auto i = extension.begin ();
+  if (i != end) {
+    int lit = *i++;
+    do {
+      assert (!lit), (void) lit;
+      while ((lit = *i++))
+        witness.push_back (lit);
+      assert (!lit);
+      assert (i != end);
+      assert (!*i);
+      const int64_t id =
+          ((int64_t) *i << 32) + static_cast<int64_t> (*(i + 1));
+      assert (id > 0);
+      i += 3;
+      assert (*i);
+      assert (i != end);
+      while (i != end && (lit = *i++))
+        clause.push_back (lit);
+      if (!it.witness (clause, witness, id))
+        return false;
+      clause.clear ();
+      witness.clear ();
+    } while (i != end);
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+void External::conclude_sat () {
+  if (!internal->proof || concluded)
+    return;
+  concluded = true;
+  if (!extended)
+    extend ();
+  vector<int> model;
+  for (int idx = 1; idx <= max_var; idx++) {
+    if (ervars[idx])
+      continue;
+    const int lit = ival (idx);
+    model.push_back (lit);
+  }
+  internal->proof->conclude_sat (model);
+}
+
+} // namespace CaDiCaL