python-sat 1.8.dev13__tar.gz → 1.8.dev15__tar.gz

{python-sat-1.8.dev13/python_sat.egg-info → python-sat-1.8.dev15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev13
+Version: 1.8.dev15
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/README.rst

@@ -348,6 +348,16 @@ publication, please, acknowledge that fact by citing PySAT:
       doi       = {10.1007/978-3-319-94144-8_26}
     }
 
+    @inproceedings{itk-sat24,
+      author    = {Alexey Ignatiev and Zi Li Tan and Christos Karamanos},
+      title     = {Towards Universally Accessible {SAT} Technology},
+      booktitle = {SAT},
+      pages     = {4:1--4:11},
+      year      = {2024},
+      url       = {https://doi.org/10.4230/LIPIcs.SAT.2024.16},
+      doi       = {10.4230/LIPICS.SAT.2024.16},
+    }
+
 To-Do
 -----
 

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/allies/approxmc.py

@@ -47,17 +47,17 @@
     The interface gives access to :class:`Counter`, which expects a formula in
     :class:`.CNF` as input. Given a few additional (optional) arguments,
     including a random seed, *tolerance factor* :math:`\\varepsilon`, and
-    *confidence* :math:`\delta`, the class can be used to get an approximate
+    *confidence* :math:`\\delta`, the class can be used to get an approximate
     number of models of the formula, subject to the given tolerance factor and
     confidence parameter.
 
-    Namely, given a CNF formula :math:`\mathcal{F}` with :math:`\#\mathcal{F}`
-    as the exact number of models, and parameters :math:`\\varepsilon\in(0,1]`
-    and :math:`\delta\in[0,1)`, the counter computes and reports a value
-    :math:`C`, which is an approximate number of models of
-    :math:`\mathcal{F}`, such that
-    :math:`\\textrm{Pr}\left[\\frac{1}{1+\\varepsilon}\#\mathcal{F}\leq C\leq
-    (1+\\varepsilon)\#\mathcal{F}\\right]\geq 1-\delta`.
+    Namely, given a CNF formula :math:`\\mathcal{F}` with
+    :math:`\\#\\mathcal{F}` as the exact number of models, and parameters
+    :math:`\\varepsilon\\in(0,1]` and :math:`\\delta\\in[0,1)`, the counter
+    computes and reports a value :math:`C`, which is an approximate number of
+    models of :math:`\\mathcal{F}`, such that
+    :math:`\\textrm{Pr}\\left[\\frac{1}{1+\\varepsilon}\\#\\mathcal{F}\\leq
+    C\\leq (1+\\varepsilon)\\#\\mathcal{F}\\right]\\geq 1-\\delta`.
 
     The implementation can be used as an executable (the list of available
     command-line options can be shown using ``approxmc.py -h``) in the
@@ -131,13 +131,13 @@ class Counter(object):
         models of the formula, subject to *tolerance factor* ``epsilon`` and
         *confidence parameter* ``delta``.
 
-        Namely, given a CNF formula :math:`\mathcal{F}` and parameters
-        :math:`\\varepsilon\in(0,1]` and :math:`\delta\in[0,1)`, the counter
-        computes and reports a value :math:`C` such that
-        :math:`\\textrm{Pr}\left[\\frac{1}{1+\\varepsilon}\#\mathcal{F}\leq
-        C\leq (1+\\varepsilon)\#\mathcal{F}\\right]\geq 1-\delta`. Here,
-        :math:`\#\mathcal{F}` denotes the exact model count for formula
-        :math:`\mathcal{F}`.
+        Namely, given a CNF formula :math:`\\mathcal{F}` and parameters
+        :math:`\\varepsilon\\in(0,1]` and :math:`\\delta\\in[0,1)`, the
+        counter computes and reports a value :math:`C` such that
+        :math:`\\textrm{Pr}\\left[\\frac{1}{1+\\varepsilon}\\#\\mathcal{F}\\leq
+        C\\leq (1+\\varepsilon)\\#\\mathcal{F}\\right]\\geq 1-\\delta`. Here,
+        :math:`\\#\\mathcal{F}` denotes the exact model count for formula
+        :math:`\\mathcal{F}`.
 
         The ``formula`` argument can be left unspecified at this stage. In
         this case, a user is expected to add all the relevant clauses using
@@ -241,7 +241,7 @@ class Counter(object):
             of :class:`Counter` or through a series of calls to
             :meth:`add_clause`, this method runs the ApproxMC counter with the
             specified values of tolerance :math:`\\varepsilon` and confidence
-            :math:`\delta` parameters, as well as the random ``seed`` value,
+            :math:`\\delta` parameters, as well as the random ``seed`` value,
             and returns the number of models estimated.
 
             A user may specify an argument ``projection``, which is a list of

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/allies/unigen.py

@@ -50,20 +50,21 @@
     The interface gives access to :class:`Sampler`, which expects a formula in
     :class:`.CNF` as input. Given a few additional (optional) arguments,
     including a random seed, *tolerance factor* :math:`\\varepsilon`,
-    *confidence* :math:`\delta` (to be used by ApproxMC), and *uniformity
-    parameter* :math:`\kappa`, the class can be used to get apply
+    *confidence* :math:`\\delta` (to be used by ApproxMC), and *uniformity
+    parameter* :math:`\\kappa`, the class can be used to get apply
     almost-uniform sampling and to obtain a requested number of samples as a
     result, subject to the given tolerance factor and confidence parameter.
 
-    Namely, given a CNF formula :math:`\mathcal{F}` with the set of satisfying
-    assignments (or models) denoted by :math:`sol(\mathcal{F})` and parameter
-    :math:`\\varepsilon\in(0,1]`, a uniform sampler outputs a model
-    :math:`y\in sol(\mathcal{F})` such that :math:`\\textrm{Pr}\left[y
-    \\textrm{ is output}\\right]=\\frac{1}{|sol(\mathcal{F})|}`.
-    Almost-uniform sampling relaxes the uniformity guarantee and ensures that
-    :math:`\\frac{1}{(1+\\varepsilon)|sol(\mathcal{F})|} \leq
-    \\textrm{Pr}\left[y \\textrm{ is output}\\right] \leq
-    \\frac{1+\\varepsilon}{|sol(\mathcal{F})|}`.
+    Namely, given a CNF formula :math:`\\mathcal{F}` with the set of
+    satisfying assignments (or models) denoted by :math:`sol(\\mathcal{F})`
+    and parameter :math:`\\varepsilon\\in(0,1]`, a uniform sampler outputs a
+    model :math:`y\\in sol(\\mathcal{F})` such that
+    :math:`\\textrm{Pr}\\left[y \\textrm{ is
+    output}\\right]=\\frac{1}{|sol(\\mathcal{F})|}`. Almost-uniform sampling
+    relaxes the uniformity guarantee and ensures that
+    :math:`\\frac{1}{(1+\\varepsilon)|sol(\\mathcal{F})|} \\leq
+    \\textrm{Pr}\\left[y \\textrm{ is output}\\right] \\leq
+    \\frac{1+\\varepsilon}{|sol(\\mathcal{F})|}`.
 
     The implementation can be used as an executable (the list of available
     command-line options can be shown using ``unigen.py -h``) in the
@@ -240,7 +241,7 @@ class Sampler(object):
             of :class:`Sampler` or through a series of calls to
             :meth:`add_clause`, this method runs the UniGen3 sampler with the
             specified values of tolerance :math:`\\varepsilon`, confidence
-            :math:`\delta` parameters, and uniformity parameter :math:`kappa`
+            :math:`\\delta` parameters, and uniformity parameter :math:`kappa`
             as well as the random ``seed`` value, and outputs a requested
             number of samples.
 

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/examples/fm.py

@@ -386,12 +386,12 @@ class FM(object):
 
             Otherwise (if the core contains more than one clause), every clause
             :math:`c` of the core is *relaxed*. This means a new *relaxation
-            literal* is added to the clause, i.e. :math:`c\gets c\\vee r`,
+            literal* is added to the clause, i.e. :math:`c\\gets c\\vee r`,
             where :math:`r` is a fresh (unused) relaxation variable. After the
             clauses get relaxed, a new cardinality encoding is added to the
             formula enforcing the sum of the new relaxation variables to be not
-            greater than 1, :math:`\sum_{c\in\phi}{r\leq 1}`, where
-            :math:`\phi` denotes the unsatisfiable core.
+            greater than 1, :math:`\\sum_{c\\in\\phi}{r\\leq 1}`, where
+            :math:`\\phi` denotes the unsatisfiable core.
         """
 
         if len(self.core) > 1:

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/examples/genhard.py

@@ -129,7 +129,7 @@ class PHP(CNF, object):
     """
         Generator of :math:`k` pigeonhole principle (:math:`k`-PHP) formulas.
         Given integer parameters :math:`m` and :math:`k`, the :math:`k`
-        pigeonhole principle states that if :math:`k\cdot m+1` pigeons are
+        pigeonhole principle states that if :math:`k\\cdot m+1` pigeons are
         distributes by :math:`m` holes, then at least one hole contains more
         than :math:`k` pigeons.
 
@@ -139,9 +139,9 @@ class PHP(CNF, object):
 
         Assume that a Boolean variable :math:`x_{ij}` encodes that pigeon
         :math:`i` resides in hole :math:`j`. Then a PHP formula can be seen as
-        a conjunction: :math:`\\bigwedge_{i=1}^{k\cdot
-        m+1}{\\textsf{AtLeast1}(x_{i1},\ldots,x_{im})}\wedge
-        \\bigwedge_{j=1}^{m}{\\textsf{AtMost}k(x_{1j},\ldots,x_{k\cdot
+        a conjunction: :math:`\\bigwedge_{i=1}^{k\\cdot
+        m+1}{\\textsf{AtLeast1}(x_{i1},\\ldots,x_{im})}\\wedge
+        \\bigwedge_{j=1}^{m}{\\textsf{AtMost}k(x_{1j},\\ldots,x_{k\\cdot
         m+1,j})}`. Here each :math:`\\textsf{AtLeast1}` constraint forces every
         pigeon to be placed into at least one hole while each
         :math:`\\textsf{AtMost}k` constraint allows the corresponding hole to
@@ -204,16 +204,17 @@ class GT(CNF, object):
     """
         Generator of ordering (or *greater than*, GT) principle formulas. Given
         an integer parameter :math:`n`, the principle states that any partial
-        order on the set :math:`\{1,2,\ldots,n\}` must have a maximal element.
-
-        Assume variable :math:`x_{ij}`, for :math:`i,j\in[n],i\\neq j`, denotes
-        the fact that :math:`i \succ j`. Clauses :math:`(\\neg{x_{ij}} \\vee
-        \\neg{x_{ji}})` and :math:`(\\neg{x_{ij}} \\vee \\neg{x_{jk}} \\vee
-        x_{ik})` ensure that the relation :math:`\succ` is anti-symmetric and
-        transitive. As a result, :math:`\succ` is a partial order on
-        :math:`[n]`. The additional requirement that each element :math:`i` has
-        a successor in :math:`[n]\setminus\{i\}` represented a clause
-        :math:`(\\vee_{j \\neq i}{x_{ji}})` makes the formula unsatisfiable.
+        order on the set :math:`\\{1,2,\\ldots,n\\}` must have a maximal element.
+
+        Assume variable :math:`x_{ij}`, for :math:`i,j\\in[n],i\\neq j`,
+        denotes the fact that :math:`i \\succ j`. Clauses
+        :math:`(\\neg{x_{ij}} \\vee \\neg{x_{ji}})` and :math:`(\\neg{x_{ij}}
+        \\vee \\neg{x_{jk}} \\vee x_{ik})` ensure that the relation
+        :math:`\\succ` is anti-symmetric and transitive. As a result,
+        :math:`\\succ` is a partial order on :math:`[n]`. The additional
+        requirement that each element :math:`i` has a successor in
+        :math:`[n]\\setminus\\{i\\}` represented a clause :math:`(\\vee_{j
+        \\neq i}{x_{ji}})` makes the formula unsatisfiable.
 
         GT formulas were originally conjectured [2]_ to be hard for resolution.
         However, [5]_ proved the existence of a polynomial size resolution
@@ -276,18 +277,18 @@ class CB(CNF, object):
     """
         Mutilated chessboard principle (CB). Given an integer :math:`n`, the
         principle states that it is impossible to cover a chessboard of size
-        :math:`2n\cdot 2n` by domino tiles if two diagonally opposite corners
+        :math:`2n\\cdot 2n` by domino tiles if two diagonally opposite corners
         of the chessboard are removed.
 
         Note that the chessboard has :math:`4n^2-2` cells. Introduce a Boolean
-        variable :math:`x_{ij}` for :math:`i,j\in[4n^2-2]` s.t. cells :math:`i`
-        and :math:`j` are adjacent (no variables are introduced for pairs of
-        non-adjacent cells). CB formulas comprise clauses (1)
+        variable :math:`x_{ij}` for :math:`i,j\\in[4n^2-2]` s.t. cells
+        :math:`i` and :math:`j` are adjacent (no variables are introduced for
+        pairs of non-adjacent cells). CB formulas comprise clauses (1)
         :math:`(\\neg{x_{ji} \\vee \\neg{x_{ki}}})` for every :math:`i,j \\neq
         k` meaning that no more than one adjacent cell can be paired with the
-        current one; and (2) :math:`(\\vee_{j \in \\text{Adj}(i)} {x_{ij}})\,\,
-        \\forall i` enforcing that every cell :math:`i` should be paired with
-        at least one adjacent cell.
+        current one; and (2) :math:`(\\vee_{j \\in \\text{Adj}(i)}
+        {x_{ij}})\\,\\, \\forall i` enforcing that every cell :math:`i` should
+        be paired with at least one adjacent cell.
 
         Clearly, since the two diagonal corners are removed, the formula is
         unsatisfiable. Also note the following. Assuming that the number of
@@ -389,8 +390,8 @@ class PAR(CNF, object):
         variables :math:`x_{ij},i \\neq j`. If variable :math:`x_{ij}` is
         *true*, then there is an edge between nodes :math:`i` and :math:`j`.
         The formula consists of the following clauses: :math:`(\\vee_{j \\neq
-        i}{x_{ij}})` for every :math:`i\in[2n+1]`, and :math:`(\\neg{x_{ij}}
-        \\vee \\neg{x_{kj}})` for all distinct :math:`i,j,k \in [2n+1]`.
+        i}{x_{ij}})` for every :math:`i\\in[2n+1]`, and :math:`(\\neg{x_{ij}}
+        \\vee \\neg{x_{kj}})` for all distinct :math:`i,j,k \\in [2n+1]`.
 
         The parity principle is known to be hard for resolution [4]_.
 

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/examples/hitman.py

@@ -35,14 +35,14 @@
     by size) subset-minimal hitting enumeration.
 
     The minimal hitting set problem is trivially formulated as a MaxSAT formula
