ezsat.h

Go to the documentation of this file.

/*
 *  ezSAT -- A simple and easy to use CNF generator for SAT solvers
 *
 *  Copyright (C) 2013  Clifford Wolf <clifford@clifford.at>
 *  
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *  
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#ifndef EZSAT_H
#define EZSAT_H

#include <set>
#include <map>
#include <vector>
#include <string>
#include <stdio.h>
#include <stdint.h>

class ezSAT
{
    // each token (terminal or non-terminal) is represented by an interger number
    //
    // the zero token:
    // the number zero is not used as valid token number and is used to encode
    // unused parameters for the functions.
    //
    // positive numbers are literals, with 1 = CONST_TRUE and 2 = CONST_FALSE;
    //
    // negative numbers are non-literal expressions. each expression is represented
    // by an operator id and a list of expressions (literals or non-literals).

public:
    enum OpId {
        OpNot, OpAnd, OpOr, OpXor, OpIFF, OpITE
    };

    static const int CONST_TRUE;
    static const int CONST_FALSE;

private:
    bool flag_keep_cnf;
    bool flag_non_incremental;

    bool non_incremental_solve_used_up;

    std::map<std::string, int> literalsCache;
    std::vector<std::string> literals;

    std::map<std::pair<OpId, std::vector<int>>, int> expressionsCache;
    std::vector<std::pair<OpId, std::vector<int>>> expressions;

    bool cnfConsumed;
    int cnfVariableCount, cnfClausesCount;
    std::vector<int> cnfLiteralVariables, cnfExpressionVariables;
    std::vector<std::vector<int>> cnfClauses, cnfClausesBackup;

    void add_clause(const std::vector<int> &args);
    void add_clause(const std::vector<int> &args, bool argsPolarity, int a = 0, int b = 0, int c = 0);
    void add_clause(int a, int b = 0, int c = 0);

    int bind_cnf_not(const std::vector<int> &args);
    int bind_cnf_and(const std::vector<int> &args);
    int bind_cnf_or(const std::vector<int> &args);

protected:
    void preSolverCallback();

public:
    int solverTimeout;
    bool solverTimoutStatus;

    ezSAT();
    virtual ~ezSAT();

    void keep_cnf() { flag_keep_cnf = true; }
    void non_incremental() { flag_non_incremental = true; }

    bool mode_keep_cnf() const { return flag_keep_cnf; }
    bool mode_non_incremental() const { return flag_non_incremental; }

    // manage expressions

    int value(bool val);
    int literal();
    int literal(const std::string &name);
    int frozen_literal();
    int frozen_literal(const std::string &name);
    int expression(OpId op, int a = 0, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0);
    int expression(OpId op, const std::vector<int> &args);

    void lookup_literal(int id, std::string &name) const;
    const std::string &lookup_literal(int id) const;

    void lookup_expression(int id, OpId &op, std::vector<int> &args) const;
    const std::vector<int> &lookup_expression(int id, OpId &op) const;

    int parse_string(const std::string &text);
    std::string to_string(int id) const;

    int numLiterals() const { return literals.size(); }
    int numExpressions() const { return expressions.size(); }

    int eval(int id, const std::vector<int> &values) const;

    // SAT solver interface
    // If you are planning on using the solver API (and not simply create a CNF) you must use a child class
    // of ezSAT that actually implements a solver backend, such as ezMiniSAT (see ezminisat.h).

    virtual bool solver(const std::vector<int> &modelExpressions, std::vector<bool> &modelValues, const std::vector<int> &assumptions);

    bool solve(const std::vector<int> &modelExpressions, std::vector<bool> &modelValues, const std::vector<int> &assumptions) {
        return solver(modelExpressions, modelValues, assumptions);
    }

    bool solve(const std::vector<int> &modelExpressions, std::vector<bool> &modelValues, int a = 0, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0) {
        std::vector<int> assumptions;
        if (a != 0) assumptions.push_back(a);
        if (b != 0) assumptions.push_back(b);
        if (c != 0) assumptions.push_back(c);
        if (d != 0) assumptions.push_back(d);
        if (e != 0) assumptions.push_back(e);
        if (f != 0) assumptions.push_back(f);
        return solver(modelExpressions, modelValues, assumptions);
    }

    bool solve(int a = 0, int b = 0, int c = 0, int d = 0, int e = 0, int f = 0) {
        std::vector<int> assumptions, modelExpressions;
        std::vector<bool> modelValues;
        if (a != 0) assumptions.push_back(a);
        if (b != 0) assumptions.push_back(b);
        if (c != 0) assumptions.push_back(c);
        if (d != 0) assumptions.push_back(d);
        if (e != 0) assumptions.push_back(e);
        if (f != 0) assumptions.push_back(f);
        return solver(modelExpressions, modelValues, assumptions);
    }

    void setSolverTimeout(int newTimeoutSeconds) {
        solverTimeout = newTimeoutSeconds;
    }

    bool getSolverTimoutStatus() {
        return solverTimoutStatus;
    }

    // manage CNF (usually only accessed by SAT solvers)

    virtual void clear();
    virtual void freeze(int id);
    virtual bool eliminated(int idx);
    void assume(int id);
    int bind(int id, bool auto_freeze = true);
    int bound(int id) const;

    int numCnfVariables() const { return cnfVariableCount; }
    int numCnfClauses() const { return cnfClausesCount; }
    const std::vector<std::vector<int>> &cnf() const { return cnfClauses; }

    void consumeCnf();
    void consumeCnf(std::vector<std::vector<int>> &cnf);

    // use this function to get the full CNF in keep_cnf mode
    void getFullCnf(std::vector<std::vector<int>> &full_cnf) const;

    std::string cnfLiteralInfo(int idx) const;

    // simple helpers for build expressions easily

    struct _V {
        int id;
        std::string name;
        _V(int id) : id(id) { }
        _V(const char *name) : id(0), name(name) { }
        _V(const std::string &name) : id(0), name(name) { }
        int get(ezSAT *that) {
            if (name.empty())
                return id;
            return that->frozen_literal(name);
        }
    };

    int VAR(_V a) {
        return a.get(this);
    }

    int NOT(_V a) {
        return expression(OpNot, a.get(this));
    }

    int AND(_V a = 0, _V b = 0, _V c = 0, _V d = 0, _V e = 0, _V f = 0) {
        return expression(OpAnd, a.get(this), b.get(this), c.get(this), d.get(this), e.get(this), f.get(this));
    }

    int OR(_V a = 0, _V b = 0, _V c = 0, _V d = 0, _V e = 0, _V f = 0) {
        return expression(OpOr, a.get(this), b.get(this), c.get(this), d.get(this), e.get(this), f.get(this));
    }

    int XOR(_V a = 0, _V b = 0, _V c = 0, _V d = 0, _V e = 0, _V f = 0) {
        return expression(OpXor, a.get(this), b.get(this), c.get(this), d.get(this), e.get(this), f.get(this));
    }

    int IFF(_V a, _V b = 0, _V c = 0, _V d = 0, _V e = 0, _V f = 0) {
        return expression(OpIFF, a.get(this), b.get(this), c.get(this), d.get(this), e.get(this), f.get(this));
    }

    int ITE(_V a, _V b, _V c) {
        return expression(OpITE, a.get(this), b.get(this), c.get(this));
    }

    void SET(_V a, _V b) {
        assume(IFF(a.get(this), b.get(this)));
    }

    // simple helpers for building expressions with bit vectors

    std::vector<int> vec_const(const std::vector<bool> &bits);
    std::vector<int> vec_const_signed(int64_t value, int numBits);
    std::vector<int> vec_const_unsigned(uint64_t value, int numBits);
    std::vector<int> vec_var(int numBits);
    std::vector<int> vec_var(std::string name, int numBits);
    std::vector<int> vec_cast(const std::vector<int> &vec1, int toBits, bool signExtend = false);

    std::vector<int> vec_not(const std::vector<int> &vec1);
    std::vector<int> vec_and(const std::vector<int> &vec1, const std::vector<int> &vec2);
    std::vector<int> vec_or(const std::vector<int> &vec1, const std::vector<int> &vec2);
    std::vector<int> vec_xor(const std::vector<int> &vec1, const std::vector<int> &vec2);

    std::vector<int> vec_iff(const std::vector<int> &vec1, const std::vector<int> &vec2);
    std::vector<int> vec_ite(const std::vector<int> &vec1, const std::vector<int> &vec2, const std::vector<int> &vec3);
    std::vector<int> vec_ite(int sel, const std::vector<int> &vec1, const std::vector<int> &vec2);

    std::vector<int> vec_count(const std::vector<int> &vec, int numBits, bool clip = true);
    std::vector<int> vec_add(const std::vector<int> &vec1, const std::vector<int> &vec2);
    std::vector<int> vec_sub(const std::vector<int> &vec1, const std::vector<int> &vec2);
    std::vector<int> vec_neg(const std::vector<int> &vec);

    void vec_cmp(const std::vector<int> &vec1, const std::vector<int> &vec2, int &carry, int &overflow, int &sign, int &zero);

    int vec_lt_signed(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_le_signed(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_ge_signed(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_gt_signed(const std::vector<int> &vec1, const std::vector<int> &vec2);

    int vec_lt_unsigned(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_le_unsigned(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_ge_unsigned(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_gt_unsigned(const std::vector<int> &vec1, const std::vector<int> &vec2);

    int vec_eq(const std::vector<int> &vec1, const std::vector<int> &vec2);
    int vec_ne(const std::vector<int> &vec1, const std::vector<int> &vec2);

    std::vector<int> vec_shl(const std::vector<int> &vec1, int shift, bool signExtend = false);
    std::vector<int> vec_srl(const std::vector<int> &vec1, int shift);

    std::vector<int> vec_shr(const std::vector<int> &vec1, int shift, bool signExtend = false) { return vec_shl(vec1, -shift, signExtend); }
    std::vector<int> vec_srr(const std::vector<int> &vec1, int shift) { return vec_srl(vec1, -shift); }

    std::vector<int> vec_shift(const std::vector<int> &vec1, int shift, int extend_left, int extend_right);
    std::vector<int> vec_shift_right(const std::vector<int> &vec1, const std::vector<int> &vec2, bool vec2_signed, int extend_left, int extend_right);
    std::vector<int> vec_shift_left(const std::vector<int> &vec1, const std::vector<int> &vec2, bool vec2_signed, int extend_left, int extend_right);

    void vec_append(std::vector<int> &vec, const std::vector<int> &vec1) const;
    void vec_append_signed(std::vector<int> &vec, const std::vector<int> &vec1, int64_t value);
    void vec_append_unsigned(std::vector<int> &vec, const std::vector<int> &vec1, uint64_t value);

    int64_t vec_model_get_signed(const std::vector<int> &modelExpressions, const std::vector<bool> &modelValues, const std::vector<int> &vec1) const;
    uint64_t vec_model_get_unsigned(const std::vector<int> &modelExpressions, const std::vector<bool> &modelValues, const std::vector<int> &vec1) const;

    int vec_reduce_and(const std::vector<int> &vec1);
    int vec_reduce_or(const std::vector<int> &vec1);

    void vec_set(const std::vector<int> &vec1, const std::vector<int> &vec2);
    void vec_set_signed(const std::vector<int> &vec1, int64_t value);
    void vec_set_unsigned(const std::vector<int> &vec1, uint64_t value);

    // helpers for generating ezSATbit and ezSATvec objects

    struct ezSATbit bit(_V a);
    struct ezSATvec vec(const std::vector<int> &vec);

    // printing CNF and internal state

    void printDIMACS(FILE *f, bool verbose = false) const;
    void printInternalState(FILE *f) const;

    // more sophisticated constraints (designed to be used directly with assume(..))

    int onehot(const std::vector<int> &vec, bool max_only = false);
    int manyhot(const std::vector<int> &vec, int min_hot, int max_hot = -1);
    int ordered(const std::vector<int> &vec1, const std::vector<int> &vec2, bool allow_equal = true);
};

// helper classes for using operator overloading when generating complex expressions

struct ezSATbit
{
    ezSAT &sat;
    int id;

    ezSATbit(ezSAT &sat, ezSAT::_V a) : sat(sat), id(sat.VAR(a)) { }

    ezSATbit operator ~() { return ezSATbit(sat, sat.NOT(id)); }
    ezSATbit operator &(const ezSATbit &other) { return ezSATbit(sat, sat.AND(id, other.id)); }
    ezSATbit operator |(const ezSATbit &other) { return ezSATbit(sat, sat.OR(id, other.id)); }
    ezSATbit operator ^(const ezSATbit &other) { return ezSATbit(sat, sat.XOR(id, other.id)); }
    ezSATbit operator ==(const ezSATbit &other) { return ezSATbit(sat, sat.IFF(id, other.id)); }
    ezSATbit operator !=(const ezSATbit &other) { return ezSATbit(sat, sat.NOT(sat.IFF(id, other.id))); }

    operator int() const { return id; }
    operator ezSAT::_V() const { return ezSAT::_V(id); }
    operator std::vector<int>() const { return std::vector<int>(1, id); }
};

struct ezSATvec
{
    ezSAT &sat;
    std::vector<int> vec;

    ezSATvec(ezSAT &sat, const std::vector<int> &vec) : sat(sat), vec(vec) { }

    ezSATvec operator ~() { return ezSATvec(sat, sat.vec_not(vec)); }
    ezSATvec operator -() { return ezSATvec(sat, sat.vec_neg(vec)); }

    ezSATvec operator &(const ezSATvec &other) { return ezSATvec(sat, sat.vec_and(vec, other.vec)); }
    ezSATvec operator |(const ezSATvec &other) { return ezSATvec(sat, sat.vec_or(vec, other.vec)); }
    ezSATvec operator ^(const ezSATvec &other) { return ezSATvec(sat, sat.vec_xor(vec, other.vec)); }

    ezSATvec operator +(const ezSATvec &other) { return ezSATvec(sat, sat.vec_add(vec, other.vec)); }
    ezSATvec operator -(const ezSATvec &other) { return ezSATvec(sat, sat.vec_sub(vec, other.vec)); }

    ezSATbit operator < (const ezSATvec &other) { return ezSATbit(sat, sat.vec_lt_unsigned(vec, other.vec)); }
    ezSATbit operator <=(const ezSATvec &other) { return ezSATbit(sat, sat.vec_le_unsigned(vec, other.vec)); }
    ezSATbit operator ==(const ezSATvec &other) { return ezSATbit(sat, sat.vec_eq(vec, other.vec)); }
    ezSATbit operator !=(const ezSATvec &other) { return ezSATbit(sat, sat.vec_ne(vec, other.vec)); }
    ezSATbit operator >=(const ezSATvec &other) { return ezSATbit(sat, sat.vec_ge_unsigned(vec, other.vec)); }
    ezSATbit operator > (const ezSATvec &other) { return ezSATbit(sat, sat.vec_gt_unsigned(vec, other.vec)); }

    ezSATvec operator <<(int shift) { return ezSATvec(sat, sat.vec_shl(vec, shift)); }
    ezSATvec operator >>(int shift) { return ezSATvec(sat, sat.vec_shr(vec, shift)); }

    operator std::vector<int>() const { return vec; }
};

#endif