cadical 0.9.0

data/ext/cadical/cadical/src/backtrack.cpp

@@ -0,0 +1,177 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// The global assignment stack can only be (partially) reset through
+// 'backtrack' which is the only function using 'unassign' (inlined and thus
+// local to this file).  It turns out that 'unassign' does not need a
+// specialization for 'probe' nor 'vivify' and thus it is shared.
+
+inline void Internal::unassign (int lit) {
+  assert (val (lit) > 0);
+  set_val (lit, 0);
+
+  int idx = vidx (lit);
+  LOG ("unassign %d @ %d", lit, var (idx).level);
+  num_assigned--;
+
+  // In the standard EVSIDS variable decision heuristic of MiniSAT, we need
+  // to push variables which become unassigned back to the heap.
+  //
+  if (!scores.contains (idx))
+    scores.push_back (idx);
+
+  // For VMTF we need to update the 'queue.unassigned' pointer in case this
+  // variable sits after the variable to which 'queue.unassigned' currently
+  // points.  See our SAT'15 paper for more details on this aspect.
+  //
+  if (queue.bumped < btab[idx])
+    update_queue_unassigned (idx);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Update the current target maximum assignment and also the very best
+// assignment.  Whether a trail produces a conflict is determined during
+// propagation.  Thus that all functions in the 'search' loop after
+// propagation can assume that 'no_conflict_until' is valid.  If a conflict
+// is found then the trail before the last decision is used (see the end of
+// 'propagate').  During backtracking we can then save this largest
+// propagation conflict free assignment.  It is saved as both 'target'
+// assignment for picking decisions in 'stable' mode and if it is the
+// largest ever such assignment also as 'best' assignment. This 'best'
+// assignment can then be used in future stable decisions after the next
+// 'rephase_best' overwrites saved phases with it.
+
+void Internal::update_target_and_best () {
+
+  if (opts.rephase == 2 && !stable)
+    return;
+
+  bool reset = (rephased && stats.conflicts > last.rephase.conflicts);
+
+  if (reset) {
+    target_assigned = 0;
+    if (rephased == 'B')
+      best_assigned = 0; // update it again
+  }
+
+  if (no_conflict_until > target_assigned) {
+    copy_phases (phases.target);
+    target_assigned = no_conflict_until;
+    LOG ("new target trail level %zu", target_assigned);
+  }
+
+  if (no_conflict_until > best_assigned) {
+    copy_phases (phases.best);
+    best_assigned = no_conflict_until;
+    LOG ("new best trail level %zu", best_assigned);
+  }
+
+  if (reset) {
+    report (rephased);
+    rephased = 0;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::backtrack (int new_level) {
+  assert (new_level <= level);
+  if (new_level == level)
+    return;
+
+  update_target_and_best ();
+  backtrack_without_updating_phases (new_level);
+}
+
+void Internal::backtrack_without_updating_phases (int new_level) {
+
+  assert (new_level <= level);
+  if (new_level == level)
+    return;
+
+  stats.backtracks++;
+
+  assert (num_assigned == trail.size ());
+
+  const size_t assigned = control[new_level + 1].trail;
+
+  LOG ("backtracking to decision level %d with decision %d and trail %zd",
+       new_level, control[new_level].decision, assigned);
+
+  const size_t end_of_trail = trail.size ();
+  size_t i = assigned, j = i;
+
+#ifdef LOGGING
+  int unassigned = 0;
+#endif
+  int reassigned = 0;
+
+  notify_backtrack (new_level);
+  if (external_prop && !external_prop_is_lazy && !private_steps &&
+      notified > assigned) {
+    LOG ("external propagator is notified about some unassignments (trail: "
+         "%zd, notified: %zd).",
+         trail.size (), notified);
+    notified = assigned;
+  }
+
+  while (i < end_of_trail) {
+    int lit = trail[i++];
+    Var &v = var (lit);
+    if (v.level > new_level) {
+      unassign (lit);
+#ifdef LOGGING
+      unassigned++;
+#endif
+    } else {
+      // This is the essence of the SAT'18 paper on chronological
+      // backtracking.  It is possible to just keep out-of-order assigned
+      // literals on the trail without breaking the solver (after some
+      // modifications to 'analyze' - see 'opts.chrono' guarded code there).
+      assert ((in_mode (BACKBONE)) || opts.chrono || external_prop ||
+              did_external_prop);
+#ifdef LOGGING
+      if (!v.level)
+        LOG ("reassign %d @ 0 unit clause %d", lit, lit);
+      else
+        LOG (v.reason, "reassign %d @ %d", lit, v.level);
+#endif
+      trail[j] = lit;
+      v.trail = j++;
+      reassigned++;
+    }
+  }
+  trail.resize (j);
+  LOG ("unassigned %d literals %.0f%%", unassigned,
+       percent (unassigned, unassigned + reassigned));
+  LOG ("reassigned %d literals %.0f%%", reassigned,
+       percent (reassigned, unassigned + reassigned));
+
+  if (propagated > assigned)
+    propagated = assigned;
+  if (propagated2 > assigned)
+    propagated2 = assigned;
+  if (no_conflict_until > assigned)
+    no_conflict_until = assigned;
+
+  propergated = 0; // Always go back to root-level.
+
+  assert (notified <= assigned + reassigned);
+  if (reassigned) {
+    notify_assignments ();
+  }
+
+  control.resize (new_level + 1);
+  level = new_level;
+  if (changed_val) {
+    assert (opts.ilb);
+    if (!val (changed_val)) {
+      changed_val = 0;
+    }
+  }
+  assert (num_assigned == trail.size ());
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/backward.cpp

@@ -0,0 +1,231 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Provide eager backward subsumption for resolved clauses.
+
+// The eliminator maintains a queue of clauses that are new and have to be
+// checked to subsume or strengthen other (longer or same size) clauses.
+
+void Eliminator::enqueue (Clause *c) {
+  if (!internal->opts.elimbackward)
+    return;
+  if (c->enqueued)
+    return;
+  LOG (c, "backward enqueue");
+  backward.push (c);
+  c->enqueued = true;
+}
+
+Clause *Eliminator::dequeue () {
+  if (backward.empty ())
+    return 0;
+  Clause *res = backward.front ();
+  backward.pop ();
+  assert (res->enqueued);
+  res->enqueued = false;
+  LOG (res, "backward dequeue");
+  return res;
+}
+
+Eliminator::~Eliminator () {
+  while (dequeue ())
+    ;
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clause (Eliminator &eliminator, Clause *c) {
+  assert (opts.elimbackward);
+  assert (!c->redundant);
+  if (c->garbage)
+    return;
+  LOG (c, "attempting backward subsumption and strengthening with");
+  size_t len = UINT_MAX;
+  unsigned size = 0;
+  int best = 0;
+  bool satisfied = false;
+  assert (mini_chain.empty ());
+  for (const auto &lit : *c) {
+    const signed char tmp = val (lit);
+    if (tmp > 0) {
+      satisfied = true;
+      break;
+    }
+    if (tmp < 0)
+      continue;
+    size_t l = occs (lit).size ();
+    LOG ("literal %d occurs %zd times", lit, l);
+    if (l < len)
+      best = lit, len = l;
+    mark (lit);
+    size++;
+  }
+  if (satisfied) {
+    LOG ("clause actually already satisfied");
+    elim_update_removed_clause (eliminator, c);
+    mark_garbage (c);
+  } else if (len > (size_t) opts.elimocclim) {
+    LOG ("skipping backward subsumption due to too many occurrences");
+  } else {
+    assert (len);
+    LOG ("literal %d has smallest number of occurrences %zd", best, len);
+    LOG ("marked %d literals in clause of size %d", size, c->size);
+    for (auto &d : occs (best)) {
+      if (d == c)
+        continue;
+      if (d->garbage)
+        continue;
+      if ((unsigned) d->size < size)
+        continue;
+      int negated = 0;
+      unsigned found = 0;
+      satisfied = false;
+      for (const auto &lit : *d) {
+        signed char tmp = val (lit);
+        if (tmp > 0) {
+          satisfied = true;
+          break;
+        }
+        if (tmp < 0)
+          continue;
+        tmp = marked (lit);
+        if (!tmp)
+          continue;
+        if (tmp < 0) {
+          if (negated) {
+            size = UINT_MAX;
+            break;
+          } else
+            negated = lit;
+        }
+        if (++found == size)
+          break;
+      }
+      if (satisfied) {
+        LOG (d, "found satisfied clause");
+        elim_update_removed_clause (eliminator, d);
+        mark_garbage (d);
+      } else if (found == size) {
+        if (!negated) {
+          LOG (d, "found subsumed clause");
+          elim_update_removed_clause (eliminator, d);
+          mark_garbage (d);
+          stats.subsumed++;
+          stats.elimbwsub++;
+        } else {
+          int unit = 0;
+          assert (minimize_chain.empty ());
+          assert (analyzed.empty ());
+          assert (lrat_chain.empty ());
+          // figure out wether we strengthen c or get a new unit
+          for (const auto &lit : *d) {
+            const signed char tmp = val (lit);
+            if (tmp < 0) {
+              if (!lrat)
+                continue;
+              Flags &f = flags (lit);
+              assert (!f.seen);
+              if (f.seen)
+                continue;
+              f.seen = true;
+              analyzed.push_back (lit);
+              continue;
+            }
+            if (tmp > 0) {
+              satisfied = true;
+              break;
+            }
+            if (lit == negated)
+              continue;
+            if (unit) {
+              unit = INT_MIN;
+              continue; // needed to guarantee d is not satsified
+            } else
+              unit = lit;
+          }
+          if (lrat && !satisfied) {
+            // if we found a unit we need to add all unit ids from
+            // {c\d}U{d\c} otherwise just the unit ids from {c\d}
+            for (const auto &lit : *c) {
+              const signed char tmp = val (lit);
+              assert (tmp <= 0);
+              if (tmp >= 0)
+                continue;
+              Flags &f = flags (lit);
+              if (f.seen && unit && unit == INT_MIN) {
+                f.seen = false;
+                continue;
+              } else if (!f.seen) {
+                f.seen = true;
+                analyzed.push_back (lit);
+              }
+            }
+            if (unit == INT_MIN) { // we do not need units from {d\c}
+              for (const auto &lit : *d) {
+                flags (lit).seen = false;
+              }
+            }
+            for (const auto &lit : analyzed) {
+              Flags &f = flags (lit);
+              if (!f.seen) {
+                f.seen = true;
+                continue;
+              }
+              int64_t id = unit_id (-lit);
+              lrat_chain.push_back (id);
+            }
+            clear_analyzed_literals ();
+            lrat_chain.push_back (d->id);
+            lrat_chain.push_back (c->id);
+          } else if (lrat)
+            clear_analyzed_literals ();
+          if (satisfied) {
+            assert (lrat_chain.empty ());
+            mark_garbage (d);
+            elim_update_removed_clause (eliminator, d);
+          } else if (unit && unit != INT_MIN) {
+            assert (unit);
+            LOG (d, "unit %d through hyper unary resolution with", unit);
+            assign_unit (unit);
+            elim_propagate (eliminator, unit);
+            lrat_chain.clear ();
+            break;
+          } else if (occs (negated).size () <= (size_t) opts.elimocclim) {
+            strengthen_clause (d, negated);
+            remove_occs (occs (negated), d);
+            elim_update_removed_lit (eliminator, negated);
+            stats.elimbwstr++;
+            assert (negated != best);
+            eliminator.enqueue (d);
+          }
+          lrat_chain.clear ();
+        }
+      }
+    }
+  }
+  mini_chain.clear ();
+  unmark (c);
+}
+
+/*------------------------------------------------------------------------*/
+
+void Internal::elim_backward_clauses (Eliminator &eliminator) {
+  if (!opts.elimbackward) {
+    assert (eliminator.backward.empty ());
+    return;
+  }
+  START (backward);
+  LOG ("attempting backward subsumption and strengthening with %zd clauses",
+       eliminator.backward.size ());
+  Clause *c;
+  while (!unsat && (c = eliminator.dequeue ()))
+    elim_backward_clause (eliminator, c);
+  STOP (backward);
+}
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/bins.cpp

@@ -0,0 +1,22 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Binary implication graph lists.
+
+void Internal::init_bins () {
+  assert (big.empty ());
+  if (big.size () < 2 * vsize)
+    big.resize (2 * vsize, Bins ());
+  LOG ("initialized binary implication graph");
+}
+
+void Internal::reset_bins () {
+  assert (!big.empty ());
+  erase_vector (big);
+  LOG ("reset binary implication graph");
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/bins.hpp

@@ -0,0 +1,22 @@
+#ifndef _bins_hpp_INCLUDED
+#define _bins_hpp_INCLUDED
+
+#include "util.hpp" // Alphabetically after 'bins'.
+
+namespace CaDiCaL {
+
+using namespace std;
+
+struct Bin {
+  int lit;
+  int64_t id;
+};
+
+typedef vector<Bin> Bins;
+
+inline void shrink_bins (Bins &bs) { shrink_vector (bs); }
+inline void erase_bins (Bins &bs) { erase_vector (bs); }
+
+} // namespace CaDiCaL
+
+#endif