-    in WCNF, as follows. Assume :math:`E=\{e_1,\ldots,e_n\}` to be a universe
+    in WCNF, as follows. Assume :math:`E=\\{e_1,\\ldots,e_n\\}` to be a universe
     of elements. Also assume there are :math:`k` sets to hit:
-    :math:`s_i=\{e_{i,1},\ldots,e_{i,j_i}\}` s.t. :math:`e_{i,l}\in E`. Every
-    set :math:`s_i=\{e_{i,1},\ldots,e_{i,j_i}\}` is translated into a hard
-    clause :math:`(e_{i,1} \\vee \ldots \\vee e_{i,j_i})`. This results in the
+    :math:`s_i=\\{e_{i,1},\\ldots,e_{i,j_i}\\}` s.t. :math:`e_{i,l}\\in E`. Every
+    set :math:`s_i=\\{e_{i,1},\\ldots,e_{i,j_i}\\}` is translated into a hard
+    clause :math:`(e_{i,1} \\vee \\ldots \\vee e_{i,j_i})`. This results in the
     set of hard clauses having size :math:`k`. The set of soft clauses
     comprises unit clauses of the form :math:`(\\neg{e_{j}})` s.t.
-    :math:`e_{j}\in E`, each having weight 1.
+    :math:`e_{j}\\in E`, each having weight 1.
 
     Taking into account this problem formulation as MaxSAT, ordered hitting
     enumeration is done with the use of the state-of-the-art MaxSAT solver

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/examples/musx.py

