cadical 0.9.0

data/ext/cadical/cadical/src/file.hpp

@@ -0,0 +1,210 @@
+#ifndef _file_hpp_INCLUDED
+#define _file_hpp_INCLUDED
+
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <vector>
+
+#ifndef NDEBUG
+#include <climits>
+#endif
+
+/*------------------------------------------------------------------------*/
+#ifndef NUNLOCKED
+#define cadical_putc_unlocked putc_unlocked
+#define cadical_getc_unlocked getc_unlocked
+#else
+#define cadical_putc_unlocked putc
+#define cadical_getc_unlocked getc
+#endif
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+// Wraps a 'C' file 'FILE' with name and supports zipped reading and writing
+// through 'popen' using external helper tools.  Reading has line numbers.
+// Compression and decompression relies on external utilities, e.g., 'gzip',
+// 'bzip2', 'xz', and '7z', which should be in the 'PATH'.
+
+struct Internal;
+
+class File {
+
+  Internal *internal;
+#if !defined(QUIET) || !defined(NDEBUG)
+  bool writing;
+#endif
+
+  int close_file; // need to close file (1=fclose, 2=pclose, 3=pipe)
+  int child_pid;
+  FILE *file;
+  char *_name;
+  uint64_t _lineno;
+  uint64_t _bytes;
+
+  File (Internal *, bool, int, int, FILE *, const char *);
+
+  static FILE *open_file (Internal *, const char *path, const char *mode);
+  static FILE *read_file (Internal *, const char *path);
+  static FILE *write_file (Internal *, const char *path);
+
+  static void split_str (const char *, std::vector<char *> &);
+  static void delete_str_vector (std::vector<char *> &);
+
+  static FILE *open_pipe (Internal *, const char *fmt, const char *path,
+                          const char *mode);
+  static FILE *read_pipe (Internal *, const char *fmt, const int *sig,
+                          const char *path);
+#ifndef _WIN32
+  static FILE *write_pipe (Internal *, const char *fmt, const char *path,
+                           int &child_pid);
+#endif
+
+public:
+  static char *find_program (const char *prg); // search in 'PATH'
+  static bool exists (const char *path);       // file exists?
+  static bool writable (const char *path);     // can write to that file?
+  static size_t size (const char *path);       // file size in bytes
+
+  bool piping (); // Is opened file a pipe?
+
+  // Does the file match the file type signature.
+  //
+  static bool match (Internal *, const char *path, const int *sig);
+
+  // Read from existing file. Assume given name.
+  //
+  static File *read (Internal *, FILE *f, const char *name);
+
+  // Open file from path name for reading (possibly through opening a pipe
+  // to a decompression utility, based on the suffix).
+  //
+  static File *read (Internal *, const char *path);
+
+  // Same for writing as for reading above.
+  //
+  static File *write (Internal *, FILE *, const char *name);
+  static File *write (Internal *, const char *path);
+
+  ~File ();
+
+  // Using the 'unlocked' versions here is way faster but
+  // not thread safe if the same file is used by different
+  // threads, which on the other hand currently is impossible.
+
+  int get () {
+    assert (!writing);
+    int res = cadical_getc_unlocked (file);
+    if (res == '\n')
+      _lineno++;
+    if (res != EOF)
+      _bytes++;
+    return res;
+  }
+
+  bool put (char ch) {
+    assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF)
+      return false;
+    _bytes++;
+    return true;
+  }
+
+  bool endl () { return put ('\n'); }
+
+  bool put (unsigned char ch) {
+    assert (writing);
+    if (cadical_putc_unlocked (ch, file) == EOF)
+      return false;
+    _bytes++;
+    return true;
+  }
+
+  bool put (const char *s) {
+    for (const char *p = s; *p; p++)
+      if (!put (*p))
+        return false;
+    return true;
+  }
+
+  bool put (int lit) {
+    assert (writing);
+    if (!lit)
+      return put ('0');
+    else if (lit == -2147483648) {
+      assert (lit == INT_MIN);
+      return put ("-2147483648");
+    } else {
+      char buffer[11];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      assert (lit != INT_MIN);
+      unsigned idx = abs (lit);
+      while (idx) {
+        assert (i > 0);
+        buffer[--i] = '0' + idx % 10;
+        idx /= 10;
+      }
+      if (lit < 0 && !put ('-'))
+        return false;
+      return put (buffer + i);
+    }
+  }
+
+  bool put (int64_t l) {
+    assert (writing);
+    if (!l)
+      return put ('0');
+    else if (l == INT64_MIN) {
+      assert (sizeof l == 8);
+      return put ("-9223372036854775808");
+    } else {
+      char buffer[21];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      assert (l != INT64_MIN);
+      uint64_t k = l < 0 ? -l : l;
+      while (k) {
+        assert (i > 0);
+        buffer[--i] = '0' + k % 10;
+        k /= 10;
+      }
+      if (l < 0 && !put ('-'))
+        return false;
+      return put (buffer + i);
+    }
+  }
+
+  bool put (uint64_t l) {
+    assert (writing);
+    if (!l)
+      return put ('0');
+    else {
+      char buffer[22];
+      int i = sizeof buffer;
+      buffer[--i] = 0;
+      while (l) {
+        assert (i > 0);
+        buffer[--i] = '0' + l % 10;
+        l /= 10;
+      }
+      return put (buffer + i);
+    }
+  }
+
+  const char *name () const { return _name; }
+  uint64_t lineno () const { return _lineno; }
+  uint64_t bytes () const { return _bytes; }
+
+  void connect_internal (Internal *i) { internal = i; }
+  bool closed () { return !file; }
+
+  void close (bool print = false);
+  void flush ();
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/flags.cpp

