cadical 0.9.0

data/ext/cadical/cadical/src/gates.cpp

@@ -0,0 +1,766 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// As in our original SATeLite published at SAT'05 we are trying to find
+// gates in order to restrict the number of resolutions that need to be
+// tried.  If there is such a gate, we only need to consider resolvents
+// among gate and one non-gate clauses.  Resolvents between definitions will
+// be tautological anyhow and resolvents among non-gates can actually be
+// shown to be redundant too.
+
+/*------------------------------------------------------------------------*/
+
+// The next function returns a non-zero if the clause 'c', which is assumed
+// to contain the literal 'first', after removing falsified literals is a
+// binary clause.  Then the actual second literal is returned.
+
+int Internal::second_literal_in_binary_clause (Eliminator &eliminator,
+                                               Clause *c, int first) {
+  assert (!c->garbage);
+  int second = 0;
+  for (const auto &lit : *c) {
+    if (lit == first)
+      continue;
+    const signed char tmp = val (lit);
+    if (tmp < 0)
+      continue;
+    if (tmp > 0) {
+      mark_garbage (c);
+      elim_update_removed_clause (eliminator, c);
+      return 0;
+    }
+    if (second) {
+      second = INT_MIN;
+      break;
+    }
+    second = lit;
+  }
+  if (!second)
+    return 0;
+  if (second == INT_MIN)
+    return 0;
+  assert (active (second));
+#ifdef LOGGING
+  if (c->size == 2)
+    LOG (c, "found binary");
+  else
+    LOG (c, "found actual binary %d %d", first, second);
+#endif
+  return second;
+}
+
+/*------------------------------------------------------------------------*/
+
+// need a copy from above that does not care about garbage
+
+int Internal::second_literal_in_binary_clause_lrat (Clause *c, int first) {
+  if (c->garbage)
+    return 0;
+  int second = 0;
+  for (const auto &lit : *c) {
+    if (lit == first)
+      continue;
+    const signed char tmp = val (lit);
+    if (tmp < 0)
+      continue;
+    if (tmp > 0)
+      return 0;
+    if (!tmp) {
+      if (second) {
+        second = INT_MIN;
+        break;
+      }
+      second = lit;
+    }
+  }
+  if (!second)
+    return 0;
+  if (second == INT_MIN)
+    return 0;
+  return second;
+}
+
+// I needed to find the second clause for hyper unary resolution to build
+// LRAT this is not efficient but I could not find a better way then just
+// finding the corresponding clause in all possible clauses
+//
+Clause *Internal::find_binary_clause (int first, int second) {
+  int best = first;
+  int other = second;
+  if (occs (first).size () > occs (second).size ()) {
+    best = second;
+    other = first;
+  }
+  for (auto c : occs (best))
+    if (second_literal_in_binary_clause_lrat (c, best) == other)
+      return c;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Mark all other literals in binary clauses with 'first'.  During this
+// marking we might also detect hyper unary resolvents producing a unit.
+// If such a unit is found we propagate it and return immediately.
+
+void Internal::mark_binary_literals (Eliminator &eliminator, int first) {
+
+  if (unsat)
+    return;
+  if (val (first))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  assert (!marked (first));
+  assert (eliminator.marked.empty ());
+
+  const Occs &os = occs (first);
+  for (const auto &c : os) {
+    if (c->garbage)
+      continue;
+    const int second =
+        second_literal_in_binary_clause (eliminator, c, first);
+    if (!second)
+      continue;
+    const int tmp = marked (second);
+    if (tmp < 0) {
+      // had a bug where units could occur multiple times here
+      // solved with flags
+      LOG ("found binary resolved unit %d", first);
+      if (lrat) {
+        Clause *d = find_binary_clause (first, -second);
+        assert (d);
+        for (auto &lit : *d) {
+          if (lit == first || lit == -second)
+            continue;
+          assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        for (auto &lit : *c) {
+          if (lit == first || lit == second)
+            continue;
+          assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        lrat_chain.push_back (c->id);
+        lrat_chain.push_back (d->id);
+        // LOG ("gates added id %" PRId64, c->id);
+        // LOG ("gates added id %" PRId64, d->id);
+        clear_analyzed_literals ();
+      }
+      assign_unit (first);
+      elim_propagate (eliminator, first);
+      return;
+    }
+    if (tmp > 0) {
+      LOG (c, "duplicated actual binary clause");
+      elim_update_removed_clause (eliminator, c);
+      mark_garbage (c);
+      continue;
+    }
+    eliminator.marked.push_back (second);
+    mark (second);
+    LOG ("marked second literal %d in binary clause %d %d", second, first,
+         second);
+  }
+}
+
+// Unmark all literals saved on the 'marked' stack.
+
+void Internal::unmark_binary_literals (Eliminator &eliminator) {
+  LOG ("unmarking %zd literals", eliminator.marked.size ());
+  for (const auto &lit : eliminator.marked)
+    unmark (lit);
+  eliminator.marked.clear ();
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find equivalence for 'pivot'.  Requires that all other literals in binary
+// clauses with 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_equivalence (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimequivs)
+    return;
+
+  assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot))
+    goto DONE;
+
+  for (const auto &c : occs (-pivot)) {
+
+    if (c->garbage)
+      continue;
+
+    const int second =
+        second_literal_in_binary_clause (eliminator, c, -pivot);
+    if (!second)
+      continue;
+    const int tmp = marked (second);
+    if (tmp > 0) {
+      LOG ("found binary resolved unit %d", second);
+      // did not find a bug where units could occur multiple times here
+      // still solved potential issues with flags
+      if (lrat) {
+        Clause *d = find_binary_clause (pivot, second);
+        assert (d);
+        for (auto &lit : *d) {
+          if (lit == pivot || lit == second)
+            continue;
+          assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        for (auto &lit : *c) {
+          if (lit == -pivot || lit == second)
+            continue;
+          assert (val (lit) < 0);
+          Flags &f = flags (lit);
+          if (f.seen)
+            continue;
+          analyzed.push_back (lit);
+          f.seen = true;
+          int64_t id = unit_id (-lit);
+          lrat_chain.push_back (id);
+          // LOG ("gates added id %" PRId64, id);
+        }
+        lrat_chain.push_back (c->id);
+        lrat_chain.push_back (d->id);
+        clear_analyzed_literals ();
+        // LOG ("gates added id %" PRId64, c->id);
+        // LOG ("gates added id %" PRId64, d->id);
+      }
+      assign_unit (second);
+      elim_propagate (eliminator, second);
+      if (val (pivot))
+        break;
+      if (unsat)
+        break;
+    }
+    if (tmp >= 0)
+      continue;
+
+    LOG ("found equivalence %d = %d", pivot, -second);
+    stats.elimequivs++;
+    stats.elimgates++;
+
+    LOG (c, "first gate clause");
+    assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+
+    Clause *d = 0;
+    const Occs &ps = occs (pivot);
+    for (const auto &e : ps) {
+      if (e->garbage)
+        continue;
+      const int other =
+          second_literal_in_binary_clause (eliminator, e, pivot);
+      if (other == -second) {
+        d = e;
+        break;
+      }
+    }
+    assert (d);
+
+    LOG (d, "second gate clause");
+    assert (!d->gate);
+    d->gate = true;
+    eliminator.gates.push_back (d);
+    eliminator.gatetype = EQUI;
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and gates for 'pivot' with a long clause, in which the pivot occurs
+// positively.  Requires that all other literals in binary clauses with
+// 'pivot' are marked (through 'mark_binary_literals');
+
+void Internal::find_and_gate (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimands)
+    return;
+
+  assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  mark_binary_literals (eliminator, pivot);
+  if (unsat || val (pivot))
+    goto DONE;
+
+  for (const auto &c : occs (-pivot)) {
+
+    if (c->garbage)
+      continue;
+    if (c->size < 3)
+      continue;
+
+    bool all_literals_marked = true;
+    unsigned arity = 0;
+    int satisfied = 0;
+
+    for (const auto &lit : *c) {
+      if (lit == -pivot)
+        continue;
+      assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0)
+        continue;
+      if (tmp > 0) {
+        satisfied = lit;
+        break;
+      }
+      tmp = marked (lit);
+      if (tmp < 0) {
+        arity++;
+        continue;
+      }
+      all_literals_marked = false;
+      break;
+    }
+
+    if (!all_literals_marked)
+      continue;
+
+    if (satisfied) {
+      LOG (c, "satisfied by %d candidate base clause", satisfied);
+      mark_garbage (c);
+      continue;
+    }
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u AND gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto &lit : *c) {
+        if (lit == -pivot)
+          continue;
+        assert (lit != pivot);
+        if (!first)
+          fputs (" & ", stdout);
+        printf ("%d", -lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimands++;
+    stats.elimgates++;
+    eliminator.gatetype = AND;
+
+    (void) arity;
+    assert (!c->gate);
+    c->gate = true;
+    eliminator.gates.push_back (c);
+    for (const auto &lit : *c) {
+      if (lit == -pivot)
+        continue;
+      assert (lit != pivot);
+      signed char tmp = val (lit);
+      if (tmp < 0)
+        continue;
+      assert (!tmp);
+      assert (marked (lit) < 0);
+      marks[vidx (lit)] *= 2;
+    }
+
+    unsigned count = 0;
+    for (const auto &d : occs (pivot)) {
+      if (d->garbage)
+        continue;
+      const int other =
+          second_literal_in_binary_clause (eliminator, d, pivot);
+      if (!other)
+        continue;
+      const int tmp = marked (other);
+      if (tmp != 2)
+        continue;
+      LOG (d, "AND gate binary side clause");
+      assert (!d->gate);
+      d->gate = true;
+      eliminator.gates.push_back (d);
+      count++;
+    }
+    assert (count >= arity);
+    (void) count;
+
+    break;
+  }
+
+DONE:
+  unmark_binary_literals (eliminator);
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract ternary clauses.
+
+bool Internal::get_ternary_clause (Clause *d, int &a, int &b, int &c) {
+  if (d->garbage)
+    return false;
+  if (d->size < 3)
+    return false;
+  int found = 0;
+  a = b = c = 0;
+  for (const auto &lit : *d) {
+    if (val (lit))
+      continue;
+    if (++found == 1)
+      a = lit;
+    else if (found == 2)
+      b = lit;
+    else if (found == 3)
+      c = lit;
+    else
+      return false;
+  }
+  return found == 3;
+}
+
+// This function checks whether 'd' exists as ternary clause.
+
+bool Internal::match_ternary_clause (Clause *d, int a, int b, int c) {
+  if (d->garbage)
+    return false;
+  int found = 0;
+  for (const auto &lit : *d) {
+    if (val (lit))
+      continue;
+    if (a != lit && b != lit && c != lit)
+      return false;
+    found++;
+  }
+  return found == 3;
+}
+
+Clause *Internal::find_ternary_clause (int a, int b, int c) {
+  if (occs (b).size () > occs (c).size ())
+    swap (b, c);
+  if (occs (a).size () > occs (b).size ())
+    swap (a, b);
+  for (auto d : occs (a))
+    if (match_ternary_clause (d, a, b, c))
+      return d;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find if-then-else gate.
+
+void Internal::find_if_then_else (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimites)
+    return;
+
+  assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  const Occs &os = occs (pivot);
+  const auto end = os.end ();
+  for (auto i = os.begin (); i != end; i++) {
+    Clause *di = *i;
+    int ai, bi, ci;
+    if (!get_ternary_clause (di, ai, bi, ci))
+      continue;
+    if (bi == pivot)
+      swap (ai, bi);
+    if (ci == pivot)
+      swap (ai, ci);
+    assert (ai == pivot);
+    for (auto j = i + 1; j != end; j++) {
+      Clause *dj = *j;
+      int aj, bj, cj;
+      if (!get_ternary_clause (dj, aj, bj, cj))
+        continue;
+      if (bj == pivot)
+        swap (aj, bj);
+      if (cj == pivot)
+        swap (aj, cj);
+      assert (aj == pivot);
+      if (abs (bi) == abs (cj))
+        swap (bj, cj);
+      if (abs (ci) == abs (cj))
+        continue;
+      if (bi != -bj)
+        continue;
+      Clause *d1 = find_ternary_clause (-pivot, bi, -ci);
+      if (!d1)
+        continue;
+      Clause *d2 = find_ternary_clause (-pivot, bj, -cj);
+      if (!d2)
+        continue;
+      LOG (di, "1st if-then-else");
+      LOG (dj, "2nd if-then-else");
+      LOG (d1, "3rd if-then-else");
+      LOG (d2, "4th if-then-else");
+      LOG ("found ITE gate %d == (%d ? %d : %d)", pivot, -bi, -ci, -cj);
+      assert (!di->gate);
+      assert (!dj->gate);
+      assert (!d1->gate);
+      assert (!d2->gate);
+      di->gate = true;
+      dj->gate = true;
+      d1->gate = true;
+      d2->gate = true;
+      eliminator.gates.push_back (di);
+      eliminator.gates.push_back (dj);
+      eliminator.gates.push_back (d1);
+      eliminator.gates.push_back (d2);
+      stats.elimgates++;
+      stats.elimites++;
+      eliminator.gatetype = ITE;
+      return;
+    }
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find and extract clause.
+
+bool Internal::get_clause (Clause *c, vector<int> &l) {
+  if (c->garbage)
+    return false;
+  l.clear ();
+  for (const auto &lit : *c) {
+    if (val (lit) < 0)
+      continue;
+    if (val (lit) > 0) {
+      l.clear ();
+      return false;
+    }
+    l.push_back (lit);
+  }
+  return true;
+}
+
+// Check whether 'c' contains only the literals in 'l'.
+
+bool Internal::is_clause (Clause *c, const vector<int> &lits) {
+  if (c->garbage)
+    return false;
+  int size = lits.size ();
+  if (c->size < size)
+    return false;
+  int found = 0;
+  for (const auto &lit : *c) {
+    if (val (lit) < 0)
+      continue;
+    if (val (lit) > 0)
+      return false;
+    const auto it = find (lits.begin (), lits.end (), lit);
+    if (it == lits.end ())
+      return false;
+    if (++found > size)
+      return false;
+  }
+  return found == size;
+}
+
+Clause *Internal::find_clause (const vector<int> &lits) {
+  int best = 0;
+  size_t len = 0;
+  for (const auto &lit : lits) {
+    size_t l = occs (lit).size ();
+    if (best && l >= len)
+      continue;
+    len = l, best = lit;
+  }
+  for (auto c : occs (best))
+    if (is_clause (c, lits))
+      return c;
+  return 0;
+}
+
+void Internal::find_xor_gate (Eliminator &eliminator, int pivot) {
+
+  if (!opts.elimxors)
+    return;
+
+  assert (opts.elimsubst);
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+  if (!eliminator.gates.empty ())
+    return;
+
+  vector<int> lits;
+
+  for (auto d : occs (pivot)) {
+
+    if (!get_clause (d, lits))
+      continue;
+
+    const int size = lits.size (); // clause size
+    const int arity = size - 1;    // arity of XOR
+
+    if (size < 3)
+      continue;
+    if (arity > opts.elimxorlim)
+      continue;
+
+    assert (eliminator.gates.empty ());
+
+    unsigned needed = (1u << arity) - 1; // additional clauses
+    unsigned signs = 0;                  // literals to negate
+
+    do {
+      const unsigned prev = signs;
+      while (parity (++signs))
+        ;
+      for (int j = 0; j < size; j++) {
+        const unsigned bit = 1u << j;
+        int lit = lits[j];
+        if ((prev & bit) != (signs & bit))
+          lits[j] = lit = -lit;
+      }
+      Clause *e = find_clause (lits);
+      if (!e)
+        break;
+      eliminator.gates.push_back (e);
+    } while (--needed);
+
+    if (needed) {
+      eliminator.gates.clear ();
+      continue;
+    }
+
+    eliminator.gates.push_back (d);
+    assert (eliminator.gates.size () == (1u << arity));
+
+#ifdef LOGGING
+    if (opts.log) {
+      Logger::print_log_prefix (this);
+      tout.magenta ();
+      printf ("found arity %u XOR gate %d = ", arity, -pivot);
+      bool first = true;
+      for (const auto &lit : *d) {
+        if (lit == pivot)
+          continue;
+        assert (lit != -pivot);
+        if (!first)
+          fputs (" ^ ", stdout);
+        printf ("%d", lit);
+        first = false;
+      }
+      fputc ('\n', stdout);
+      tout.normal ();
+      fflush (stdout);
+    }
+#endif
+    stats.elimgates++;
+    stats.elimxors++;
+    const auto end = eliminator.gates.end ();
+    auto j = eliminator.gates.begin ();
+    for (auto i = j; i != end; i++) {
+      Clause *e = *i;
+      if (e->gate)
+        continue;
+      e->gate = true;
+      LOG (e, "contributing");
+      *j++ = e;
+    }
+    eliminator.gates.resize (j - eliminator.gates.begin ());
+    eliminator.gatetype = XOR;
+    break;
+  }
+}
+
+/*------------------------------------------------------------------------*/
+
+// Find a gate for 'pivot'.  If such a gate is found, the gate clauses are
+// marked and pushed on the stack of gates.  Further hyper unary resolution
+// might detect units, which are propagated.  This might assign the pivot or
+// even produce the empty clause.
+
+void Internal::find_gate_clauses (Eliminator &eliminator, int pivot) {
+  if (!opts.elimsubst)
+    return;
+
+  if (unsat)
+    return;
+  if (val (pivot))
+    return;
+
+  assert (eliminator.gates.empty ());
+
+  find_equivalence (eliminator, pivot);
+  find_and_gate (eliminator, pivot);
+  find_and_gate (eliminator, -pivot);
+  find_if_then_else (eliminator, pivot);
+  find_xor_gate (eliminator, pivot);
+  find_definition (eliminator, pivot);
+}
+
+void Internal::unmark_gate_clauses (Eliminator &eliminator) {
+  LOG ("unmarking %zd gate clauses", eliminator.gates.size ());
+  for (const auto &c : eliminator.gates) {
+    assert (c->gate);
+    c->gate = false;
+  }
+  eliminator.gates.clear ();
+  eliminator.definition_unit = 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL