na

src/sat/smt/polysat/inequality.h

@@ -0,0 +1,164 @@
+/*++
+Copyright (c) 2021 Microsoft Corporation
+
+Module Name:
+
+    Polysat core saturation
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2021-03-19
+    Jakob Rath 2021-04-6
+
+--*/
+#pragma once
+
+#include "sat/smt/polysat/constraints.h"
+
+namespace polysat {
+
+    /// Normalized inequality:
+    ///     lhs <= rhs, if !is_strict
+    ///     lhs < rhs, otherwise
+    class inequality {
+        core& c;
+        constraint_id m_id;
+        pdd m_lhs;
+        pdd m_rhs;
+        signed_constraint m_src;
+        
+        inequality(core& c, constraint_id id, pdd lhs, pdd rhs, signed_constraint src) :
+            c(c), m_id(id), m_lhs(std::move(lhs)), m_rhs(std::move(rhs)), m_src(std::move(src)) {}
+
+        void set(pdd& dst, pdd const& src) const {
+            dst.reset(src.manager());
+            dst = src;
+        }
+        
+    public:
+        static inequality from_ule(core& c, constraint_id id);
+        pdd const& lhs() const { return m_lhs; }
+        pdd const& rhs() const { return m_rhs; }
+        bool is_strict() const { return m_src.is_negative(); }
+        constraint_id id() const { return m_id; }
+        signed_constraint as_signed_constraint() const { return m_src; }
+        operator signed_constraint() const { return m_src; }
+
+        // c := lhs ~ v
+        //  where ~ is < or <=
+        bool is_l_v(pvar v) const { return rhs() == c.var(v); }
+
+        // c := v ~ rhs
+        bool is_g_v(pvar v) const { return lhs() == c.var(v); }
+
+        // c := x ~ Y
+        bool is_x_l_Y(pvar x, pdd& y) const { return is_g_v(x) && (set(y, rhs()), true); }
+ 
+        // c := Y ~ x
+        bool is_Y_l_x(pvar x, pdd& y) const { return is_l_v(x) && (set(y, lhs()), true); }
+
+        // c := Y ~ Ax
+        bool is_Y_l_Ax(pvar x, pdd& a, pdd& y) const { return is_xY(x, rhs(), a) && (set(y, lhs()), true); }
+        bool verify_Y_l_Ax(pvar x, pdd const& a, pdd const& y) const { return lhs() == y && rhs() == a * c.var(x); }
+
+        // c := X*y ~ X*Z
+        bool is_Xy_l_XZ(pvar y, pdd& x, pdd& z) const { return is_xY(y, lhs(), x) && (false); }
+        bool verify_Xy_l_XZ(pvar y, pdd const& x, pdd const& z) const { lhs() == c.var(y) * x && rhs() == z * x; }
+
+        // c := Ax ~ Y
+        bool is_Ax_l_Y(pvar x,  pdd& a, pdd& y) const;
+        bool verify_Ax_l_Y(pvar x, pdd const& a, pdd const& y) const;
+
+        // c := Ax + B ~ Y
+        bool is_AxB_l_Y(pvar x, pdd& a, pdd& b, pdd& y) const {
+            return lhs().degree(x) == 1 && (set(y, rhs()), lhs().factor(x, 1, a, b), true);
+        }
+        bool verify_AxB_l_Y(pvar x, pdd const& a, pdd const& b, pdd const& y) const { return rhs() == y && lhs() == a * c.var(x) + b; }
+
+        // c := Y ~ Ax + B
+        bool is_Y_l_AxB(pvar x, pdd& y, pdd& a, pdd& b) const { return rhs().degree(x) == 1 && (set(y, lhs()), rhs().factor(x, 1, a, b), true); }
+        bool verify_Y_l_AxB(pvar x,  pdd const& y, pdd const& a, pdd& b) const;
+
+        // c := Ax + B ~ Y, val(Y) = 0
+        bool is_AxB_eq_0(pvar x, pdd& a, pdd& b, pdd& y) const;
+        bool verify_AxB_eq_0(pvar x, pdd const& a, pdd const& b, pdd const& y) const;
+
+        // c := Ax + B != Y, val(Y) = 0
+        bool is_AxB_diseq_0(pvar x, pdd& a, pdd& b, pdd& y) const;
+
+        // c := Y*X ~ z*X
+        bool is_YX_l_zX(pvar z, pdd& x, pdd& y) const;
+        bool verify_YX_l_zX(pvar z, pdd const& x, pdd const& y) const;
+
+        // c := xY <= xZ
+        bool is_xY_l_xZ(pvar x, pdd& y, pdd& z) const;
+
+        /**
+         * Match xy = x * Y
+        */
+        static bool is_xY(pvar x, pdd const& xy, pdd& y) { return xy.degree(x) == 1 && xy.factor(x, 1, y); }
+
+        /**
+         * Rewrite to one of six equivalent forms:
+         *
+         *      i=0     p <= q                  (unchanged)
+         *      i=1     p <= p - q - 1
+         *      i=2     q - p <= q
+         *      i=3     q - p <= -p - 1
+         *      i=4     -q - 1 <= -p - 1
+         *      i=5     -q - 1 <= p - q - 1
+         */
+        //inequality rewrite_equiv(int i) const;
+
+        //std::ostream& display(std::ostream& out) const;
+    };
+
+
+    struct bilinear {
+        rational a, b, c, d;
+
+        rational eval(rational const& x, rational const& y) const {
+            return a*x*y + b*x + c*y + d;
+        }
+
+        bilinear operator-() const {
+            bilinear r(*this);
+            r.a = -r.a;
+            r.b = -r.b;
+            r.c = -r.c;
+            r.d = -r.d;
+            return r;
+        }
+
+        bilinear operator-(bilinear const& other) const {
+            bilinear r(*this);
+            r.a -= other.a;
+            r.b -= other.b;
+            r.c -= other.c;
+            r.d -= other.d;
+            return r;
+        }
+
+        bilinear operator+(rational const& d) const {
+            bilinear r(*this);
+            r.d += d;
+            return r;
+        }
+        
+        bilinear operator-(rational const& d) const {
+            bilinear r(*this);
+            r.d -= d;
+            return r;
+        }
+
+        bilinear operator-(int d) const {
+            bilinear r(*this);
+            r.d -= d;
+            return r;
+        }
+};
+
+    inline std::ostream& operator<<(std::ostream& out, bilinear const& b) {
+        return out << b.a << "*x*y + " << b.b << "*x + " << b.c << "*y + " << b.d;
+    }
+}