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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev13
+Version: 1.8.dev14
 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.dev14}/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.dev14}/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.dev14}/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.dev14}/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.dev14}/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.dev14}/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.dev14}/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.dev14}/pysat/__init__.py

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

{python-sat-1.8.dev13 → python_sat-1.8.dev14}/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.dev14}/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

{python-sat-1.8.dev13 → python_sat-1.8.dev14}/pysat/formula.py

@@ -125,19 +125,19 @@
     additional class for dealing with *partial* and *weighted partial* CNF
     formulas, i.e. WCNF formulas. A WCNF formula is a conjunction of two sets
     of clauses: *hard* clauses and *soft* clauses, i.e.
-    :math:`\mathcal{F}=\mathcal{H}\wedge\mathcal{S}`. Soft clauses of a WCNF
+    :math:`\\mathcal{F}=\\mathcal{H}\\wedge\\mathcal{S}`. Soft clauses of a WCNF
     are labeled with integer *weights*, i.e. a soft clause of
-    :math:`\mathcal{S}` is a pair :math:`(c_i, w_i)`. In partial (unweighted)
+    :math:`\\mathcal{S}` is a pair :math:`(c_i, w_i)`. In partial (unweighted)
     formulas, all soft clauses have weight 1.
 
     WCNF can be of help when solving optimization problems using the SAT
     technology. A typical example of where a WCNF formula can be used is
     `maximum satisfiability (MaxSAT)
     <https://en.wikipedia.org/wiki/Maximum_satisfiability_problem>`__, which
-    given a WCNF formula :math:`\mathcal{F}=\mathcal{H}\wedge\mathcal{S}`
-    targets satisfying all its hard clauses :math:`\mathcal{H}` and maximizing
+    given a WCNF formula :math:`\\mathcal{F}=\\mathcal{H}\\wedge\\mathcal{S}`
+    targets satisfying all its hard clauses :math:`\\mathcal{H}` and maximizing
     the sum of weights of satisfied soft clauses, i.e. maximizing the value of
-    :math:`\sum_{c_i\in\mathcal{S}}{w_i\\cdot c_i}`.
+    :math:`\\sum_{c_i\\in\\mathcal{S}}{w_i\\cdot c_i}`.
 
     An object of class :class:`WCNF` has two variables to access the hard and
     soft clauses of the corresponding formula: ``hard`` and ``soft``. The
@@ -160,7 +160,7 @@
         [1, 3]
 
     A properly constructed WCNF formula must have a *top weight*, which should
-    be equal to :math:`1+\sum_{c_i\in\mathcal{S}}{w_i}`. Top weight of a
+    be equal to :math:`1+\\sum_{c_i\\in\\mathcal{S}}{w_i}`. Top weight of a
     formula can be accessed through variable ``topw``.
 
     .. code-block:: python
@@ -882,10 +882,15 @@ class Formula(object):
 
                 if len(collection) > 1:
                     if _hashable(collection):
-                        items.append((prefix, repr(collection)))
+                        # it is a hashable iterable; it is better to sort it
+                        items.append((prefix, repr(sorted(collection, key=lambda x: hash(x)))))
                     else:
                         for i, item in enumerate(collection):
                             if _hashable(item):
+                                # it is a hashable iterable; it is better to sort it
+                                if isinstance(item, Iterable):
+                                    item = sorted(item, key=lambda x: hash(x))
+
                                 items.append((prefix, repr(item)))
                             elif isinstance(item, Iterable):
                                 items.extend(_flatten(item, prefix=prefix))
@@ -900,6 +905,10 @@ class Formula(object):
                     value = collection[key]
                     new_key = prefix + sep + key if prefix else key
                     if value and _hashable(value):
+                        # it is a hashable iterable; it is better to sort it
+                        if isinstance(value, Iterable):
+                            value = sorted(value, key=lambda x: hash(x))
+
                         items.append((new_key, repr(value)))
                     elif isinstance(value, Iterable):
                         if value:
@@ -1450,9 +1459,9 @@ Formula.set_context('default')
 class And(Formula):
     """
         Conjunction. Given a list of operands (subformulas) :math:`f_i`,
-        :math:`i \in \{1,\ldots,n\}, n \in \mathbb{N}`, it creates a formula
-        :math:`\\bigwedge_{i=1}^{n}{f_i}`. The list of operands *of size at
-        least 1* should be passed as arguments to the constructor.
+        :math:`i \\in \\{1,\\ldots,n\\}, n \\in \\mathbb{N}`, it creates a
+        formula :math:`\\bigwedge_{i=1}^{n}{f_i}`. The list of operands *of
+        size at least 1* should be passed as arguments to the constructor.
 
         Example:
 
@@ -1613,7 +1622,7 @@ class And(Formula):
             subformula, thus representing their conjunction.
 
             If ``name_required`` is set to ``True``, the method encodes the
-            conjunction using the standard logic: :math:`x \equiv
+            conjunction using the standard logic: :math:`x \\equiv
             \\bigwedge{y_i}`, if :math:`x` is the new auxiliary variable
             encoding ``self`` and :math:`y_i` is the auxiliary variable
             representing :math:`i`'s subformula.
@@ -1672,9 +1681,9 @@ class And(Formula):
 class Or(Formula):
     """
         Disjunction. Given a list of operands (subformulas) :math:`f_i`,
-        :math:`i \in \{1,\ldots,n\}, n \in \mathbb{N}`, it creates a formula
-        :math:`\\bigvee_{i=1}^{n}{f_i}`. The list of operands *of size at
-        least 1* should be passed as arguments to the constructor.
+        :math:`i \\in \\{1,\\ldots,n\\}, n \\in \\mathbb{N}`, it creates a
+        formula :math:`\\bigvee_{i=1}^{n}{f_i}`. The list of operands *of size
+        at least 1* should be passed as arguments to the constructor.
 
         Example:
 
@@ -1835,7 +1844,7 @@ class Or(Formula):
             subformula, thus representing their conjunction.
 
             If ``name_required`` is set to ``True``, the method encodes the
