cadical 0.9.0

data/ext/cadical/cadical/src/decompose.hpp

@@ -0,0 +1,23 @@
+#ifndef _decompose_hpp_INCLUDED
+#define _decompose_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+// This implements Tarjan's algorithm for decomposing the binary implication
+// graph intro strongly connected components (SCCs).  Literals in one SCC
+// are equivalent and we replace them all by the literal with the smallest
+// index in the SCC.  These variables are marked 'substituted' and will be
+// removed from all clauses.  Their value will be fixed during 'extend'.
+
+#define TRAVERSED UINT_MAX // mark completely traversed
+
+struct DFS {
+  unsigned idx;   // depth first search index
+  unsigned min;   // minimum reachable index
+  Clause *parent; // for lrat
+  DFS () : idx (0), min (0), parent (0) {}
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/deduplicate.cpp

@@ -0,0 +1,275 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+// Equivalent literal substitution in 'decompose' and shrinking in 'subsume'
+// or 'vivify' might produce duplicated binary clauses.  They can not be
+// found in 'subsume' nor 'vivify' since we explicitly do not consider
+// binary clauses as candidates to be shrunken or subsumed.  They are
+// detected here by a simple scan of watch lists and then marked as garbage.
+// This is actually also quite fast.
+
+// Further it might also be possible that two binary clauses can be resolved
+// to produce a unit (we call it 'hyper unary resolution').  For example
+// resolving the binary clauses '1 -2' and '1 2' produces the unit '1'.
+// This could be found by probing in 'probe' unless '-1' also occurs in a
+// binary clause (add the clause '-1 2' to those two clauses) in which case
+// '1' as well as '2' both occur positively as well as negatively and none
+// of them nor their negation is considered as probe
+
+void Internal::mark_duplicated_binary_clauses_as_garbage () {
+
+  if (!opts.deduplicate)
+    return;
+  if (unsat)
+    return;
+  if (terminated_asynchronously ())
+    return;
+
+  START_SIMPLIFIER (deduplicate, DEDUP);
+  stats.deduplications++;
+
+  assert (!level);
+  assert (watching ());
+
+  vector<int> stack; // To save marked literals and unmark them later.
+
+  int64_t subsumed = 0;
+  int64_t units = 0;
+
+  for (auto idx : vars) {
+
+    if (unsat)
+      break;
+    if (!active (idx))
+      continue;
+    int unit = 0;
+
+    for (int sign = -1; !unit && sign <= 1; sign += 2) {
+
+      const int lit = sign * idx; // Consider all literals.
+
+      assert (stack.empty ());
+      Watches &ws = watches (lit);
+
+      // We are removing references to garbage clause. Thus no 'auto'.
+
+      const const_watch_iterator end = ws.end ();
+      watch_iterator j = ws.begin ();
+      const_watch_iterator i;
+
+      for (i = j; !unit && i != end; i++) {
+        Watch w = *j++ = *i;
+        if (!w.binary ())
+          continue;
+        int other = w.blit;
+        const int tmp = marked (other);
+        Clause *c = w.clause;
+
+        if (tmp > 0) { // Found duplicated binary clause.
+
+          if (c->garbage) {
+            j--;
+            continue;
+          }
+          LOG (c, "found duplicated");
+
+          // The previous identical clause 'd' might be redundant and if the
+          // second clause 'c' is not (so irredundant), then we have to keep
+          // 'c' instead of 'd', thus we search for it and replace it.
+
+          if (!c->redundant) {
+            watch_iterator k;
+            for (k = ws.begin ();; k++) {
+              assert (k != i);
+              if (!k->binary ())
+                continue;
+              if (k->blit != other)
+                continue;
+              Clause *d = k->clause;
+              if (d->garbage)
+                continue;
+              c = d;
+              break;
+            }
+            *k = w;
+          }
+
+          LOG (c, "mark garbage duplicated");
+          stats.subsumed++;
+          stats.deduplicated++;
+          subsumed++;
+          mark_garbage (c);
+          j--;
+
+        } else if (tmp < 0) { // Hyper unary resolution.
+
+          LOG ("found %d %d and %d %d which produces unit %d", lit, -other,
+               lit, other, lit);
+          unit = lit;
+          if (lrat) {
+            // taken from fradical
+            assert (lrat_chain.empty ());
+            lrat_chain.push_back (c->id);
+            // We've forgotten where the other binary clause is, so go find
+            // it again
+            for (watch_iterator k = ws.begin ();; k++) {
+              assert (k != i);
+              if (!k->binary ())
+                continue;
+              if (k->blit != -other)
+                continue;
+              lrat_chain.push_back (k->clause->id);
+              break;
+            }
+          }
+          j = ws.begin (); // Flush 'ws'.
+          units++;
+
+        } else {
+          if (c->garbage) {
+            j--;
+            continue;
+          }
+          mark (other);
+          stack.push_back (other);
+        }
+      }
+
+      if (j == ws.begin ())
+        erase_vector (ws);
+      else if (j != end)
+        ws.resize (j - ws.begin ()); // Shrink watchers.
+
+      for (const auto &other : stack)
+        unmark (other);
+
+      stack.clear ();
+    }
+
+    // Propagation potentially messes up the watches and thus we can not
+    // propagate the unit immediately after finding it.  Instead we break
+    // out of both loops and assign and propagate the unit here.
+
+    if (unit) {
+
+      stats.failed++;
+      stats.hyperunary++;
+      assign_unit (unit);
+      // lrat_chain.clear ();   done in search_assign
+
+      if (!propagate ()) {
+        LOG ("empty clause after propagating unit");
+        learn_empty_clause ();
+      }
+    }
+  }
+  STOP_SIMPLIFIER (deduplicate, DEDUP);
+
+  report ('2', !opts.reportall && !(subsumed + units));
+}
+
+/*------------------------------------------------------------------------*/
+
+// See the comment for vivifyflush.
+//
+struct deduplicate_flush_smaller {
+
+  bool operator() (Clause *a, Clause *b) const {
+
+    const auto eoa = a->end (), eob = b->end ();
+    auto i = a->begin (), j = b->begin ();
+    for (; i != eoa && j != eob; i++, j++)
+      if (*i != *j)
+        return *i < *j;
+    const bool smaller =
+        (j == eob && i != eoa) ||
+        (j == eob && i == eoa && !a->redundant && b->redundant) ||
+        (j == eob && i == eoa && (a->redundant == b->redundant) &&
+         b->id < a->id);
+    return smaller;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+// We discovered in a bug report
+// (https://github.com/arminbiere/cadical/issues/147) that some problems
+// contains clauses several times. This was handled properly before (as a
+// side effect of vivifyflush), but the proper ticks scheduling limitation
+// makes this impossible since 2.2. Therefore, we have implemented this
+// detection as a proper inprocessing technique that is off by default and
+// run only once during preprocess quickly. As we do not want to assume
+// anything on the input clauses, we also remove the true/false literals.
+//
+// In essence, the code is simply taken from vivifyflush (without all the
+// rest of the code around obviously).
+//
+void Internal::deduplicate_all_clauses () {
+  assert (!level);
+  clear_watches ();
+
+  mark_satisfied_clauses_as_garbage ();
+  garbage_collection ();
+
+  // in order to do the inprocessing inplace, we remove the deleted clauses,
+  // put the binary deleted clauses first. Then we work on the non-deleted
+  // clauses by sorting them and sorting the clause w.r.t each other.
+  auto start = clauses.begin ();
+  auto mid = std::partition (clauses.begin (), clauses.end (),
+                             [] (Clause *c) { return !c->garbage; });
+  std::for_each (start, mid,
+                 [] (Clause *c) { return sort (c->begin (), c->end ()); });
+  assert (std::all_of (start, mid, [] (Clause *c) { return !c->garbage; }));
+  assert (std::all_of (mid, end (clauses),
+                       [] (Clause *c) { return c->garbage; }));
+
+  stable_sort (start, mid, deduplicate_flush_smaller ());
+  auto j = start, i = j;
+
+  Clause *prev = 0;
+  int64_t subsumed = 0;
+  for (; i != mid; i++) {
+    Clause *c = *j++ = *i;
+    if (!prev || c->size < prev->size) {
+      prev = c;
+      continue;
+    }
+    const auto eop = prev->end ();
+    auto k = prev->begin ();
+    for (auto l = c->begin (); k != eop; k++, l++)
+      if (*k != *l)
+        break;
+    if (k == eop) {
+      LOG (c, "found subsumed");
+      LOG (prev, "subsuming");
+      assert (!c->garbage);
+      assert (!prev->garbage);
+      assert (c->redundant || !prev->redundant);
+      mark_garbage (c);
+      delete_clause (c);
+      subsumed++;
+      j--;
+    } else
+      prev = c;
+  }
+
+  for (; i != clauses.end (); ++i) {
+    Clause *c = *i;
+    assert (c->garbage);
+    delete_clause (c);
+  }
+
+  clauses.resize (j - clauses.begin ());
+
+  ++stats.deduplicatedinitrounds;
+  PHASE ("deduplicate-all", stats.deduplicatedinitrounds,
+         "flushed %" PRId64 " subsumed clauses out of %zd", subsumed,
+         clauses.end () - start);
+  stats.subsumed += subsumed;
+  stats.deduplicatedinit += subsumed;
+  check_clause_stats ();
+  connect_watches ();
+  report ('d', !opts.reportall && !subsumed);
+}
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/definition.cpp

@@ -0,0 +1,283 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+#define INVALID_LIT UINT_MAX
+
+// functions below are passed to kitten
+//
+struct definition_extractor {
+  Eliminator *eliminator;
+  Internal *internal;
+  vector<Clause *> clauses[2];
+  int lit;
+  vector<vector<int>> implicants;
+  int unit;
+};
+
+extern "C" {
+
+// used to extract definitions from kitten
+//
+static void traverse_definition_core (void *state, unsigned id) {
+  definition_extractor *extractor = (definition_extractor *) state;
+  Clause *clause;
+  const vector<Clause *> &clauses0 = extractor->clauses[0];
+  const vector<Clause *> &clauses1 = extractor->clauses[1];
+  Eliminator *eliminator = extractor->eliminator;
+  const size_t size_clauses0 = clauses0.size ();
+  const size_t size_clauses1 = clauses1.size ();
+  assert (size_clauses0 <= UINT_MAX);
+  unsigned sign;
+  assert (id < size_clauses0 + size_clauses1);
+  if (id < size_clauses0) {
+    clause = clauses0[id];
+    sign = 1;
+  } else {
+    unsigned tmp = id - size_clauses0;
+#ifndef NDEBUG
+    assert (size_clauses1 <= UINT_MAX);
+    assert (tmp < size_clauses1);
+#endif
+    clause = clauses1[tmp];
+    sign = 2;
+  }
+  (void) size_clauses1;
+  clause->gate = true;
+  eliminator->gates.push_back (clause);
+#ifdef LOGGING
+  Internal *internal = extractor->internal;
+  LOG (clause, "extracted gate");
+#endif
+  eliminator->definition_unit |= sign;
+}
+
+// extracts relevant learned clauses from kissat for drat proofs
+//
+static void traverse_one_sided_core_lemma (void *state, bool learned,
+                                           size_t size,
+                                           const unsigned *lits) {
+  if (!learned)
+    return;
+  definition_extractor *extractor = (definition_extractor *) state;
+  Eliminator *eliminator = extractor->eliminator;
+  Internal *internal = extractor->internal;
+  Proof *proof = internal->proof;
+  const int unit = extractor->unit;
+  vector<proof_clause> &proof_clauses = eliminator->proof_clauses;
+  if (size) {
+    proof_clause pc;
+    pc.id = ++(internal->clause_id);
+    pc.literals.push_back (unit);
+    const unsigned *end = lits + size;
+    for (const unsigned *p = lits; p != end; p++)
+      pc.literals.push_back (internal->citten2lit (*p)); // conversion
+    proof_clauses.push_back (pc);
+    assert (proof);
+    proof->add_derived_clause (pc.id, true, pc.literals, pc.chain);
+  } else {
+    internal->assign_unit (unit);
+    for (const auto &pc : proof_clauses) {
+      proof->delete_clause (pc.id, true, pc.literals);
+    }
+    proof_clauses.clear ();
+  }
+}
+
+// extract lrat proofs for relevant clauses
+//
+static void traverse_one_sided_core_lemma_with_lrat (
+    void *state, unsigned cid, unsigned id, bool learned, size_t size,
+    const unsigned *lits, size_t chain_size, const unsigned *chain) {
+  definition_extractor *extractor = (definition_extractor *) state;
+  Eliminator *eliminator = extractor->eliminator;
+  Internal *internal = extractor->internal;
+  Proof *proof = internal->proof;
+  const int unit = extractor->unit;
+  const vector<Clause *> &clauses0 = extractor->clauses[0];
+  const vector<Clause *> &clauses1 = extractor->clauses[1];
+  vector<proof_clause> &proof_clauses = eliminator->proof_clauses;
+  if (!learned) { // remember clauses for mapping to kitten internal
+    assert (size);
+    assert (!chain_size);
+    proof_clause pc;
+    pc.cid = cid;
+    pc.learned = false;
+    const size_t size_clauses0 = clauses0.size ();
+    assert (size_clauses0 <= UINT_MAX);
+    if (id < size_clauses0) {
+      pc.id = clauses0[id]->id;
+    } else {
+      unsigned tmp = id - size_clauses0;
+#ifndef NDEBUG
+      const size_t size_clauses1 = clauses1.size ();
+      assert (size_clauses1 <= UINT_MAX);
+      assert (tmp < size_clauses1);
+#endif
+      pc.id = clauses1[tmp]->id;
+    }
+    proof_clauses.push_back (pc);
+  } else { // actually add to proof
+    assert (chain_size);
+    if (size) {
+      proof_clause pc;
+      pc.id = ++(internal->clause_id);
+      pc.cid = cid;
+      pc.learned = true;
+      pc.literals.push_back (unit);
+      const unsigned *end = lits + size;
+      for (const unsigned *p = lits; p != end; p++)
+        pc.literals.push_back (internal->citten2lit (*p)); // conversion
+      for (const unsigned *p = chain + chain_size; p != chain; p--) {
+        int64_t id = 0;
+        for (const auto &cpc : proof_clauses) {
+          if (cpc.cid == *(p - 1)) {
+            id = cpc.id;
+            break;
+          }
+        }
+        assert (id);
+        pc.chain.push_back (id);
+      }
+      proof_clauses.push_back (pc);
+      assert (proof);
+      proof->add_derived_clause (pc.id, true, pc.literals, pc.chain);
+    } else { // learn unit finish proof
+      assert (internal->lrat_chain.empty ());
+      for (const unsigned *p = chain + chain_size; p != chain; p--) {
+        int64_t id = 0;
+        for (const auto &cpc : proof_clauses) {
+          if (cpc.cid == *(p - 1)) {
+            id = cpc.id;
+            break;
+          }
+        }
+        assert (id);
+        internal->lrat_chain.push_back (id);
+      }
+      internal->assign_unit (unit);
+      assert (internal->lrat_chain.empty ());
+      for (const auto &pc : proof_clauses) {
+        if (pc.learned)
+          proof->delete_clause (pc.id, true, pc.literals);
+      }
+      proof_clauses.clear ();
+    }
+  }
+}
+
+} // end extern C
+
+// Code ported from kissat. Kitten (and kissat) use unsigned representation
+// for literals whereas CaDiCaL uses signed representation. Conversion is
+// necessary for communication using lit2citten and citten2lit.
+// This code is called in elim and kitten is initialized beforehand.
+// To avoid confusion all cadical interal definitions with kitten are called
+// citten.
+//
+void Internal::find_definition (Eliminator &eliminator, int lit) {
+  if (!opts.elimdef)
+    return;
+  if (unsat)
+    return;
+  if (val (lit))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+  assert (!val (lit));
+  assert (!level);
+  assert (citten);
+  const int not_lit = -lit;
+  definition_extractor extractor;
+  extractor.lit = lit;
+  extractor.clauses[0] = occs (lit);
+  extractor.clauses[1] = occs (not_lit);
+  extractor.eliminator = &eliminator;
+  extractor.internal = internal;
+  citten_clear_track_log_terminate ();
+  unsigned exported = 0;
+  for (unsigned sign = 0; sign < 2; sign++) {
+    const unsigned except = sign ? lit2citten (not_lit) : lit2citten (lit);
+    for (auto c : extractor.clauses[sign]) {
+      // to avoid copying the literals of c in their unsigned
+      // representation we instead implement the translation in kitten
+      if (!c->garbage) {
+        LOG (c, "adding to kitten");
+        citten_clause_with_id_and_exception (citten, exported, c->size,
+                                             c->literals, except);
+      }
+      exported++;
+    }
+  }
+  stats.definitions_checked++;
+  const size_t limit = opts.elimdefticks;
+  kitten_set_ticks_limit (citten, limit);
+  int status = kitten_solve (citten);
+  if (!exported)
+    goto ABORT;
+  if (status == 20) {
+    LOG ("sub-solver result UNSAT shows definition exists");
+    uint64_t learned;
+    unsigned reduced = kitten_compute_clausal_core (citten, &learned);
+    LOG ("1st sub-solver core of size %u original clauses out of %u",
+         reduced, exported);
+    for (int i = 2; i <= opts.elimdefcores; i++) {
+      kitten_shrink_to_clausal_core (citten);
+      kitten_shuffle_clauses (citten);
+      kitten_set_ticks_limit (citten, 10 * limit);
+      int tmp = kitten_solve (citten);
+      assert (!tmp || tmp == 20);
+      if (!tmp) {
+        LOG ("aborting core extraction");
+        goto ABORT;
+      }
+#ifndef NDEBUG
+      unsigned previous = reduced;
+#endif
+      reduced = kitten_compute_clausal_core (citten, &learned);
+      LOG ("%d sub-solver core of size %u original clauses out of %u", i,
+           reduced, exported);
+      assert (reduced <= previous);
+#if not defined(LOGGING) && defined(NDEBUG)
+      (void) reduced;
+#endif
+    }
+    stats.definitions_extracted++;
+    eliminator.gatetype = DEF;
+    eliminator.definition_unit = 0;
+    kitten_traverse_core_ids (citten, &extractor, traverse_definition_core);
+    assert (eliminator.definition_unit);
+    int unit = 0;
+    if (eliminator.definition_unit == 2) {
+      unit = not_lit;
+    } else if (eliminator.definition_unit == 1)
+      unit = lit;
+
+    if (unit) {
+      stats.definition_units++;
+      VERBOSE (2, "one sided core "
+                  "definition extraction yields "
+                  "failed literal");
+      if (proof) {
+        if (lrat) {
+          extractor.unit = unit;
+          kitten_trace_core (citten, &extractor,
+                             traverse_one_sided_core_lemma_with_lrat);
+        } else {
+          extractor.unit = unit;
+          kitten_traverse_core_clauses (citten, &extractor,
+                                        traverse_one_sided_core_lemma);
+        }
+      } else
+        assign_unit (unit);
+      elim_propagate (eliminator, unit);
+    }
+  } else {
+  ABORT:
+    LOG ("sub-solver failed to show that definition exists");
+  }
+  stats.definition_ticks += kitten_current_ticks (citten);
+  return;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/delay.hpp

@@ -0,0 +1,38 @@
+#ifndef _delay_hpp_INCLUDED
+#define _delay_hpp_INCLUDED
+
+#include <cstdint>
+#include <limits>
+
+namespace CaDiCaL {
+struct Delay {
+  unsigned count;
+  unsigned current;
+
+  Delay () : count (0), current (0) {}
+
+  bool delay () {
+    if (count) {
+      --count;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  void bump_delay () {
+    current += current < std::numeric_limits<unsigned>::max ();
+    count = current;
+  }
+
+  void reduce_delay () {
+    if (!current)
+      return;
+    current /= 2;
+    count = current;
+  }
+};
+
+} // namespace CaDiCaL
+
+#endif