python-sat 1.9.dev15__tar.gz → 1.9.dev17__tar.gz

{python_sat-1.9.dev15/python_sat.egg-info → python_sat-1.9.dev17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev15
+Version: 1.9.dev17
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado
@@ -15,8 +15,10 @@ Provides-Extra: approxmc
 Requires-Dist: pyapproxmc>=4.1.8; extra == "approxmc"
 Provides-Extra: cryptosat
 Requires-Dist: pycryptosat>=5.11.18; extra == "cryptosat"
+Provides-Extra: pb
+Requires-Dist: pindakaas>=0.6.1; extra == "pb"
 Provides-Extra: pblib
-Requires-Dist: pypblib>=0.0.3; extra == "pblib"
+Requires-Dist: pindakaas>=0.6.1; extra == "pblib"
 Provides-Extra: unigen
 Requires-Dist: pyunigen>=4.1.20; extra == "unigen"
 Dynamic: author

{python_sat-1.9.dev15 → python_sat-1.9.dev17}/README.rst

@@ -128,18 +128,19 @@ list of cardinality encodings included is the following:
 
 Furthermore, PySAT supports a number of encodings of pseudo-Boolean
 constraints listed below. This is done by exploiting a third-party library
-`PyPBLib <https://pypi.org/project/pypblib/>`__  developed by the `Logic
-Optimization Group <http://ulog.udl.cat/>`__ of the University of Lleida.
-(PyPBLib is a wrapper over the known PBLib library [10]_.)
+`Pindakaas <https://pypi.org/project/pindakaas/>`__ [10]_.
 
 -  binary decision diagrams (BDD) [11]_ [12]_
 -  sequential weight counters [13]_
 -  sorting networks [11]_
 -  adder networks [11]_
--  and binary merge [14]_
+-  binary merge [14]_
+-  the watchdog encoding [15]_
+-  the generalized totalizer [16]_
+-  and the mixed radix encoding [17]_
 
-.. [10] Tobias Philipp, Peter Steinke. *PBLib - A Library for Encoding
-    Pseudo-Boolean Constraints into CNF*. SAT 2015. pp. 9-16
+.. [10] Hendrik Bierlee, Jip J. Dekker. *Pindakaas*. Software.
+    https://doi.org/10.5281/zenodo.10851855
 
 .. [11] Niklas Eén, Niklas Sörensson. *Translating Pseudo-Boolean
     Constraints into SAT*. JSAT. vol. 2(1-4). 2006. pp. 1-26
@@ -156,19 +157,29 @@ Optimization Group <http://ulog.udl.cat/>`__ of the University of Lleida.
     Translation of Pseudo-Boolean Constraints into CNF Such That
     Generalized Arc Consistency Is Maintained*. KI. 2014. pp. 123-134
 
+.. [15] Olivier Bailleux, Yacine Boufkhad, Olivier Roussel. *New Encodings
+    of Pseudo-Boolean Constraints into CNF*. SAT 2009. pp. 181-194
+
+.. [16] Saurabh Joshi, Ruben Martins, Vasco Manquinho. *Generalized Totalizer
+    Encoding for Pseudo-Boolean Constraints*. CP 2015. pp. 200-209
+
+.. [17] Anpeng Zha, Miyuki Koshimura, Hiroshi Fujita. *N-level Modulo-based
+    CNF Encodings of Pseudo-Boolean Constraints for MaxSAT*. Constraints
+    24(2). 2019. pp. 133-161
+
 Finally, PySAT now supports arbitrary Boolean formulas with on-the-fly
-clausification [21]_ and provides (pre-)processing functionality [22]_ by
+clausification [24]_ and provides (pre-)processing functionality [25]_ by
 exposing an interface to CaDiCaL's (version 1.5.3) preprocessor as well as
-external user-defined engines following the IPASIR-UP interface [23]_.
+external user-defined engines following the IPASIR-UP interface [26]_.
 
-.. [21] G. S. Tseitin. *On the complexity of derivations in the propositional
+.. [24] G. S. Tseitin. *On the complexity of derivations in the propositional
    calculus*.  Studies in Mathematics and Mathematical Logic, Part II. pp.
    115–125, 1968
 
-.. [22] Armin Biere, Matti Järvisalo, Benjamin Kiesl. *Preprocessing in SAT
+.. [25] Armin Biere, Matti Järvisalo, Benjamin Kiesl. *Preprocessing in SAT
    Solving*. In *Handbook of Satisfiability - Second Edition*. pp. 391-435
 
-.. [23] Katalin Fazekas, Aina Niemetz, Mathias Preiner, Markus Kirchweger,
+.. [26] Katalin Fazekas, Aina Niemetz, Mathias Preiner, Markus Kirchweger,
    Stefan Szeider, Armin Biere. *IPASIR-UP: User Propagators for CDCL*. SAT.
    2023. pp. 8:1-8:13
 
@@ -234,29 +245,29 @@ PySAT usage is detailed in the `provided examples
 <https://github.com/pysathq/pysat/tree/master/examples>`__. For instance, one
 can find simple PySAT-based implementations of
 
--  Fu&Malik algorithm for MaxSAT [15]_
--  RC2/OLLITI algorithm for MaxSAT [19]_ [20]_
--  CLD-like algorithm for MCS extraction and enumeration [17]_
--  LBX-like algorithm for MCS extraction and enumeration [18]_
--  Deletion-based MUS extraction [16]_
+-  Fu&Malik algorithm for MaxSAT [18]_
+-  RC2/OLLITI algorithm for MaxSAT [22]_ [23]_
+-  CLD-like algorithm for MCS extraction and enumeration [20]_
+-  LBX-like algorithm for MCS extraction and enumeration [21]_
+-  Deletion-based MUS extraction [19]_
 
-.. [15] Zhaohui Fu, Sharad Malik. *On Solving the Partial MAX-SAT Problem*.
+.. [18] Zhaohui Fu, Sharad Malik. *On Solving the Partial MAX-SAT Problem*.
    SAT 2006. pp. 252-265
 
-.. [16] Joao Marques Silva. *Minimal Unsatisfiability: Models, Algorithms and
+.. [19] Joao Marques Silva. *Minimal Unsatisfiability: Models, Algorithms and
    Applications*. ISMVL 2010. pp. 9-14
 
-.. [17] Joao Marques-Silva, Federico Heras, Mikolas Janota, Alessandro Previti,
+.. [20] Joao Marques-Silva, Federico Heras, Mikolas Janota, Alessandro Previti,
    Anton Belov. *On Computing Minimal Correction Subsets*. IJCAI 2013. pp.
    615-622
 
-.. [18] Carlos Mencia, Alessandro Previti, Joao Marques-Silva. *Literal-Based
+.. [21] Carlos Mencia, Alessandro Previti, Joao Marques-Silva. *Literal-Based
    MCS Extraction*. IJCAI 2015. pp. 1973-1979
 
-.. [19] António Morgado, Carmine Dodaro, Joao Marques-Silva. *Core-Guided
+.. [22] António Morgado, Carmine Dodaro, Joao Marques-Silva. *Core-Guided
    MaxSAT with Soft Cardinality Constraints*. CP 2014. pp. 564-573
 
-.. [20] António Morgado, Alexey Ignatiev, Joao Marques-Silva. *MSCG: Robust
+.. [23] António Morgado, Alexey Ignatiev, Joao Marques-Silva. *MSCG: Robust
    Core-Guided MaxSAT Solving. System Description*. JSAT 2015. vol. 9,
    pp. 129-134
 
@@ -313,12 +324,12 @@ using PySAT is to install the latest stable release of the toolkit from `PyPI
 
 ::
 
-    $ pip install python-sat[aiger,approxmc,cryptosat,pblib]
+    $ pip install python-sat[aiger,approxmc,cryptosat,pb]
 
-We encourage you to install the *optional* dependencies `pblib`, `aiger`,
+We encourage you to install the *optional* dependencies `pb`, `aiger`,
 `approxmc`, and `cryptosat` as in the previous command. However, if it cannot
 be done (e.g. if their installation fails), you can install PySAT with the
-functionality of `aiger`, `approxmc`, `cryptosat`, and `pblib` disabled:
+functionality of `aiger`, `approxmc`, `cryptosat`, and `pb` disabled:
 
 ::
 
@@ -334,7 +345,7 @@ following way:
 .. note::
 
     For some shells, e.g. *zsh*, you may need to put the package names into
-    single quotes, i.e. use ``pip install 'python-sat[aiger,approxmc,pblib]'``.
+    single quotes, i.e. use ``pip install 'python-sat[aiger,approxmc,pb]'``.
 
 Alternatively, one can clone `the repository
 <https://github.com/pysathq/pysat>`__ and execute the following command in the

{python_sat-1.9.dev15 → python_sat-1.9.dev17}/examples/rc2.py

@@ -237,6 +237,7 @@ class RC2(object):
         self.bnds = {}  # a mapping from sum assumptions to totalizer bounds
         self.tobj = {}  # a mapping from sum assumptions to totalizer objects
         self.swgt = {}  # a mapping from sum assumptions to their core weights
+        self.filt = []   # contextual assumptions (useless in RC2)
         self.cost = 0
 
         # mappings between internal and external variables
@@ -440,7 +441,7 @@ class RC2(object):
         # introduce new variables if necessary
         cl = list(map(lambda l: self._map_extlit(l), clause if not len(clause) == 2 or not type(clause[0]) in (list, tuple, set) else clause[0]))
 
-        if not weight:
+        if weight is None:
             if not len(clause) == 2 or not type(clause[0]) in (list, tuple, set):
                 # the clause is hard, and so we simply add it to the SAT oracle
                 self.oracle.add_clause(cl)
@@ -464,17 +465,18 @@ class RC2(object):
                 cl.append(-selv)
                 self.oracle.add_clause(cl)
 
-            if selv not in self.wght:
-                # record selector and its weight
-                self.sels.append(selv)
-                self.wght[selv] = weight
-                self.smap[selv] = len(self.sels) - 1
-            else:
-                # selector is not new; increment its weight
-                self.wght[selv] += weight
+            if weight:
+                if selv not in self.wght:
+                    # record selector and its weight
+                    self.sels.append(selv)
+                    self.wght[selv] = weight
+                    self.smap[selv] = len(self.sels) - 1
+                else:
+                    # selector is not new; increment its weight
+                    self.wght[selv] += weight
 
-            self.sall.append(selv)
-            self.sels_set.add(selv)
+                self.sall.append(selv)
+                self.sels_set.add(selv)
 
             return selv
 
@@ -658,6 +660,13 @@ class RC2(object):
             else:
                 done = True
 
+    def active_assumps(self):
+        """
+            Get the assumptions for the main core-guided loop.
+        """
+
+        return self.sels + self.sums
+
     def compute_(self):
         """
             Main core-guided loop, which iteratively calls a SAT
@@ -679,7 +688,7 @@ class RC2(object):
         self.interrupted = False
 
         # main solving loop
-        while not self._call_oracle(assumptions=self.sels + self.sums,
+        while not self._call_oracle(assumptions=self.active_assumps(),
                                     expect_interrupt=self.expect_interrupt):
 
             # even if the call has been interrupted, we
@@ -1055,7 +1064,7 @@ class RC2(object):
         """
 
         # the first case is simpler
-        if self._call_oracle(assumptions=[-tobj.rhs[1]]):
+        if self._call_oracle(assumptions=self.filt + [-tobj.rhs[1]]):
             return 1
         else:
             self.cost += self.minw
@@ -1068,7 +1077,7 @@ class RC2(object):
             # increasing the bound
             self.update_sum(-tobj.rhs[i - 1])
 
-            if self._call_oracle(assumptions=[-tobj.rhs[i]]):
+            if self._call_oracle(assumptions=self.filt + [-tobj.rhs[i]]):
                 # the bound should be equal to i
                 return i
 
@@ -1244,10 +1253,9 @@ class RC2(object):
             # right-hand side is always equal to the number of input literals
             rhs = len(t.lits)
 
-            if b < rhs:
+            if b < rhs and not t.rhs[b]:
                 # creating an additional bound
-                if not t.rhs[b]:
-                    t.rhs[b] = self.pool.id()
+                t.rhs[b] = self.pool.id()
 
                 # a new at-most-b constraint
                 amb = [[-t.rhs[b]] * (rhs - b) + t.lits, rhs]

{python_sat-1.9.dev15 → python_sat-1.9.dev17}/pysat/__init__.py

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

{python_sat-1.9.dev15 → python_sat-1.9.dev17}/pysat/card.py

@@ -195,46 +195,38 @@ class CardEnc(object):
     """
 
     @classmethod
-    def _update_vids(cls, cnf, inp, vpool):
+    def _update_vids(cls, cnf, top, vpool):
         """
-            Update variable ids in the given formula and id pool. The literals
-            serving as the input to the cardinality constraint are not
-            updated.
+            Update the id pool to account for the auxiliary variables of the
+            given formula, i.e. all variables larger than ``top``. If these
+            overlap with the ranges marked as occupied in the pool, they are
+            renumbered to free ids. Variables up to ``top``, e.g. the input
+            literals of the constraint, are not updated.
 
-            :param cnf: a list of literals in the sum.
-            :param inp: the list of input literals
-            :param vpool: the value of bound :math:`k`.
+            :param cnf: the encoding of the constraint
+            :param top: the largest variable id of the input
+            :param vpool: variable pool to update
 
             :type cnf: :class:`.formula.CNFPlus`
-            :type inp: list(int)
+            :type top: int
             :type vpool: :class:`.formula.IDPool`
         """
 
-        top, vmap = max(inp + [vpool.top]), {}  # current top and variable mapping
+        # the pool must not hand out the input ids, nor the rest of an
+        # occupied range that the input ids reach into
+        vpool.top = top
+        while vpool._occupied and vpool._occupied[0][0] <= vpool.top:
+            vpool.top = max(vpool.top, vpool._occupied[0][1])
+            vpool._occupied.pop(0)
 
-        # we are going to use this to check if literals are input
-        inp = set([abs(l) for l in inp])
-
-        # creating a new variable mapping, taking into
-        # account variables marked as "occupied"
-        while top < cnf.nv:
-            top += 1
-
-            # skipping the input literals
-            if top in inp:
-                vmap[top] = top
-                continue
-
-            vpool.top += 1
-
-            while vpool._occupied and vpool.top >= vpool._occupied[0][0]:
-                if vpool.top <= vpool._occupied[0][1] + 1:
-                    vpool.top = vpool._occupied[0][1] + 1
-
-                vpool._occupied.pop(0)
+        if vpool.top == top and not (vpool._occupied and vpool._occupied[0][0] <= cnf.nv):
+            # the auxiliary variables already have free ids
+            vpool.top = max(vpool.top, cnf.nv)
+            return
 
-            # mapping this literal to a free one
-            vmap[top] = vpool.top
+        # mapping each auxiliary variable to a free id,
+        # taking into account variables marked as "occupied"
+        vmap = {var: vpool._next() for var in range(top + 1, cnf.nv + 1)}
 
         # updating the clauses
         for cl in cnf.clauses:
@@ -296,12 +288,7 @@ class CardEnc(object):
 
             # updating vpool if necessary
             if vpool:
-                if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
-                    cls._update_vids(ret, lits, vpool)
-                else:
-                    # here, ret.nv id is assumed to be larger than the top id
-                    vpool.top = ret.nv - 1
-                    vpool._next()
+                cls._update_vids(ret, top_id, vpool)
 
         return ret
 
@@ -397,12 +384,7 @@ class CardEnc(object):
 
             # updating vpool if necessary
             if vpool:
-                if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
-                    cls._update_vids(ret, lits, vpool)
-                else:
-                    # here, ret.nv id is assumed to be larger than the top id
-                    vpool.top = ret.nv - 1
-                    vpool._next()
+                cls._update_vids(ret, top_id, vpool)
 
         return ret
 

{python_sat-1.9.dev15 → python_sat-1.9.dev17}/pysat/integer.py

@@ -228,7 +228,9 @@ import numbers
 from pysat.card import CardEnc, EncType as CardEncType
 from pysat.engines import BooleanEngine
 from pysat.formula import CNF, Formula
-from pysat.pb import PBEnc, EncType as PBEncType
+from pysat.pb import PBEnc, EncType as PBEncType, NoSuchEncodingError, \
+        _pindakaas_db, _pindakaas_cnf
+import pindakaas  # after pysat.pb, which checks that it is installed
 
 
 # importable components
@@ -577,7 +579,8 @@ class Integer:
         """
 
         def is_satisfied(lit):
-            return model[abs(lit) - 1] == lit
+            # a literal beyond the model occurs in no clause, so it is free
+            return abs(lit) <= len(model) and model[abs(lit) - 1] == lit
 
         if self.encoding == 'direct':
             for value in self.domain:
@@ -752,6 +755,45 @@ class Integer:
 
         return wmap, shift
 
+    def _linear_term(self, kind, wmap):
+        """
+            Inverse of :meth:`linearize` for one kind of literal. Given a map
+            from domain values ``v`` to pairs ``(lit, weight)``, where ``lit``
+            is the literal of :math:`x \\geq v` (``kind == 'ge'``) or of
+            :math:`x = v` (``kind == 'eq'``), possibly negated, return
+            ``(coeff, const)`` such that the weighted sum of the literals
+            equals ``coeff * X + const``. Return ``None`` if the map does not
+            have this form.
+
+            :param kind: ``'ge'`` or ``'eq'``
+            :param wmap: literals and their weights by domain value
+            :type kind: str
+            :type wmap: dict
+
+            :rtype: tuple or None
+        """
+
+        if kind == 'ge':
+            # x = lb + sum_k [x >= k] and ub - x = sum_k -[x >= k]
+            signs = {lit > 0 for lit, _ in wmap.values()}
+            wvals = {wght for _, wght in wmap.values()}
+            if len(wmap) != self.ub - self.lb or len(signs) != 1 or len(wvals) != 1:
+                return None
+
+            wght = wvals.pop()
+            return (wght, -wght * self.lb) if signs.pop() else (-wght, wght * self.ub)
+
+        # direct literals, the weights must be affine in the values
+        if any(lit < 0 for lit, _ in wmap.values()):
+            return None
+
+        wvals = [wmap[v][1] if v in wmap else 0 for v in self.domain]
+        coeff = wvals[1] - wvals[0] if len(wvals) > 1 else 0
+        if any(w != wvals[0] + coeff * i for i, w in enumerate(wvals)):
+            return None
+
+        return coeff, wvals[0] - coeff * self.lb
+
     def _add_channeling(self):
         """
             Clauses linking direct and order encodings.
@@ -2142,26 +2184,45 @@ class IntegerEngine(BooleanEngine):
         self._add_clause([s1, s2], selv=selv)
         return selv
 
-    def clausify(self, cardenc=CardEncType.seqcounter, pbenc=PBEncType.best):
+    def clausify(self, cardenc=CardEncType.seqcounter, pbenc=PBEncType.best,
+                 intenc=PBEncType.best):
         """
-            Clausify all constraints and return a CNF encoding. All linear
-            constraints are converted using the user-specified cardinality and
-            pseudo-Boolean encoding. The former are utilized for unweighted
-            constraints, while the latter are utilized for weighted
-            constraints.
+            Clausify all constraints and return a CNF encoding.
+
+            Linear constraints over :class:`Integer` variables are encoded by
+            Pindakaas as *integer* linear constraints, using the encoding
+            ``intenc``. The literals of each :class:`Integer` are passed to
+            Pindakaas as an integer variable, which lets it use integer
+            encodings, e.g. the mixed radix encoding.
+
+            The remaining linear constraints, and all of them if ``intenc``
+            is ``None``, are converted using the user-specified cardinality
+            and pseudo-Boolean encoding. The former are utilized for
+            unweighted constraints, while the latter are utilized for
+            weighted constraints.
 
-            Note that parameters ``cardenc`` and ``pbenc`` default to
-            :attr:`.card.EncType.seqcounter` and
-            :class:`pysat.pb.EncType.best`, respectively.
+            Note that parameters ``cardenc``, ``pbenc`` and ``intenc``
+            default to :attr:`.card.EncType.seqcounter`,
+            :class:`pysat.pb.EncType.best` and
+            :class:`pysat.pb.EncType.best`, respectively. The *native*
+            encodings produce no clauses and raise :class:`ValueError`.
 
             :param cardenc: cardinality encoding for unweighted constraints
             :param pbenc: PB encoding for weighted constraints
+            :param intenc: encoding for integer linear constraints, or ``None``
             :type cardenc: int
             :type pbenc: int
+            :type intenc: int or None
 
             :rtype: :class:`pysat.formula.CNF`
         """
 
+        # native constraints are not clauses, and would be lost
+        if cardenc == CardEncType.native or PBEncType.native in (pbenc, intenc):
+            raise ValueError('Native encodings cannot be clausified')
+        if intenc is not None and intenc not in PBEncType._to_encoder:
+            raise NoSuchEncodingError(intenc)
+
         # we are going to store the resulting formula here
         res = CNF()
 
@@ -2184,8 +2245,19 @@ class IntegerEngine(BooleanEngine):
         # (e.g. reified disjunctions) already cached in the engine
         res.extend(self.clauses)
 
+        # separating integer linear constraints from Boolean ones
+        lcons, iconss = self._lcons, []
+        if intenc is not None:
+            lcons = []
+            for cs in self._lcons:
+                icons = self._integer_terms(cs, vpool)
+                if icons:
+                    iconss.append(icons)
+                else:
+                    lcons.append(cs)
+
         # the main part is to encode all linear constraints
-        for cs in self._lcons:
+        for cs in lcons:
             lits, bound = cs[1][0], cs[1][1]
             weights = {} if len(cs[1]) == 2 else cs[1][2]
 
@@ -2200,13 +2272,11 @@ class IntegerEngine(BooleanEngine):
 
             # we have a common weight wght => cardinality constraint
             if wght is not None:
-                new_bound = bound // wght
-                if isinstance(new_bound, Decimal):
-                    new_bound = int(new_bound)
-                elif isinstance(new_bound, float):
-                    new_bound = int(math.floor(new_bound))
+                if isinstance(bound, Decimal):
+                    # Decimal's // rounds towards zero, not down
+                    new_bound = math.floor(bound / wght)
                 else:
-                    new_bound = int(new_bound)
+                    new_bound = int(math.floor(bound // wght))
 
                 if new_bound < 0:
                     # the bound is negative => constraint is unsatisfiable
@@ -2235,20 +2305,112 @@ class IntegerEngine(BooleanEngine):
             wlist = [int(w) if not isinstance(w, Decimal) else int(w)
                             for w in wlist]
 
+            if bound_int < 0:
+                # the weights are non-negative => unsatisfiable
+                res.append([])
+                continue
+
             enc = PBEnc.atmost(lits=lits, weights=wlist, bound=bound_int,
                                vpool=vpool, encoding=pbenc)
             res.extend(enc.clauses)
 
+        # integer linear constraints go last, as they share one encoding
+        if iconss:
+            res.extend(self._clausify_integer(iconss, vpool, intenc))
+
         return res
 
+    def _integer_terms(self, cs, vpool):
+        """
+            Recover the integer structure of a linear constraint. The
+            literals of each :class:`Integer` recognized by
+            :meth:`Integer._linear_term` become a single integer term.
+            Return a triple ``(terms, rest, bound)``, where ``terms`` is a
+            list of ``(var, kind, coeff)``, ``rest`` is a list of the
+            remaining weighted literals, and the constraint is ``terms +
+            rest <= bound``. Return ``None`` if there are no integer terms or
+            if the numbers are not integers.
+        """
+
+        _, _, bound, lits, weights = self._linear_key(cs)
+
+        if not self._intlike(bound) or not all(self._intlike(weights[l]) for l in lits):
+            return None
+
+        # grouping the literals by their integer variable and kind
+        groups, rest = defaultdict(dict), []
+        for l in lits:
+            obj, wght = vpool.obj(abs(l)), int(weights[l])
+            if isinstance(obj, tuple) and len(obj) == 3 and isinstance(obj[0], Integer):
+                group = groups[obj[0], obj[1]]
+                if obj[2] not in group:
+                    group[obj[2]] = (l, wght)
+                    continue
+
+            # a Boolean literal, or the negation of one already in its group
+            rest.append((l, wght))
+
+        terms, bound = [], int(bound)
+        for (var, kind), wmap in groups.items():
+            term = var._linear_term(kind, wmap)
+            if term is None:
+                rest.extend(wmap.values())
+            else:
+                coeff, const = term
+                if coeff:
+                    terms.append((var, kind, coeff))
+                bound -= const
+
+        return (terms, rest, bound) if terms else None
+
+    def _clausify_integer(self, iconss, vpool, intenc):
+        """
+            Encode integer linear constraints, as returned by
+            :meth:`_integer_terms`, with Pindakaas. Return the list of
+            clauses.
+        """
+
+        encoder, options = PBEncType._to_encoder[intenc]
+        Lit = pindakaas.Lit.from_raw
+
+        # new variables must also avoid literals that are not in the pool
+        top_id = max([vpool.top] + [abs(l) for _, rest, _ in iconss for l, _ in rest])
+        db = _pindakaas_db(top_id)
+        ivars = {}  # integer variables, created lazily
+
+        def ivar(var, kind):
+            if (var, kind) not in ivars:
+                if kind == 'ge':
+                    lits = [var.ge(k) for k in range(var.lb + 1, var.ub + 1)]
+                    make = db.int_var_from_order_literals
+                else:
+                    lits = [var.equals(v) for v in var.domain]
+                    make = db.int_var_from_direct_literals
+                ivars[var, kind] = make(var.domain, [Lit(l) for l in lits])
+            return ivars[var, kind]
+
+        try:
+            for terms, rest, bound in iconss:
+                lhs = 0
+                for var, kind, coeff in terms:
+                    lhs += coeff * ivar(var, kind)
+                for l, w in rest:
+                    lhs += w * Lit(l)
+
+                db.add_encoding(lhs <= bound, encoder, **options)
+        except pindakaas.Unsatisfiable:
+            return [[]]
+
+        return _pindakaas_cnf(db, top_id, vpool=vpool).clauses
+
     @staticmethod
     def _intlike(value):
         """
             Checking if the value can be converted to integer.
         """
 
-        # yes, nothing to do
-        if isinstance(value, numbers.Integral):
+        # yes, nothing to do (plain ints first, as the ABC check is slow)
+        if type(value) is int or isinstance(value, numbers.Integral):
             return True
 
         # yes, it's a convertable decimal