@@ -0,0 +1,135 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::mark_fixed (int lit) {
+  if (external->fixed_listener) {
+    int elit = externalize (lit);
+    assert (elit);
+    const int eidx = abs (elit);
+    if (!external->ervars[eidx])
+      external->fixed_listener->notify_fixed_assignment (elit);
+  }
+  Flags &f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::FIXED;
+  LOG ("fixed %d", abs (lit));
+  stats.all.fixed++;
+  stats.now.fixed++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.fixed ());
+
+  if (external_prop && private_steps) {
+    // If pre/inprocessing found a fixed assignment, we want the propagator
+    // to know about it.
+    // But at that point it is not guaranteed to be already on the trail, so
+    // notification will happen only later.
+    assert (!level || in_mode (BACKBONE));
+  }
+}
+
+void Internal::mark_eliminated (int lit) {
+  Flags &f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::ELIMINATED;
+  LOG ("eliminated %d", abs (lit));
+  stats.all.eliminated++;
+  stats.now.eliminated++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.eliminated ());
+}
+
+void Internal::mark_pure (int lit) {
+  Flags &f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::PURE;
+  LOG ("pure %d", abs (lit));
+  stats.all.pure++;
+  stats.now.pure++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.pure ());
+}
+
+void Internal::mark_substituted (int lit) {
+  Flags &f = flags (lit);
+  assert (f.status == Flags::ACTIVE);
+  f.status = Flags::SUBSTITUTED;
+  LOG ("substituted %d", abs (lit));
+  stats.all.substituted++;
+  stats.now.substituted++;
+  stats.inactive++;
+  assert (stats.active);
+  stats.active--;
+  assert (!active (lit));
+  assert (f.substituted ());
+}
+
+void Internal::mark_active (int lit) {
+  Flags &f = flags (lit);
+  assert (f.status == Flags::UNUSED);
+  f.status = Flags::ACTIVE;
+  LOG ("activate %d previously unused", abs (lit));
+  assert (stats.inactive);
+  stats.inactive--;
+  assert (stats.unused);
+  stats.unused--;
+  stats.active++;
+  assert (active (lit));
+}
+
+void Internal::reactivate (int lit) {
+  assert (!active (lit));
+  Flags &f = flags (lit);
+  assert (f.status != Flags::FIXED);
+  assert (f.status != Flags::UNUSED);
+#ifdef LOGGING
+  const char *msg = 0;
+#endif
+  switch (f.status) {
+  default:
+  case Flags::ELIMINATED:
+    assert (f.status == Flags::ELIMINATED);
+    assert (stats.now.eliminated > 0);
+    stats.now.eliminated--;
+#ifdef LOGGING
+    msg = "eliminated";
+#endif
+    break;
+  case Flags::SUBSTITUTED:
+#ifdef LOGGING
+    msg = "substituted";
+#endif
+    assert (stats.now.substituted > 0);
+    stats.now.substituted--;
+    break;
+  case Flags::PURE:
+#ifdef LOGGING
+    msg = "pure literal";
+#endif
+    assert (stats.now.pure > 0);
+    stats.now.pure--;
+    break;
+  }
+#ifdef LOGGING
+  assert (msg);
+  LOG ("reactivate previously %s %d", msg, abs (lit));
+#endif
+  f.status = Flags::ACTIVE;
+  f.sweep = false;
+  assert (active (lit));
+  stats.reactivated++;
+  assert (stats.inactive > 0);
+  stats.inactive--;
+  stats.active++;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/flags.hpp

@@ -0,0 +1,93 @@
+#ifndef _flags_hpp_INCLUDED
+#define _flags_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Flags { // Variable flags.
+
+  //  The first set of flags is related to 'analyze' and 'minimize'.
+  //
+  bool seen : 1;       // seen in generating first UIP clause in 'analyze'
+  bool keep : 1;       // keep in learned clause in 'minimize'
+  bool poison : 1;     // can not be removed in 'minimize'
+  bool removable : 1;  // can be removed in 'minimize'
+  bool shrinkable : 1; // can be removed in 'shrink'
+  bool added : 1; // has already been added to lrat_chain (in 'minimize')
+
+  // These three variable flags are used to schedule clauses in subsumption
+  // ('subsume'), variables in bounded variable elimination ('elim') and in
+  // hyper ternary resolution ('ternary').
+  //
+  bool elim : 1;    // removed since last 'elim' round (*)
+  bool subsume : 1; // added since last 'subsume' round (*)
+  bool ternary : 1; // added in ternary clause since last 'ternary' (*)
+  bool sweep : 1;
+  bool blockable : 1;
+
+  unsigned char
+      marked_signed : 2; // generate correct LRAT chains in decompose
+  unsigned char factor : 2;
+
+  // These literal flags are used by blocked clause elimination ('block').
+  //
+  unsigned char block : 2; // removed since last 'block' round (*)
+  unsigned char skip : 2;  // skip this literal as blocking literal
+  bool backbone1, backbone0;
+  // Bits for handling assumptions.
+  //
+  unsigned char assumed : 2;
+  unsigned char failed : 2; // 0 if not part of failure
+                            // 1 if positive lit is in failure
+  // 2 if negated lit is in failure
+  bool factored_but_on_reconstruction_stack : 1;
+
+  enum {
+    UNUSED = 0,
+    ACTIVE = 1,
+    FIXED = 2,
+    ELIMINATED = 3,
+    SUBSTITUTED = 4,
+    PURE = 5
+  };
+
+  unsigned char status : 3;
+
+  // Initialized explicitly in 'Internal::init' through this function.
+  //
+  Flags () {
+    seen = keep = poison = removable = shrinkable = added = sweep =
+        backbone1 = backbone0 = false;
+    subsume = elim = ternary = true;
+    block = 3u;
+    skip = assumed = failed = marked_signed = factor = 0;
+    status = UNUSED;
+  }
+
+  bool unused () const { return status == UNUSED; }
+  bool active () const { return status == ACTIVE; }
+  bool fixed () const { return status == FIXED; }
+  bool eliminated () const { return status == ELIMINATED; }
+  bool substituted () const { return status == SUBSTITUTED; }
+  bool pure () const { return status == PURE; }
+
+  // The flags marked with '(*)' are copied during 'External::copy_flags',
+  // which in essence means they are reset in the copy if they were clear.
+  // This avoids the effort of fruitless preprocessing the copy.
+
+  void copy (Flags &dst) const {
+    dst.elim = elim;
+    dst.subsume = subsume;
+    dst.ternary = ternary;
+    dst.block = block;
+    dst.sweep = sweep;
+    dst.backbone0 = backbone0;
+    dst.backbone1 = backbone1;
+    dst.added = added;
+    dst.factor = factor;
+    // seen, keep, poison, removable, shrinkable are unused
+  }
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/flip.cpp

@@ -0,0 +1,269 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+bool Internal::flip (int lit) {
+
+  // Do not try to flip inactive literals except for unused variables.
+
+  if (!active (lit) && !flags (lit).unused ())
+    return false;
+
+  /*
+  if (flags (lit).unused ()) {
+    assert (lit <= max_var);
+    mark_active (lit);
+    set_val (lit, 1);
+    return true;
+  }
+  */
+
+  // TODO: Unused case is not handled yet.
+  // if (flags (lit).unused ()) return false;
+
+  // Need to reestablish proper watching invariants as if there are no
+  // blocking literals as flipping in principle does not work with them.
+
+  if (propergated < trail.size ())
+    propergate ();
+
+  LOG ("trying to flip %d", lit);
+
+  const int idx = vidx (lit);
+  const signed char original_value = vals[idx];
+  assert (original_value);
+  lit = original_value < 0 ? -idx : idx;
+  assert (val (lit) > 0);
+
+  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
+  // check whether assigning 'lit' to false would break watching invariants
+  // or even make the clause false.  We also try to find replacement
+  // watches in case this fixes the watching invariant.  This code is very
+  // similar to propagation of a literal in 'Internal::propagate'.
+
+  bool res = true;
+
+  Watches &ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  watch_iterator bow = ws.begin ();
+
+  // We first go over binary watches/clauses first as this is cheaper and
+  // has higher chance of failure and we can not use blocking literals.
+
+  for (const_watch_iterator i = bow; i != eow; i++) {
+    const Watch w = *i;
+    if (!w.binary ())
+      continue;
+    const signed char b = val (w.blit);
+    if (b > 0)
+      continue;
+    assert (b < 0);
+    res = false;
+    break;
+  }
+
+  if (res) {
+    const_watch_iterator i = bow;
+    watch_iterator j = bow;
+
+    while (i != eow) {
+
+      const Watch w = *j++ = *i++;
+
+      if (w.binary ())
+        continue;
+
+      if (w.clause->garbage) {
+        j--;
+        continue;
+      }
+
+      literal_iterator lits = w.clause->begin ();
+
+      const int other = lits[0] ^ lits[1] ^ lit;
+      const signed char u = val (other);
+      if (u > 0)
+        continue;
+
+      const int size = w.clause->size;
+      const literal_iterator middle = lits + w.clause->pos;
+      const const_literal_iterator end = lits + size;
+      literal_iterator k = middle;
+
+      int r = 0;
+      signed char v = -1;
+      while (k != end && (v = val (r = *k)) < 0)
+        k++;
+      if (v < 0) {
+        k = lits + 2;
+        assert (w.clause->pos <= size);
+        while (k != middle && (v = val (r = *k)) < 0)
+          k++;
+      }
+
+      if (v < 0) {
+        res = false;
+        break;
+      }
+
+      assert (v > 0);
+      assert (lits + 2 <= k), assert (k <= w.clause->end ());
+      w.clause->pos = k - lits;
+      lits[0] = other, lits[1] = r, *k = lit;
+      watch_literal (r, lit, w.clause);
+      j--;
+    }
+
+    if (j != i) {
+
+      while (i != eow)
+        *j++ = *i++;
+
+      ws.resize (j - ws.begin ());
+    }
+  }
+#ifdef LOGGING
+  if (res)
+    LOG ("literal %d can be flipped", lit);
+  else
+    LOG ("literal %d can not be flipped", lit);
+#endif
+
+  if (res) {
+
+    const int idx = vidx (lit);
+    const signed char original_value = vals[idx];
+    assert (original_value);
+    lit = original_value < 0 ? -idx : idx;
+    assert (val (lit) > 0);
+
+    LOG ("flipping value of %d = 1 to %d = -1", lit, lit);
+
+    set_val (idx, -original_value);
+    assert (val (-lit) > 0);
+    assert (val (lit) < 0);
+
+    Var &v = var (idx);
+    assert (trail[v.trail] == lit);
+    trail[v.trail] = -lit;
+    if (opts.ilb) {
+      if (!changed_val)
+        changed_val = lit;
+      else {
+        assert (val (changed_val));
+        if (v.level < var (changed_val).level) {
+          changed_val = lit;
+        }
+      }
+    }
+  } else
+    LOG ("flipping value of %d failed", lit);
+
+  return res;
+}
+
+bool Internal::flippable (int lit) {
+
+  // Can not check inactive literals except for unused variables.
+
+  if (!active (lit) && !flags (lit).unused ())
+    return false;
+
+  /*
+  if (flags (lit).unused ()) {
+    assert (lit <= max_var);
+    mark_active (lit);
+    return true;
+  }
+  */
+  // TODO: Unused case is not handled yet
+  // if (flags (lit).unused ()) return false;
+
+  // Need to reestablish proper watching invariants as if there are no
+  // blocking literals as flipping in principle does not work with them.
+
+  if (propergated < trail.size ())
+    propergate ();
+
+  LOG ("checking whether %d is flippable", lit);
+
+  const int idx = vidx (lit);
+  const signed char original_value = vals[idx];
+  assert (original_value);
+  lit = original_value < 0 ? -idx : idx;
+  assert (val (lit) > 0);
+
+  // Here we go over all the clauses in which 'lit' is watched by 'lit' and
+  // check whether assigning 'lit' to false would break watching invariants
+  // or even make the clause false.  In contrast to 'flip' we do not try to
+  // find replacement literals but do use blocking literals'.  Therefore we
+  // also do not split the traversal code into two parts.
+
+  bool res = true;
+
+  Watches &ws = watches (lit);
+  const const_watch_iterator eow = ws.end ();
+  for (watch_iterator i = ws.begin (); i != eow; i++) {
+
+    const Watch w = *i;
+    const signed char b = val (w.blit);
+    if (b > 0)
+      continue;
+    assert (b < 0);
+
+    if (w.binary ()) {
+      res = false;
+      break;
+    }
+
+    if (w.clause->garbage)
+      continue;
+
+    literal_iterator lits = w.clause->begin ();
+
+    const int other = lits[0] ^ lits[1] ^ lit;
+    const signed char u = val (other);
+    if (u > 0) {
+      i->blit = other;
+      continue;
+    }
+
+    const int size = w.clause->size;
+    const literal_iterator middle = lits + w.clause->pos;
+    const const_literal_iterator end = lits + size;
+    literal_iterator k = middle;
+
+    int r = 0;
+    signed char v = -1;
+    while (k != end && (v = val (r = *k)) < 0)
+      k++;
+    if (v < 0) {
+      k = lits + 2;
+      assert (w.clause->pos <= size);
+      while (k != middle && (v = val (r = *k)) < 0)
+        k++;
+    }
+
+    if (v < 0) {
+      res = false;
+      break;
+    }
+
+    assert (v > 0);
+    assert (lits + 2 <= k);
+    assert (k <= w.clause->end ());
+    w.clause->pos = k - lits;
+    i->blit = r;
+  }
+
+#ifdef LOGGING
+  if (res)
+    LOG ("literal %d can be flipped", lit);
+  else
+    LOG ("literal %d can not be flipped", lit);
+#endif
+
+  return res;
+}
+
+} // namespace CaDiCaL