-            conjunction using the standard logic: :math:`x \equiv
+            conjunction using the standard logic: :math:`x \\equiv
             \\bigvee{y_i}`, if :math:`x` is the new auxiliary variable
             encoding ``self`` and :math:`y_i` is the auxiliary variable
             representing :math:`i`'s subformula.
@@ -2164,11 +2173,11 @@ class Implies(Formula):
             If ``name_required`` is ``False``, the method recursively encodes
             the left and right subformulas giving them names, say, :math:`x`
             and :math:`y` respectively and the populates self's clauses with a
-            single binary clause :math:`(\\neg{x}\lor y)`.
+            single binary clause :math:`(\\neg{x}\\lor y)`.
 
             If ``name_required`` is set to ``True``, the method removes this
             single clause and instead gives a name to the implication by
-            Tseitin-encoding it, i.e. :math:`n \equiv (\\neg{x}\lor y)`.
+            Tseitin-encoding it, i.e. :math:`n \\equiv (\\neg{x}\\lor y)`.
 
             :param name_required: whether or not a Tseitin variable is needed
             :param name_required: bool
@@ -2222,10 +2231,10 @@ class Implies(Formula):
 class Equals(Formula):
     """
         Equivalence. Given a list of operands (subformulas) :math:`f_i`,
-        :math:`i \in \{1,\ldots,n\}, n \in \mathbb{N}`, it creates a formula
-        :math:`f_1 \leftrightarrow f_2 \leftrightarrow\ldots\leftrightarrow
-        f_n`. The list of operands *of size at least 2* should be passed as
-        arguments to the constructor.
+        :math:`i \\in \\{1,\\ldots,n\\}, n \\in \\mathbb{N}`, it creates a
+        formula :math:`f_1 \\leftrightarrow f_2
+        \\leftrightarrow\\ldots\\leftrightarrow f_n`. The list of operands *of
+        size at least 2* should be passed as arguments to the constructor.
 
         Example:
 
@@ -2405,8 +2414,8 @@ class Equals(Formula):
             If ``name_required`` is ``False``, the method recursively encodes
             the subformulas and populates self's clauses with binary clauses
             connecting two consecutive subformulas :math:`f_i` and
-            :math:`f_{i+1}` by introducing two clauses :math:`(\\neg{f_i}\lor
-            f_{i+1})` and :math:`(f_i\lor\\neg{f_i+1})`.
+            :math:`f_{i+1}` by introducing two clauses :math:`(\\neg{f_i}\\lor
+            f_{i+1})` and :math:`(f_i\\lor\\neg{f_i+1})`.
 
             If ``name_required`` is set to ``True``, the method introduces an
             new auxiliary name for the equivalence term and clausifies it by
@@ -2468,10 +2477,10 @@ class Equals(Formula):
 class XOr(Formula):
     """
         Exclusive disjunction. Given a list of operands (subformulas)
-        :math:`f_i`, :math:`i \in \{1,\ldots,n\}, n \in \mathbb{N}`, it
-        creates a formula :math:`f_1 \oplus f_2 \oplus\ldots\oplus f_n`. The
-        list of operands *of size at least 2* should be passed as arguments to
-        the constructor.
+        :math:`f_i`, :math:`i \\in \\{1,\\ldots,n\\}, n \\in \\mathbb{N}`, it
+        creates a formula :math:`f_1 \\oplus f_2 \\oplus\\ldots\\oplus f_n`.
+        The list of operands *of size at least 2* should be passed as
+        arguments to the constructor.
 
         Example:
 
@@ -2747,7 +2756,7 @@ class ITE(Formula):
     """
         If-then-else operator. Given three operands (subformulas) :math:`x`,
         :math:`y`, and :math:`z`, it creates a formula :math:`(x \\rightarrow
-        y) \land (\\neg{x} \\rightarrow z)`. The operands should be passed as
+        y) \\land (\\neg{x} \\rightarrow z)`. The operands should be passed as
         arguments to the constructor.
 
         Example:
@@ -2886,12 +2895,12 @@ class ITE(Formula):
             the ``cond``, ``cons1``, and ``cons2`` subformulas giving them
             names, say, :math:`x`, :math:`y`, and :math:`z`, respectivela, and
             the populates self's clauses with two binary clauses
-            :math:`(\\neg{x}\lor y)` and :math:`(x \lor y)`.
+            :math:`(\\neg{x}\\lor y)` and :math:`(x \\lor y)`.
 
             If ``name_required`` is set to ``True``, the method removes these
             clauses and instead gives a name to the ITE by Tseitin-encoding
-            it, i.e. encoding :math:`n \equiv \left[(\\neg{x}\lor
-            y)\land(x\lor y)\\right]`.
+            it, i.e. encoding :math:`n \\equiv \\left[(\\neg{x}\\lor
+            y)\\land(x\\lor y)\\right]`.
 
             :param name_required: whether or not a Tseitin variable is needed
             :param name_required: bool
@@ -2984,6 +2993,7 @@ class CNF(Formula, object):
 
         self.nv = 0
         self.clauses = []
+        self.encoded = []
         self.comments = []
 
         # this variable is required for integration with Formula
