passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/sat/solvers/picosat.py

@@ -0,0 +1,228 @@
+# sage_setup: distribution = sagemath-combinat
+r"""
+PicoSAT Solver
+
+This solver relies on the ``pycosat`` Python bindings to ``PicoSAT``.
+
+The ``pycosat`` package should be installed on your Sage installation.
+
+AUTHORS:
+
+- Thierry Monteil (2018): initial version.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2018 Thierry Monteil <sage!lma.metelu.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from .satsolver import SatSolver
+
+from sage.misc.lazy_import import lazy_import
+from sage.features.sat import Pycosat
+
+lazy_import('pycosat', ['solve'], feature=Pycosat())
+
+
+class PicoSAT(SatSolver):
+    r"""
+    PicoSAT Solver.
+
+    INPUT:
+
+    - ``verbosity`` -- integer between 0 and 2 (default: 0)
+
+    - ``prop_limit`` -- integer (default: 0); the propagation limit
+
+    EXAMPLES::
+
+        sage: from sage.sat.solvers.picosat import PicoSAT
+        sage: solver = PicoSAT()                           # optional - pycosat
+    """
+    def __init__(self, verbosity=0, prop_limit=0):
+        r"""
+        Construct a new PicoSAT instance.
+
+        See the documentation class for the description of inputs.
+
+        EXAMPLES::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+        """
+        self._verbosity = int(verbosity)
+        if prop_limit is None:
+            self._prop_limit = 0
+        else:
+            self._prop_limit = int(prop_limit)
+        self._solve = solve
+        self._nvars = 0
+        self._clauses = []
+
+    def var(self, decision=None):
+        r"""
+        Return a *new* variable.
+
+        INPUT:
+
+        - ``decision`` -- ignored; accepted for compatibility with other solvers
+
+        EXAMPLES::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+            sage: solver.var()                             # optional - pycosat
+            1
+
+            sage: solver.add_clause((-1,2,-4))             # optional - pycosat
+            sage: solver.var()                             # optional - pycosat
+            5
+        """
+        self._nvars += 1
+        return self._nvars
+
+    def nvars(self):
+        r"""
+        Return the number of variables.
+
+        Note that for compatibility with DIMACS convention, the number
+        of variables corresponds to the maximal index of the variables used.
+
+        EXAMPLES::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+            sage: solver.nvars()                           # optional - pycosat
+            0
+
+        If a variable with intermediate index is not used, it is still
+        considered as a variable::
+
+            sage: solver.add_clause((1,-2,4))              # optional - pycosat
+            sage: solver.nvars()                           # optional - pycosat
+            4
+        """
+        return self._nvars
+
+    def add_clause(self, lits):
+        r"""
+        Add a new clause to set of clauses.
+
+        INPUT:
+
+        - ``lits`` -- tuple of nonzero integers
+
+        .. NOTE::
+
+            If any element ``e`` in ``lits`` has ``abs(e)`` greater
+            than the number of variables generated so far, then new
+            variables are created automatically.
+
+        EXAMPLES::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+            sage: solver.add_clause((1, -2 , 3))           # optional - pycosat
+        """
+        if 0 in lits:
+            raise ValueError("0 should not appear in the clause: {}".format(lits))
+        # pycosat does not handle Sage integers
+        lits = [int(i) for i in lits]
+        self._nvars = max(self._nvars, *(abs(i) for i in lits))
+        self._clauses.append(lits)
+
+    def __call__(self, assumptions=None):
+        r"""
+        Solve this instance.
+
+        OUTPUT:
+
+        - If this instance is SAT: A tuple of length ``nvars() + 1``,
+          where the ``i``-th entry holds an assignment for the
+          ``i``-th variables (the ``0``-th entry is always ``None``).
+
+        - If this instance is UNSAT: ``False``.
+
+        EXAMPLES::
+
+            sage: # optional - pycosat
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()
+            sage: solver.add_clause((1,2))
+            sage: solver.add_clause((-1,2))
+            sage: solver.add_clause((-1,-2))
+            sage: solver()
+            (None, False, True)
+
+            sage: solver.add_clause((1,-2))                # optional - pycosat
+            sage: solver()                                 # optional - pycosat
+            False
+        """
+        # import pycosat
+        # self._solve = pycosat.solve
+        sol = self._solve(self._clauses, verbose=self._verbosity,
+                          prop_limit=self._prop_limit, vars=self._nvars)
+        # sol = pycosat.solve(self._clauses)
+        if sol == 'UNSAT':
+            return False
+        else:
+            return (None,) + tuple([s > 0 for s in sol])
+
+    def __repr__(self):
+        r"""
+        TESTS::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+            sage: solver                                   # optional - pycosat
+            PicoSAT solver: 0 variables, 0 clauses.
+        """
+        return "PicoSAT solver: {} variables, {} clauses.".format(self.nvars(), len(self.clauses()))
+
+    def clauses(self, filename=None):
+        r"""
+        Return original clauses.
+
+        INPUT:
+
+        - ``filename`` -- (optional) if given, clauses are written to
+          ``filename`` in DIMACS format
+
+        OUTPUT:
+
+        If ``filename`` is ``None`` then a list of ``lits`` is returned,
+        where ``lits`` is a list of literals.
+
+        If ``filename`` points to a writable file, then the list of original
+        clauses is written to that file in DIMACS format.
+
+        EXAMPLES::
+
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()                       # optional - pycosat
+            sage: solver.add_clause((1,2,3,4,5,6,7,8,-9))  # optional - pycosat
+            sage: solver.clauses()                         # optional - pycosat
+            [[1, 2, 3, 4, 5, 6, 7, 8, -9]]
+
+        DIMACS format output::
+
+            sage: # optional - pycosat
+            sage: from sage.sat.solvers.picosat import PicoSAT
+            sage: solver = PicoSAT()
+            sage: solver.add_clause((1, 2, 4))
+            sage: solver.add_clause((1, 2, -4))
+            sage: fn = tmp_filename()
+            sage: solver.clauses(fn)
+            sage: print(open(fn).read())
+            p cnf 4 2
+            1 2 4 0
+            1 2 -4 0
+            <BLANKLINE>
+        """
+        if filename is None:
+            return self._clauses
+        from sage.sat.solvers.dimacs import DIMACS
+        DIMACS.render_dimacs(self._clauses, filename, self.nvars())

sage/sat/solvers/sat_lp.py

@@ -0,0 +1,156 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.numerical.mip
+r"""
+Solve SAT problems Integer Linear Programming
+
+The class defined here is a :class:`~sage.sat.solvers.satsolver.SatSolver` that
+solves its instance using :class:`MixedIntegerLinearProgram`. Its performance
+can be expected to be slower than when using
+:class:`~sage.sat.solvers.cryptominisat.cryptominisat.CryptoMiniSat`.
+"""
+from .satsolver import SatSolver
+from sage.numerical.mip import MixedIntegerLinearProgram, MIPSolverException
+
+
+class SatLP(SatSolver):
+    def __init__(self, solver=None, verbose=0, *, integrality_tolerance=1e-3):
+        r"""
+        Initialize the instance.
+
+        INPUT:
+
+        - ``solver`` -- (default: ``None``) specify a Mixed Integer Linear Programming
+          (MILP) solver to be used. If set to ``None``, the default one is used. For
+          more information on MILP solvers and which default solver is used, see
+          the method
+          :meth:`solve <sage.numerical.mip.MixedIntegerLinearProgram.solve>`
+          of the class
+          :class:`MixedIntegerLinearProgram <sage.numerical.mip.MixedIntegerLinearProgram>`.
+
+        - ``verbose`` -- integer (default: 0); sets the level of verbosity
+          of the LP solver. Set to 0 by default, which means quiet.
+
+        - ``integrality_tolerance`` -- parameter for use with MILP solvers over an
+          inexact base ring; see :meth:`MixedIntegerLinearProgram.get_values`
+
+        EXAMPLES::
+
+            sage: S=SAT(solver='LP'); S
+            an ILP-based SAT Solver
+        """
+        SatSolver.__init__(self)
+        self._LP = MixedIntegerLinearProgram(solver=solver)
+        self._LP_verbose = verbose
+        self._vars = self._LP.new_variable(binary=True)
+        self._integrality_tolerance = integrality_tolerance
+
+    def var(self):
+        """
+        Return a *new* variable.
+
+        EXAMPLES::
+
+            sage: S=SAT(solver='LP'); S
+            an ILP-based SAT Solver
+            sage: S.var()
+            1
+        """
+        nvars = n = self._LP.number_of_variables()
+        while nvars == self._LP.number_of_variables():
+            n += 1
+            self._vars[n]  # creates the variable if needed
+        return n
+
+    def nvars(self):
+        """
+        Return the number of variables.
+
+        EXAMPLES::
+
+            sage: S=SAT(solver='LP'); S
+            an ILP-based SAT Solver
+            sage: S.var()
+            1
+            sage: S.var()
+            2
+            sage: S.nvars()
+            2
+        """
+        return self._LP.number_of_variables()
+
+    def add_clause(self, lits):
+        """
+        Add a new clause to set of clauses.
+
+        INPUT:
+
+        - ``lits`` -- tuple of nonzero integers
+
+        .. NOTE::
+
+            If any element ``e`` in ``lits`` has ``abs(e)`` greater
+            than the number of variables generated so far, then new
+            variables are created automatically.
+
+        EXAMPLES::
+
+            sage: S=SAT(solver='LP'); S
+            an ILP-based SAT Solver
+            sage: for u,v in graphs.CycleGraph(6).edges(sort=False, labels=False):
+            ....:     u,v = u+1,v+1
+            ....:     S.add_clause((u,v))
+            ....:     S.add_clause((-u,-v))
+        """
+        if 0 in lits:
+            raise ValueError("0 should not appear in the clause: {}".format(lits))
+        p = self._LP
+        p.add_constraint(p.sum(self._vars[x] if x > 0 else 1-self._vars[-x] for x in lits)
+                         >= 1)
+
+    def __call__(self):
+        """
+        Solve this instance.
+
+        OUTPUT:
+
+        - If this instance is SAT: A tuple of length ``nvars()+1``
+          where the ``i``-th entry holds an assignment for the
+          ``i``-th variables (the ``0``-th entry is always ``None``).
+
+        - If this instance is UNSAT: ``False``
+
+        EXAMPLES::
+
+            sage: def is_bipartite_SAT(G):
+            ....:     S=SAT(solver='LP'); S
+            ....:     for u,v in G.edges(sort=False, labels=False):
+            ....:         u,v = u+1,v+1
+            ....:         S.add_clause((u,v))
+            ....:         S.add_clause((-u,-v))
+            ....:     return S
+            sage: S = is_bipartite_SAT(graphs.CycleGraph(6))
+            sage: S() # random
+            [None, True, False, True, False, True, False]
+            sage: True in S()
+            True
+            sage: S = is_bipartite_SAT(graphs.CycleGraph(7))
+            sage: S()
+            False
+        """
+        try:
+            self._LP.solve(log=self._LP_verbose)
+        except MIPSolverException:
+            return False
+
+        b = self._LP.get_values(self._vars, convert=bool, tolerance=self._integrality_tolerance)
+        n = max(b)
+        return [None] + [b.get(i, False) for i in range(1, n + 1)]
+
+    def __repr__(self):
+        """
+        TESTS::
+
+            sage: S=SAT(solver='LP'); S
+            an ILP-based SAT Solver
+        """
+        return "an ILP-based SAT Solver"

sage/sat/solvers/satsolver.pxd

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-combinat
+cdef class SatSolver:
+    pass