z3-z3-4.13.0.src.sat.smt.pb_constraint.h Maven / Gradle / Ivy
The newest version!
/*++
Copyright (c) 2017 Microsoft Corporation
Module Name:
pb_constraint.h
Abstract:
Interface for Boolean constraints.
Author:
Nikolaj Bjorner (nbjorner) 2017-01-30
Revision History:
--*/
#pragma once
#include "sat/smt/pb_solver_interface.h"
namespace pb {
enum class tag_t {
card_t,
pb_t
};
class card;
class pbc;
inline lbool value(sat::model const& m, literal l) { return l.sign() ? ~m[l.var()] : m[l.var()]; }
class constraint {
protected:
tag_t m_tag;
bool m_removed { false };
literal m_lit;
literal m_watch { sat::null_literal };
unsigned m_glue { 0 };
unsigned m_psm { 0 };
unsigned m_size;
size_t m_obj_size;
bool m_learned { false };
unsigned m_id;
bool m_pure { false }; // is the constraint pure (only positive occurrences)
unsigned m_k;
void display_lit(std::ostream& out, solver_interface const& s, literal lit, unsigned sz, bool values) const;
public:
constraint(tag_t t, unsigned id, literal l, unsigned sz, size_t osz, unsigned k):
m_tag(t), m_lit(l), m_size(sz), m_obj_size(osz), m_id(id), m_k(k) {
}
virtual ~constraint() = default;
sat::ext_constraint_idx cindex() const { return sat::constraint_base::mem2base(this); }
void deallocate(small_object_allocator& a) { a.deallocate(obj_size(), sat::constraint_base::mem2base_ptr(this)); }
unsigned id() const { return m_id; }
tag_t tag() const { return m_tag; }
literal lit() const { return m_lit; }
unsigned size() const { return m_size; }
void set_size(unsigned sz) { SASSERT(sz <= m_size); m_size = sz; }
void update_literal(literal l) { m_lit = l; }
bool was_removed() const { return m_removed; }
void set_removed() { m_removed = true; }
void nullify_literal() { m_lit = sat::null_literal; }
unsigned glue() const { return m_glue; }
void set_glue(unsigned g) { m_glue = g; }
unsigned psm() const { return m_psm; }
void set_psm(unsigned p) { m_psm = p; }
void set_learned(bool f) { m_learned = f; }
bool learned() const { return m_learned; }
bool is_watched() const { return m_watch == m_lit && m_lit != sat::null_literal; }
void set_watch() { m_watch = m_lit; }
void reset_watch() { m_watch = sat::null_literal; }
bool is_clear() const { return m_watch == sat::null_literal && m_lit != sat::null_literal; }
bool is_pure() const { return m_pure; }
void set_pure() { m_pure = true; }
unsigned fold_max_var(unsigned w) const;
size_t obj_size() const { return m_obj_size; }
card& to_card();
pbc& to_pb();
card const& to_card() const;
pbc const& to_pb() const;
bool is_card() const { return m_tag == tag_t::card_t; }
bool is_pb() const { return m_tag == tag_t::pb_t; }
bool is_watched(solver_interface const& s, literal lit) const;
void unwatch_literal(solver_interface& s, literal lit);
void nullify_tracking_literal(solver_interface& s);
void watch_literal(solver_interface& s, literal lit);
virtual void clear_watch(solver_interface& s) = 0;
virtual bool init_watch(solver_interface& s) = 0;
virtual lbool eval(sat::model const& m) const = 0;
virtual lbool eval(solver_interface const& s) const = 0;
virtual bool is_blocked(sat::simplifier& s, literal lit) const = 0;
virtual bool validate_unit_propagation(solver_interface const& s, literal alit) const = 0;
virtual bool is_watching(literal l) const { UNREACHABLE(); return false; };
virtual literal_vector literals() const { UNREACHABLE(); return literal_vector(); }
virtual void swap(unsigned i, unsigned j) noexcept { UNREACHABLE(); }
virtual literal get_lit(unsigned i) const { UNREACHABLE(); return sat::null_literal; }
virtual void set_lit(unsigned i, literal l) { UNREACHABLE(); }
virtual void negate() { UNREACHABLE(); }
virtual bool is_extended_binary(literal_vector& r) const { return false; }
virtual double get_reward(solver_interface const& s, sat::literal_occs_fun& occs) const { return 0; }
virtual std::ostream& display(std::ostream& out) const = 0;
virtual std::ostream& display(std::ostream& out, solver_interface const& s, bool values) const = 0;
virtual void init_use_list(sat::ext_use_list& ul) const = 0;
virtual void set_k(unsigned k) { VERIFY(k < 4000000000); m_k = k; }
virtual unsigned get_coeff(unsigned i) const { UNREACHABLE(); return 0; }
unsigned k() const { return m_k; }
bool well_formed() const;
class iterator {
constraint const& c;
unsigned idx;
public:
iterator(constraint const& c, unsigned idx) : c(c), idx(idx) {}
literal operator*() { return c.get_lit(idx); }
iterator& operator++() { ++idx; return *this; }
bool operator==(iterator const& other) const { SASSERT(&c == &other.c); return idx == other.idx; }
bool operator!=(iterator const& other) const { SASSERT(&c == &other.c); return idx != other.idx; }
};
class literal_iterator {
constraint const& c;
public:
literal_iterator(constraint const& c):c(c) {}
iterator begin() const { return iterator(c, 0); }
iterator end() const { return iterator(c, c.size()); }
};
};
std::ostream& operator<<(std::ostream& out, constraint const& c);
}