@@ -3574,13 +3584,14 @@ class CNF(Formula, object):
 
     def negate(self, topv=None):
         """
-            Given a CNF formula :math:`\mathcal{F}`, this method creates a CNF
-            formula :math:`\\neg{\mathcal{F}}`. The negation of the formula is
-            encoded to CNF with the use of *auxiliary* Tseitin variables [1]_.
-            A new CNF formula is returned keeping all the newly introduced
-            variables that can be accessed through the ``auxvars`` variable.
-            All the literals used to encode the negation of the original
-            clauses can be accessed through the ``enclits`` variable.
+            Given a CNF formula :math:`\\mathcal{F}`, this method creates a
+            CNF formula :math:`\\neg{\\mathcal{F}}`. The negation of the
+            formula is encoded to CNF with the use of *auxiliary* Tseitin
+            variables [1]_. A new CNF formula is returned keeping all the
+            newly introduced variables that can be accessed through the
+            ``auxvars`` variable. All the literals used to encode the negation
+            of the original clauses can be accessed through the ``enclits``
+            variable.
 
             **Note** that the negation of each clause is encoded with one
             auxiliary variable if it is not unit size. Otherwise, no auxiliary
@@ -4360,11 +4371,11 @@ class CNFPlus(CNF, object):
             3 5 7 0
 
         Each AtLeastK constraint is translated into an AtMostK constraint in
-        the standard way: :math:`\sum_{i=1}^{n}{x_i}\geq k \leftrightarrow
-        \sum_{i=1}^{n}{\\neg{x_i}}\leq (n-k)`. Internally, AtMostK constraints
-        are stored in variable ``atmosts``, each being a pair ``(lits, k)``,
-        where ``lits`` is a list of literals in the sum and ``k`` is the upper
-        bound.
+        the standard way: :math:`\\sum_{i=1}^{n}{x_i}\\geq k \\leftrightarrow
+        \\sum_{i=1}^{n}{\\neg{x_i}}\\leq (n-k)`. Internally, AtMostK
+        constraints are stored in variable ``atmosts``, each being a pair
+        ``(lits, k)``, where ``lits`` is a list of literals in the sum and
+        ``k`` is the upper bound.
 
         Example:
 
@@ -4885,10 +4896,11 @@ class WCNFPlus(WCNF, object):
         i.e. soft cardinality constraints are currently *not supported*.
 
         Each AtLeastK constraint is translated into an AtMostK constraint in
-        the standard way: :math:`\sum_{i=1}^{n}{x_i}\geq k \leftrightarrow
-        \sum_{i=1}^{n}{\\neg{x_i}}\leq (n-k)`. Internally, AtMostK constraints
-        are stored in variable ``atms``, each being a pair ``(lits, k)``, where
-        ``lits`` is a list of literals in the sum and ``k`` is the upper bound.
+        the standard way: :math:`\\sum_{i=1}^{n}{x_i}\\geq k \\leftrightarrow
+        \\sum_{i=1}^{n}{\\neg{x_i}}\\leq (n-k)`. Internally, AtMostK
+        constraints are stored in variable ``atms``, each being a pair
+        ``(lits, k)``, where ``lits`` is a list of literals in the sum and
+        ``k`` is the upper bound.
 
         Example:
 

{python-sat-1.8.dev13 → python_sat-1.8.dev14}/pysat/pb.py

@@ -49,9 +49,9 @@
         Pseudo-Boolean Constraints into CNF*. SAT 2015. pp. 9-16
 
     A *pseudo-Boolean constraint* is a constraint of the form:
-    :math:`\left(\sum_{i=1}^n{a_i\cdot x_i}\\right)\circ k`, where
-    :math:`a_i\in\mathbb{N}`, :math:`x_i\in\{y_i,\\neg{y_i}\}`,
-    :math:`y_i\in\mathbb{B}`, and :math:`\circ\in\{\leq,=,\geq\}`.
+    :math:`\\left(\\sum_{i=1}^n{a_i\\cdot x_i}\\right)\\circ k`, where
+    :math:`a_i\\in\\mathbb{N}`, :math:`x_i\\in\{y_i,\\neg{y_i}\\}`,
+    :math:`y_i\\in\\mathbb{B}`, and :math:`\\circ\\in\\{\\leq,=,\\geq\\}`.
     Pseudo-Boolean constraints arise in a number of important practical
     applications. Thus, several *encodings* of pseudo-Boolean constraints into
     CNF formulas are known [2]_. The list of pseudo-Boolean encodings
@@ -362,8 +362,9 @@ class PBEnc(object):
         """
             This method can be used for creating a CNF encoding of a LEQ
             (weighted AtMostK) constraint, i.e. of