@@ -227,7 +227,7 @@ class MUSX(object):
 
             Soft clauses are (de)activated using the standard MiniSat-like
             assumptions interface [2]_. Each soft clause :math:`c` is augmented
-            with a selector literal :math:`s`, e.g. :math:`(c) \gets (c \\vee
+            with a selector literal :math:`s`, e.g. :math:`(c) \\gets (c \\vee
             \\neg{s})`. As a result, clause :math:`c` can be activated by
             assuming literal :math:`s`. The over-approximation provided as an
             input is specified as a list of selector literals for clauses in

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/examples/rc2.py

@@ -695,8 +695,8 @@ class RC2(object):
         """
             Detect and adapt intrinsic AtMost1 constraints. Assume
             there is a subset of soft clauses
-            :math:`\\mathcal{S}'\subseteq \\mathcal{S}` s.t.
-            :math:`\sum_{c\in\\mathcal{S}'}{c\leq 1}`, i.e. at most
+            :math:`\\mathcal{S}'\\subseteq \\mathcal{S}` s.t.
+            :math:`\\sum_{c\\in\\mathcal{S}'}{c\\leq 1}`, i.e. at most
             one of the clauses of :math:`\\mathcal{S}'` can be
             satisfied.
 
@@ -709,7 +709,7 @@ class RC2(object):
             unit-propagated to be false. Note that this method for
             detection of AtMost1 constraints is *incomplete*, because
             in general unit propagation does not suffice to test