-            :math:`\sum_{i=1}^{n}{a_i\cdot x_i}\leq k`. The resulting set of
-            clauses is returned as an object of class :class:`.formula.CNF`.
+            :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}\\leq k`. The resulting set
+            of clauses is returned as an object of class
+            :class:`.formula.CNF`.
 
             The input list of literals can contain either integers or pairs
             ``(l, w)``, where ``l`` is an integer literal and ``w`` is an
@@ -409,8 +410,8 @@ class PBEnc(object):
         """
             This method can be used for creating a CNF encoding of a GEQ
             (weighted AtLeastK) constraint, i.e. of
-            :math:`\sum_{i=1}^{n}{a_i\cdot x_i}\geq k`. The method shares the
-            arguments and the return type with method :meth:`PBEnc.leq`.
+            :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}\\geq k`. The method shares
+            the arguments and the return type with method :meth:`PBEnc.leq`.
             Please, see it for details.
         """
 
@@ -432,7 +433,7 @@ class PBEnc(object):
             encoding=EncType.best):
         """
             This method can be used for creating a CNF encoding of a weighted
-            EqualsK constraint, i.e. of :math:`\sum_{i=1}^{n}{a_i\cdot x_i}=
+            EqualsK constraint, i.e. of :math:`\\sum_{i=1}^{n}{a_i\\cdot x_i}=
             k`. The method shares the arguments and the return type with
             method :meth:`PBEnc.leq`. Please, see it for details.
         """

{python-sat-1.8.dev13 → python_sat-1.8.dev14}/pysat/solvers.py

@@ -119,12 +119,12 @@
 
     PySAT supports both non-incremental and incremental SAT solving.
     Incrementality can be achieved with the use of the MiniSat-like
-    *assumption-based* interface [2]_. It can be helpful if multiple calls to a
-    SAT solver are needed for the same formula using different sets of
+    *assumption-based* interface [2]_. It can be helpful if multiple calls to
+    a SAT solver are needed for the same formula using different sets of
     "assumptions", e.g. when doing consecutive SAT calls for formula
-    :math:`\mathcal{F}\land (a_{i_1}\land\ldots\land a_{i_1+j_1})` and
-    :math:`\mathcal{F}\land (a_{i_2}\land\ldots\land a_{i_2+j_2})`, where every
-    :math:`a_{l_k}` is an assumption literal.
+    :math:`\\mathcal{F}\\land (a_{i_1}\\land\\ldots\\land a_{i_1+j_1})` and
+    :math:`\\mathcal{F}\\land (a_{i_2}\\land\\ldots\\land a_{i_2+j_2})`, where
+    every :math:`a_{l_k}` is an assumption literal.
 
     There are several advantages of using assumptions: (1) it enables one to
     *keep and reuse* the clauses learnt during previous SAT calls at a later
@@ -404,7 +404,7 @@ class Solver(object):
         """
 
         # checking keyword arguments
-        kwallowed = set(['incr', 'with_proof', 'warm_start'])
+        kwallowed = set(['incr', 'with_proof', 'warm_start', 'native_card'])
         for a in kwargs:
             if a not in kwallowed:
                 raise TypeError('Unexpected keyword argument \'{0}\''.format(a))
@@ -735,7 +735,7 @@ class Solver(object):
             .. code-block:: python
 
                 >>> from pysat.solvers import Solver
-                >>> s = Solver(bootstrap_with=[[-1, 2], [-2, 3])
+                >>> s = Solver(bootstrap_with=[[-1, 2], [-2, 3]])
                 >>> s.solve()
                 True
                 >>> s.solve(assumptions=[1, -3])
@@ -1349,14 +1349,14 @@ class Solver(object):
             **Note that most of the solvers do not support native AtMostK
             constraints**.
 
-            An AtMostK constraint is :math:`\sum_{i=1}^{n}{x_i}\leq k`. A
+            An AtMostK constraint is :math:`\\sum_{i=1}^{n}{x_i}\\leq k`. A
             native AtMostK constraint should be given as a pair ``lits`` and
             ``k``, where ``lits`` is a list of literals in the sum.
 
             Also, besides *unweighted* AtMostK constraints, some solvers (see
             :class:`Cadical195`) support their weighted counterparts, i.e.
-            pseudo-Boolean constraints of the form :math:`\sum_{i=1}^{n}{w_i
-            \cdot x_i}\leq k`. The weights of the literals can be specified
+            pseudo-Boolean constraints of the form :math:`\\sum_{i=1}^{n}{w_i
+            \\cdot x_i}\\leq k`. The weights of the literals can be specified
             using the argument ``weights``.
 
             :param lits: a list of literals

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-sat
-Version: 1.8.dev13
+Version: 1.8.dev14
 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.dev14}/python_sat.egg-info/SOURCES.txt

@@ -85,8 +85,9 @@ tests/test_atmost1.py
 tests/test_atmostk.py
 tests/test_boolengine.py
 tests/test_clausification.py
-tests/test_cnfplus.py
+tests/test_cnf.py
 tests/test_equals1.py
+tests/test_formula_unique.py
 tests/test_process.py
 tests/test_propagate.py
 tests/test_unique_model.py

python-sat-1.8.dev13/tests/test_cnfplus.py → python_sat-1.8.dev14/tests/test_cnf.py

@@ -1,3 +1,4 @@
+import pytest
 from pysat.card import *
 from pysat.formula import CNFPlus
 from pysat.solvers import Solver, SolverNames
@@ -27,7 +28,17 @@ cnf1.append(range(1, 6))  # at least 1
 cnf2 = CardEnc.atmost(lits=range(1, 6), bound=1, encoding=EncType.seqcounter)
 cnf2.append(range(1, 6))  # at least 1
 
+def test_cnf():
+    cnf = CNF()
+    cnf_copy = cnf.copy()
+    # TODO: check actual values of the copy for sanity.
+
 def test_cnfplus():
+    cnfplus = CNFPlus()
+    cnfplus_copy = cnfplus.copy()
+    # TODO: check actual values of the copy for sanity.
+
+def test_cnfplus_solvers():
     # testing cnf1:
     for name in solvers:
         if name not in ('minicard', 'gluecard30', 'gluecard41'):
@@ -59,7 +70,7 @@ def test_cnfplus():
                     pass
             assert i == 5, 'there should be 5 models'
 
-def test_cnf():
+def test_cnf_solvers():
     # testing cnf2
     for name in solvers:
         with Solver(name=name, bootstrap_with=cnf2) as s:

python_sat-1.8.dev14/tests/test_formula_unique.py

@@ -0,0 +1,38 @@
+from pysat.formula import *
+from itertools import permutations
+
+def test_atom_uniqueness():
+    x1, x2 = Atom('x'), Atom('x')  # same atom
+    z = Atom('z')                  # a different atom
+
+    assert x1 is x2, 'Atoms should be the same object'
+    assert x1 is not z, 'Atoms should be different objects'
+
+def test_2and_uniqueness():
+    x1, x2 = Atom('x'), Atom('x')  # same atom
+    y = Atom('y')                  # a different atom
+
+    a = And(x1, y)
+    b = And(y, x1)
+    c = And(x2, y)
+    d = And(y, x2)
+
+    assert id(a) == id(b) == id(c) == id(d), 'All 2-and\'s should be the same object'
+
+def test_3and_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = And(x, y, z)
+
+    for comb in permutations([x, y, z]):
+        assert And(*comb) is a, 'All 3-and\'s should be the same object'
+        assert And(comb) is a, 'All 3-and\'s should be the same object'
+
+def test_3or_uniqueness():
+    x, y, z = Atom('x'), Atom('y'), Atom('z')
+
+    a = Or(x, y, z)
+
+    for comb in permutations([x, y, z]):
+        assert Or(*comb) is a, 'All 3-and\'s should be the same object'
+        assert Or(comb) is a, 'All 3-and\'s should be the same object'