-            whether or not :math:`\\mathcal{F}\wedge l_i\\models
+            whether or not :math:`\\mathcal{F}\\wedge l_i\\models
             \\neg{l_j}`.
 
             Each intrinsic AtMost1 constraint detected this way is
@@ -796,7 +796,7 @@ class RC2(object):
             has cost at least :math:`|\\mathcal{S}'|-1` (assuming
             *unweighted* MaxSAT). Furthermore, it is safe to replace
             all clauses of :math:`\\mathcal{S}'` with a single soft
-            clause :math:`\sum_{c\in\\mathcal{S}'}{c}`.
+            clause :math:`\\sum_{c\\in\\mathcal{S}'}{c}`.
 
             Here, input parameter ``am1`` plays the role of subset
             :math:`\\mathcal{S}'` mentioned above. The procedure bumps
@@ -907,13 +907,13 @@ class RC2(object):
             optimization* in [6]_.
 
             Given a totalizer object ``tobj`` representing a sum of
-            some *relaxation* variables :math:`r\in R` that augment
+            some *relaxation* variables :math:`r\\in R` that augment
             soft clauses :math:`\\mathcal{C}_r`, the idea is to
             increase the right-hand side of the sum (which is equal to
             1 by default) as much as possible, reaching a value
             :math:`k` s.t. formula
-            :math:`\\mathcal{H}\wedge\\mathcal{C}_r\wedge(\sum_{r\in
-            R}{r\leq k})` is still unsatisfiable while increasing it
+            :math:`\\mathcal{H}\\wedge\\mathcal{C}_r\\wedge(\\sum_{r\\in
+            R}{r\\leq k})` is still unsatisfiable while increasing it
             further makes the formula satisfiable (here
             :math:`\\mathcal{H}` denotes the hard part of the
             formula).

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 8, 'dev', 13)
+VERSION = (1, 8, 'dev', 15)
 
 
 # PEP440 Format

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/pysat/card.py

@@ -68,10 +68,10 @@
         pp. 129-134
 
     A cardinality constraint is a constraint of the form:
-    :math:`\sum_{i=1}^n{x_i}\leq k`. Cardinality constraints are ubiquitous in
-    practical problem formulations. Note that the implementation of the
+    :math:`\\sum_{i=1}^n{x_i}\\leq k`. Cardinality constraints are ubiquitous
+    in practical problem formulations. Note that the implementation of the
     pairwise, bitwise, and ladder encodings can only deal with AtMost1
-    constraints, e.g. :math:`\sum_{i=1}^n{x_i}\leq 1`.
+    constraints, e.g. :math:`\\sum_{i=1}^n{x_i}\\leq 1`.
 
     Access to all cardinality encodings can be made through the main class of
     this module, which is :class:`.CardEnc`.
@@ -150,9 +150,9 @@ class EncType(object):
         Note that while most of the encodings are produced as a list of
         clauses, the "native" encoding of `MiniCard
         <https://github.com/liffiton/minicard>`__ is managed as one clause.
-        Given an AtMostK constraint :math:`\sum_{i=1}^n{x_i\leq k}`, the native
-        encoding represents it as a pair ``[lits, k]``, where ``lits`` is a
-        list of size ``n`` containing literals in the sum.
+        Given an AtMostK constraint :math:`\\sum_{i=1}^n{x_i\\leq k}`, the
+        native encoding represents it as a pair ``[lits, k]``, where ``lits``
+        is a list of size ``n`` containing literals in the sum.
     """
 
     pairwise    = 0
@@ -248,8 +248,8 @@ class CardEnc(object):
             encoding=EncType.seqcounter):
         """
             This method can be used for creating a CNF encoding of an AtMostK
-            constraint, i.e. of :math:`\sum_{i=1}^{n}{x_i}\leq k`. The method
-            shares the arguments and the return type with method
+            constraint, i.e. of :math:`\\sum_{i=1}^{n}{x_i}\\leq k`. The
+            method shares the arguments and the return type with method
             :meth:`CardEnc.atleast`. Please, see it for details.
         """
 
@@ -310,9 +310,10 @@ class CardEnc(object):
             encoding=EncType.seqcounter):
         """
             This method can be used for creating a CNF encoding of an AtLeastK
-            constraint, i.e. of :math:`\sum_{i=1}^{n}{x_i}\geq k`. The method
-            takes 1 mandatory argument ``lits`` and 3 default arguments can be
-            specified: ``bound``, ``top_id``, ``vpool``, and ``encoding``.
+            constraint, i.e. of :math:`\\sum_{i=1}^{n}{x_i}\\geq k`. The
+            method takes 1 mandatory argument ``lits`` and 3 default arguments
+            can be specified: ``bound``, ``top_id``, ``vpool``, and
+            ``encoding``.
 
             :param lits: a list of literals in the sum.
             :param bound: the value of bound :math:`k`.
@@ -410,7 +411,7 @@ class CardEnc(object):
             encoding=EncType.seqcounter):
         """
             This method can be used for creating a CNF encoding of an EqualsK
-            constraint, i.e. of :math:`\sum_{i=1}^{n}{x_i}= k`. The method
+            constraint, i.e. of :math:`\\sum_{i=1}^{n}{x_i}= k`. The method
             makes consecutive calls of both :meth:`CardEnc.atleast` and
             :meth:`CardEnc.atmost`. It shares the arguments and the return type
             with method :meth:`CardEnc.atleast`. Please, see it for details.

{python-sat-1.8.dev13 → python-sat-1.8.dev15}/pysat/engines.py

@@ -342,9 +342,9 @@ class LinearConstraint:
 class ParityConstraint:
     """
         A possible implementation of parity constraints. These are constraints
-        of the form :math:`l_1 \oplus l_2 \oplus \ldots \oplus l_n = b` where
-        each :math:`l_i` is a Boolean literal while :math:`b` is a Boolean
-        constant. The class is designed to exemplify the work with
+        of the form :math:`l_1 \\oplus l_2 \\oplus \\ldots \\oplus l_n = b`
+        where each :math:`l_i` is a Boolean literal while :math:`b` is a
+        Boolean constant. The class is designed to exemplify the work with
         :class:`BooleanEngine`.
 
         The implementation is pretty naive. It propagates a last unassigned