Improving Reduction Techniques in Pseudo-Boolean Conflict Analysis
Abstract
Recent pseudo-Boolean (PB) solvers leverage the cutting planes proof system to perform SAT-style conflict analysis during search. This process learns implied PB constraints, which can prune later parts of the search tree and is crucial to a PB solver’s performance. A key step in PB conflict analysis is the reduction of a reason constraint, which caused a variable propagation that contributed to the conflict. While necessary, reduction generally makes the reason constraint less strong. Consequently, different approaches to reduction have been proposed, broadly categorised as division- or saturation-based, with the aim of preserving the strength of the reason constraint as much as possible.
This paper proposes two novel techniques in each reduction category. We theoretically show how each technique yields reason constraints which are at least as strong as those obtained from existing reduction methods. We then evaluate the empirical effectiveness of the reduction techniques on hard knapsack instances and the most recent PB’24 competition benchmarks.
Keywords and phrases:
Constraint Programming, Pseudo-Boolean Reasoning, Conflict AnalysisCopyright and License:
2012 ACM Subject Classification:
Theory of computation Constraint and logic programmingSupplementary Material:
Dataset (Experimental Results): https://github.com/ML-KULeuven/SAT25_PB_reductions_experiments [19]archived at
swh:1:dir:650c2f9b37926504a59a11a6dbf319620b311dc3
Funding:
This research was partly funded by the European Research Council (ERC) under the EU Horizon 2020 research and innovation programme (Grant No 101002802, CHAT-Opt).Event:
28th International Conference on Theory and Applications of Satisfiability Testing (SAT 2025)Editors:
Jeremias Berg and Jakob NordströmSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Problem setting
Although the Boolean satisfiability (SAT) problem is NP-complete [7], in recent decades conflict-driven clause learning (CDCL) solvers [20, 1] routinely solve problems with up to millions of variables. However, the resolution proof system on which they are based may require exponential solve-time for some problems, such as the pigeonhole problem [14]. For this reason, higher-level proof systems pose a promising alternative, such as the cutting planes proof system [8]. Cutting planes form the underlying proof system of conflict-driven pseudo-Boolean (PB) constraint solvers, where we especially focus on PB constraints that are (weighted) linear inequalities over Boolean variables. The cutting planes proof system generalises the resolution proof system by using such PB constraints instead of clauses, which allow for more powerful reasoning. In theory this means that PB solvers can solve problems like the pigeonhole problem in polynomial time, where CDCL-based solvers would need exponential time. The effectiveness of good PB reasoning has been shown in the most recent PB competition of 2024 [24], where PB solvers such as RoundingSat [12] and its offspring Exact [11] show top performance with their native implementation of the cutting planes proof system. Exact and RoundingSat are not only used as stand-alone solvers, but also as PB oracles in other PB solvers such as Hybrid-CASHWMaxSATDisjCadSP+Exact [22], mixed-bag [17] and IPBHS [16].
However, there still lies a difficulty for PB solvers to use the improved reasoning power of the cutting planes proof system effectively. In CDCL, the resolution of two conflicting clauses can simply be done by taking the union of two conflicting clauses and leaving out the propagated variable. While resolution can be generalised, PB solvers require an additional so-called reduction step to ensure the eventual learned constraint prevents the original conflict [5]. Additionally, the stronger the learned constraint the more pruning it will be able to do, hence the need for reduction techniques that keep the reason constraint as strong as possible. Consequently, various types of reduction have been investigated [12, 18, 21]. In this work we theoretically motivate and investigate four new reduction methods that are at least as strong as existing reduction methods.
Our contributions.
First, we propose two novel variants of division-based reduction, namely Weaken Superfluous (WS) and Anti-Weakening of non-falsifieds (AW). Both exploit the rounding behaviour of the division operation in division-based reduction. We prove how the reduced constraints using these techniques are at least as strong as the ones obtained from using standard division-based reduction. Furthermore, we show how after applying the WS technique, the division operation is equivalent to the Mixed-Integer Rounding (MIR) operation, even though generally MIR dominates division [21]. Secondly, we propose two novel variants of a saturation-based reduction technique known as Multiply and Weaken (MW) [18], which we call Multiply and Weaken Direct (MWD) and Multiply and Weaken Indirect (MWI). These variants hybridize saturation- and division-based reduction by applying the former when favourable, using the latter as fallback. Then, we show that MWD with MWI produces constraints at least as strong as those from MWD alone. Finally, experiments empirically evaluate how the theoretically stronger reduction techniques impact solver performance on crafted and competition PB problems.
The organisation of the paper is as follows. In Section 2 we review the basics of PB solving, starting from CDCL and working our way to the current state-of-the-art division-based reduction method in RoundingSat. In Section 3 and Section 4 we introduce our novel techniques for division- and saturation-based reduction methods respectively. Section 5 contains the results from our experiments. In Section 6 we conclude our finding and discuss future work.
2 Preliminaries
We use notation and terminology from [10]. The term pseudo-Boolean (PB) constraint refers to a - linear inequality. We identify with and with . A literal denotes either a variable or its negation . We assume w.l.o.g. that all constraints are written in normalized form, where literals are over pairwise distinct variables, coefficients are positive integers, and is a positive integer called the degree. For a constraint , denotes its set of literals and denotes the coefficient of literal . A PB constraint with degree is a clause.
The (partial) assignment is an ordered set of literals over pairwise distinct variables. A literal is assigned to true by an assignment if , assigned to false or falsified if , and is unassigned otherwise. We define the slack of a constraint under a partial assignment as:
| (1) |
In other words, the slack measures how far is from falsifying the constraint. Then, we say that falsifies if . A pseudo-Boolean formula is a set of PB constraints. An assignment is a solution to if satisfies all constraints in . A formula is satisfiable if it has a solution.
2.1 Conflict-Driven Pseudo-Boolean Search
Conflict-driven PB solving generalizes the CDCL algorithm for SAT, but uses PB constraints instead of clauses. The state of a PB solver can be represented by a and , where is a set of constraints called the constraint database. Initially, is the input formula and is the empty set .
Given a solver state, the search loop starts with a propagation phase, which checks for any constraint whether it is falsified:
| (2) |
or whether a literal in with coefficient , where has not yet been assigned by , is implied by under :
| (3) |
If condition (3) holds, is falsified by , so is implied by under . For an assignment we write to denote that is the reason for the propagation of , and also use the notation . Each propagation can enable new propagations, continuing the propagation phase until condition (3) does not hold for any constraint in the database or until condition (2) holds for at least one. Note that unlike clauses, a single PB constraint can propagate multiple literals, even at different propagation phases.
If condition (2) holds for some constraint, it is considered a conflict and the constraint is denoted as the conflict constraint. On conflict, the solver enters a conflict analysis phase. During this phase, the solver derives a learned constraint which is a logical consequence of the current set of reason constraints combined with the conflict constraint. Crucially, the learned constraint must propagate a literal at some earlier search depth, hence preventing the current conflict from occurring again. Then, this learned constraint is added to , after which the solver backjumps to a sufficient early search depth.
Alternatively, if no conflict is detected, the solver extends by making a heuristic decision to assign some currently unassigned variable. If is a decision then it has no associated reason constraint, which we denote by .
The PB solver reports unsatisfiability whenever it learns a constraint equivalent to the trivial inconsistency . If propagation does not lead to a conflict and all variables have been assigned, the solver reports that the input formula is satisfiable.
2.2 PB Conflict Analysis
In this subsection we will go into more detail about the conflict analysis phase of PB solvers, where the following operations are used [2, 4]:
- Addition.
-
(4) Where we implicitly assume that the result is rewritten in normalised form.
Example 1.
Addition of the constraint with yields , which normalises to by cancelling literals and , where .
- Division.
-
(5) - Multiplication.
-
(6) - Saturation.
-
(7) - Weakening.
-
(8) Weakening is partial when , and full when .
- Anti-weakening
-
(9)
Using these operations, PB solvers often implement different variants of conflict analysis, [6, 12, 3, 11]. We give a general outline in Algorithm 1 [21]. Conflict analysis starts from the conflict constraint . We call the last literal of the current assignment, the reason literal . If it was not propagated, or , then it did not contribute to the conflict, so it can be removed from the assignment and we continue with the literal propagated just before it. If it is propagated and , then we should replace with its reason constraint by addition of the two constraints [15, 4], which requires reducing the reason constraint as explained below. When the new is propagating we have a learned constraint, and we can exit the conflict analysis phase.
To preserve the conflict during addition of and , there are two key requirements which make conflict-driven learning non-trivial for PB solving: The first one is that (i) adding to should indeed eliminate . Secondly, the learned constraint must propagate at an earlier stage, therefore (ii) it needs to remain conflicting under the current assignment. Since these requirements generally do not hold [4, Chapter 7], we need a reduction step, where [13] such that the requirements are enforced. A sufficient condition for (i) is that the reduced reason has the same coefficient for as the conflict constraint has for . A sufficient condition for (ii) is that after reduction, the reduced reason has slack or less, since by definition and slack is subadditive [12]: adding two constraints yields a constraint with a slack at most the sum of the slacks of the two original constraints. Hence formally we have the following requirements:
- Cancelling Coefficients (Requirement 1)
-
- Negative Slack Condition (Requirement 2)
-
Our work focuses on this reduction step. To compare between two outcomes of a reduction, we say that is stronger than when implies (i.e. every satisfying variable assignment to is also a satisfying assignment to ) but not the other way around. is rationally stronger than when the former implies the latter and not the other way around, considering assignments of rational values between the closed interval to the variables. We say reduction method dominates reduction method , with reduced constraints and respectively, when for any input rationally implies .
We already mentioned that slack is subadditive under addition. Additionally, slack remains unchanged when weakening a non-falsified literal or anti-weakening a falsified literal; slack increases when weakening a falsified literal or anti-weakening a non-falsified literal; slack is multiplied by when multiplying a constraint by . Hence, to decrease the slack of an individual non-conflicting reason constraint, at least one division or saturation step is necessary. Saturation-based reduction was the first successful implementation of cutting planes for PB solving [3], however most state-of-the-art solvers opt for division-based reduction [12, 17, 11, 22]. We will now look more in depth at division-based reduction.
2.3 RoundingSat-style Reduction
We describe the division-based reduction approach proposed by RoundingSat [12], which consists of three steps.
- Weaken Non-Divisible Non-Falsifieds (Step 1)
-
In the first step, we weaken all non-falsified literals that have a coefficient not divisible by , the reason literal ’s coefficient, so that all non-falsified literals become divisible by . In the original RoundingSat paper, these literals were fully weakened, but in the most recent implementation of RoundingSat111This recent version also participated in the last PB competition [24]., non-falsified literals with coefficient are partially weakened by , i.e. to the largest multiple of smaller than . This is a less aggressive version of weakening also discussed in [18].
- Divide (Step 2)
-
In the second step, we divide the resulting constraint by and round up all coefficients as per Equation 5. Since the previous weakening guaranteed that all non-falsified literals are divisible by , we have and no non-falsified literals are rounded up during division, which would have increased the slack. Furthermore, the authors have proven after this division step the slack is at most , because the divisor is larger than the slack [12, Proposition 3.1], hence satisfying Negative Slack Condition (Requirement 2). From their work it follows that:
Corollary 2.
Given a constraint with slack and a divisor , if the coefficients of all non-falsified literals are divisible by , then the slack after division is .
- Multiply (Step 3)
-
In the third step, given that ’s coefficient is now 1, Cancelling Coefficients (Requirement 1) can be satisfied by multiplying the reason constraint by the coefficient of the negated reason literal in the conflict .
Example 3.
Given the reason constraint , a conflict constraint , an assignment , reason literal and divisor .
Weaken Non-Divisible Non-Falsifieds (Step 1) of this method is to weaken the non-divisible non-falsified literals. So is weakened by . Then in Divide (Step 2), the constraint is divided by :
| (10) |
Note that Negative Slack Condition (Requirement 2) is now already satisfied. To satisfy Cancelling Coefficients (Requirement 1) we need to perform Multiply (Step 3) by multiplying by to get the reduced reason , which satisfies Cancelling Coefficients (Requirement 1) and Negative Slack Condition (Requirement 2). To obtain a new learned constraint we then add the reduced reason to and get . This learned constraint will propagate as soon as is decided, thereby preventing the conflict, and possibly preventing similar conflicts in later search.
3 Division-Based Reduction Variants
In this section we propose two new variants of division-based reduction, based on the above. Notice that since the reduced constraint must be implied by the reason constraint , is at best as strong as . Hence, our goal is to design a reduction method such that remains as strong as possible.
In Sections 3.1 and 3.2, we will exploit Corollary 2 and the behaviour of rounding during division-based reduction in two novel techniques. For each technique we show that Cancelling Coefficients (Requirement 1) and Negative Slack Condition (Requirement 2) still hold and that each technique dominates division-based reduction without the technique. In Section 3.3, we show how the techniques interact and can be combined.
3.1 Weaken Superfluous (WS)
When dividing a constraint with degree by divisor , the post-division degree is . Due to the upward rounding, we can often lower by some amount without changing . Specifically, for any . After Weaken Non-Divisible Non-Falsifieds (Step 1) (weakening of non-divisible non-falsifieds) of the above division-based reduction, we set maximally to get . We define a superfluous literal as:
Definition 4 (Superfluous Literal).
When dividing a constraint by , a literal with coefficient is superfluous when with .
Hence, we can weaken a superfluous literal by without altering the degree obtained after Divide (Step 2). But now, is rounded down in Divide (Step 2), which makes the reduced constraint stronger. Thus we propose the WS reduction where we iteratively weaken superfluous literals until there are no more left. Since the non-falsifieds have already been weakened to be divisible, the superfluous literals are always falsified. Therefore the reason literal is never superfluous and its coefficient will not change compared to RoundingSat-style reduction. Thus Cancelling Coefficients (Requirement 1) will still be satisfied after Multiply (Step 3) as when applying this reduction.
Example 5.
Continuing with Example 3, after Weaken Non-Divisible Non-Falsifieds (Step 1), we can weaken by a total of before Divide (Step 2). Thus is a superfluous literal, so we weaken it as well.
| (11) |
The final constraints from Equations 10 and 11 now both satisfy Negative Slack Condition (Requirement 2) and after multiplication both will also satisfy Cancelling Coefficients (Requirement 1), but the latter is stronger than the former.
We now prove division-based reduction with WS dominates division-based reduction without WS.
Proposition 6.
Let be some divisor. Let be a constraint with a superfluous literal, so . Let be the constraint after division by . Let be the constraint after weakening the superfluous literal to the nearest divisible integer (so by ), and then division by .
implies and the slack of is at most that of .
Proof.
We know that after division and
.
Note that and that (since ).
Hence, only differs from in that the coefficient of is rounded down. This means and thus implies .
From the proof, , so after division, the slack of the constraint where a superfluous literal is weakened is at most that of the non-weakened variant. So weakening superfluous literals preserves whether Negative Slack Condition (Requirement 2) is satisfied after division.
3.1.1 Link to Mixed Integer Rounding (MIR)
It has been proposed to replace the division operation (Divide (Step 2)) in division-based reduction by the Mixed Integer Rounding (MIR) operation [21]:
- Mixed Integer Rounding (MIR).
-
(12) with
To obtain normalised PB constraints with integer coefficients, MIR is followed by multiplication by .
It was shown that division-based reduction using the MIR operation in Divide (Step 2) dominates division-based reduction with the division operation [21]. However, we can show that if there are no superfluous literals, the two reduction variants are equivalent. Consequently, after weakening superfluous literals, using MIR in Divide (Step 2) provides no advantage anymore compared to using division.
Proposition 7.
Let be a constraint and a divisor such that none of the literals are superfluous in . Let and be the constraints obtained by applying the division and the MIR operation with , respectively. Then .
Proof.
As no literals are superfluous, for all literals it holds by Definition 4 that or . Hence, . In that case, Equation 12 simplifies to Equation 5, so . This means that, when there are no superfluous literals (e.g. after removing them with WS) division and MIR are equivalent.222Up to multiplication by a constant factor, which is needed for MIR. This is not the case when there are superfluous literals in the constraint. E.g. WS followed by division on constraint with divisor is stronger than just MIR on the same constraint. The opposite can also be true, e.g. for constraint with divisor . There could be other cases where just the MIR operation, without doing WS first, may be stronger than WS combined with the division operation. Further analysis is left for future work.
3.2 Anti-Weaken Anti-Superfluous (AW)
When dividing a constraint with slack by divisor , the post-division slack is according to Corollary 2. Due to downward rounding, we can often increase by some amount without changing . Specifically, for any . During Weaken Non-Divisible Non-Falsifieds (Step 1) we set maximally to get . We define an anti-superfluous literal as:
Definition 8 (Anti-Superfluous Literal).
When dividing a constraint with slack by , a non-falsified literal with coefficient is anti-superfluous when with .
During the weakening of non-divisible non-falsifieds, we can then anti-weaken by . This makes the literal divisible without it being weakened, while still not increasing the slack as part of division by . Note that we can repeat this step until there are no more anti-superfluous literals left.
Example 9.
We can again look at the conflict from Example 3, but now apply AW.
Instead of weakening by , we can anti-weaken it by and then divide by .
| (13) |
The final constraints from Equations 10 and 13 now both satisfy Negative Slack Condition (Requirement 2) and after multiplication will also satisfy Cancelling Coefficients (Requirement 1), but the latter is stronger than the former.
We now prove that division-based reduction with anti-weakening non-falsifieds dominates division-based reduction without.
Proposition 10.
Let be some divisor, a partial assignment, a constraint with slack , and an anti-superfluous literal, so .
Let be the constraint after Weaken Non-Divisible Non-Falsifieds (Step 1) and Divide (Step 2). Let be the constraint after Weaken Non-Divisible Non-Falsifieds (Step 1) and Divide (Step 2) where during Weaken Non-Divisible Non-Falsifieds (Step 1) is anti-weakened by instead of weakened by .
implies and the slack of is equal to that of .
Proof.
Since the total amount that is anti-weakened is at most , we know that the slacks of and are still equal after Divide (Step 2). Then, since is anti-weakened for it holds that . And since the slack of the two constraints is the same, the following equality holds for their respective degrees . This means and thus implies .
Hence, we propose the AW reduction where we iteratively anti-weaken anti-superfluous literals until there are no more left. From Proposition 10 it follows that anti-weakening does not increase the slack (as it yields constraints that are at least as strong), preserving Negative Slack Condition (Requirement 2). And since in RoundingSat-style reduction the divisor is the reason literal’s coefficient, the reason literal is never anti-superfluous and will thus be unchanged, satisfying Cancelling Coefficients (Requirement 1).
3.3 Combining WS and AW reduction
There is an interesting dynamic between the WS and AW reduction methods. Both exploit Corollary 2 in a similar way, by temporarily increasing the slack, while ensuring Negative Slack Condition (Requirement 2) is not violated after division. In the context of division-based reduction, WS and AW are two sides of the same coin, where WS applies to falsified literals and AW to non-falsified literals.
Proposition 11.
Let be some divisor and a partial assignment. Let be some constraint with slack , before Weaken Non-Divisible Non-Falsifieds (Step 1). Let . Let be that same constraint, with degree after Weaken Non-Divisible Non-Falsifieds (Step 1). Let . Then .
Proof.
Before Weaken Non-Divisible Non-Falsifieds (Step 1), . Weakening non-falsified literals does not alter this value. So after Weaken Non-Divisible Non-Falsifieds (Step 1), . By rearranging Equation 1 and replacing and since all non-falsifieds are divisible by we get . Therefore, .
So the amount we can (anti-)weaken by is shared between the two techniques, i.e. if we weaken superfluous literals by , then we only have left to anti-weaken anti-superfluous literals.
We can easily combine AW and WS in one divsion-based reduction approach, which we present in Algorithm 2. We first apply AW in lines 6 to 8, then WS in lines 10 to 14.
4 Saturation-Based Reduction Variants
In the previous section we focused on division-based reduction. In this section we will focus on the other family of reduction techniques: saturation-based reduction. We investigate a saturation-based method called Multiply and Weaken (MW) [18]. The main idea we use from MW is to multiply the reason and/or the conflict constraint in order to bring the coefficients of the reason literal in the reason and conflict close to each other, with . We develop two reduction variants, both of which use weakening in a different manner to satisfy Cancelling Coefficients (Requirement 1). As for Negative Slack Condition (Requirement 2), the MW reduction variants use the necessary, but less strict, requirement:
- Weak Negative Slack Condition (Requirement 3)
-
4.1 Multiply and Weaken Direct (MWD)
The first MW reduction variant, Multiply and Weaken Direct (MWD), applies the following operations. First, multiply by and by . Then, weaken the reason literal in the multiplied reason constraint by the exact amount needed to satisfy Cancelling Coefficients (Requirement 1), i.e. by . However, these operations will only yield a reduced reason and conflict constraint (i.e. meeting Weak Negative Slack Condition (Requirement 3)) if the following condition holds:
| (14) |
If Equation 14 does hold, then Weak Negative Slack Condition (Requirement 3) is guaranteed to be satisfied, since the multiplications of the slack are taken into account and weakening of non-falsified literals does not increase the slack. If Equation 14 does not hold, MWD reduction uses a fallback reduction method instead. In some cases, MWD yields stronger constraints than division-based reduction:
Example 12.
Given a reason constraint , a conflict constraint , an assignment and a reason literal .
We show Weaken Non-Divisible Non-Falsifieds (Step 1) and Divide (Step 2) for division-based reduction:
| (15) |
For MWD reduction, we first need to check if it is even possible to satisfy Weak Negative Slack Condition (Requirement 3). Since Weak Negative Slack Condition (Requirement 3) will indeed be satisfied. If so, Weak Negative Slack Condition (Requirement 3) will indeed be satisfied and we can continue with the MWD approach. Since no multiplication is needed all we need to do is weaken by :
| (16) |
We can see that the reduced reason from MWD in Equation 16 is stronger than the one from division-based reduction Equation 15.
4.2 Multiply and Weaken Indirect (MWI)
While MWD always directly weakens the reason literal , another approach is possible when is saturated, i.e. if its coefficient is at least as high as the degree of the constraint. Instead of weakening directly, we can lower the degree by weakening a different non-falsified literal, and then apply saturation. This lowers ’s coefficient to the degree of the constraint, effectively giving the same coefficient as if it was weakened. In this case, we weaken two literals “for the price of one”. Other than the different weakening approach followed by saturation of the reason constraint, MWI applies the same operations as MWD. We continue Example 12:
Example 13.
Instead of weakening directly by , we can instead weaken the non-falsified literal by and then saturate so that gets the desired coefficient .
| (17) |
Clearly, since the coefficient of is lower, the reduced reason in Equation 17 is stronger than the one obtained by MWD in Equation 16.
Note that constraints obtained by MWI imply those obtained by MWD, as the only difference in both routines is that some coefficients are lowered for MWI, while the degree in the reduced reason remains exactly the same.
4.3 Combining MWD, MWI, and division-based reduction
We present the novel MW variants in Algorithm 3. On line 3 we check Equation 14 to see if Weak Negative Slack Condition (Requirement 3) will hold after MWD. If it does, we multiply the constraint and calculate the amount we directly weaken by on line 17. Otherwise, we use a fallback reduction, in our case this is division-based reduction from Algorithm 2. Note that this allows us to combine the division-based reduction variants, AW and WS, with the saturation-based variants, MWD and MWI. Then from line 9 to 16, if the reason literal is saturated, we apply indirect weakening and saturation. We perform the final step of direct weakening and saturate again. In this fashion, we use MWI in combination with MWD since there is no guarantee that only MWI will always sufficiently reduce the reason coefficient.
5 Experimental Evaluation
In this section, we evaluate the impact of the proposed techniques on solver performance. We implemented our techniques into Exact 2.1.0 [11]333The earlier version of Exact submitted to the PB’24 competition already incorporated these techniques, which is a fork of RoundingSat [12]. We use three benchmark sets:
- KNAP
- DEC-LIN
-
the decision linear track of the PB’24 competition (398 instances)
- OPT-LIN
-
the optimisation linear track of the PB’24 competition (489 instances)
For KNAP the solver is given a memory limit 8GB of RAM and a timeout of 600 seconds. For DEC-LIN and OPT-LIN the solver is given a memory limit of 31GB of RAM and a timeout of 3600 seconds as in the PB’24 competition. The KNAP benchmark set is added because each instance consists of a single constraint, which puts a heavy emphasis on learning strong constraints. Our experiments were run on a cluster with 32 INTEL(R) XEON(R) SILVER 4514Y (2GHz) CPUs with 256GB of shared memory. We run each configuration of the solver with 5 seeds. Our figures are plotted with performance on the -axis and solve time on the -axis. Optimisation instances are considered solved if an optimal solution is found and it is proven that no better exists. We use the results from the five seeds to plot 95% confidence bands to visualize potential variance in solve-times, with a solid line for the median. The implementation and run logs are included as supplemental material.
5.1 Individual techniques
Our first experiment compares each individual technique (i.e. the WS, AW, MWD, and MWD+MWI reduction methods) to Exact as a baseline. For the division-based techniques we see that on KNAP in Figure 1(a), WS solves more instances and AW solves some instances faster. We also see positive results when it comes to the saturation-based techniques in Figure 1(b). MWD and MWD+MWI both perform similarly, while outperforming the baseline. On DEC-LIN we see similar trends for the division-based techniques in Figure 2(a). WS still solves more instances than the baseline and AW mostly helps solving some instances faster. For the saturation-based techniques we do see in Figure 2(b) a different trend compared to KNAP. While MWD still helps improve the performance of the solver, MWD+MWI shows a negative performance. This unexpected result is interesting, since we know MWD+MWI dominates MWD from a theoretical perspective. On OPT-LIN we do not see much of a difference either way for the division-based techniques in Figure 3(a), but the performance marginally worsens for the saturation-based techniques in Figure 3(b).
We believe the smaller impact of AW is due to how each technique changes the constraint. WS only lowers one coefficient while keeping everything else the same, while AW increases the degree as well as a coefficient. The increase in the degree could however lead to fewer saturation opportunities after addition with the conflict constraint, reducing the impact. On the other hand, lowering a coefficient via WS may lead to fewer variable cancellations and in turn less saturation after addition, though the odds for cancellation on non-propagated literals may be relatively smaller. In the end, both techniques show only moderate impact on the selected benchmarks.
5.2 Combined techniques
In our second experiment we evaluate how combining the different techniques as shown in Section 4.3 impacts the empirical runtime of PB solvers. Additionally, we test an implementation of the combined division-based techniques, WS+AW, on another solver, namely the PB’24 competition version of RoundingSat, to see how it behaves in different solvers. Implementing the saturation-based techniques in RoundingSat would have required more extensive changes due to overflows after multiplication.
The results are summarised in Table 1. On KNAP, combining all the techniques has a compounding effect for both solvers. On DEC-LIN, the results are less clear. Exact+WS+AW does perform very well, which might initially seem surprising since according to Proposition 11 applying AW means less WS is possible. RoundingSat+WS+AW, on the other hand has minor impact on RoundingSat for DEC-LIN. Still, it seems both techniques can be combined effectively. The same cannot be said when mixing the division- and saturation-based techniques. We hypothesize that since WS+AW improves division-based reduction, a better heuristic than Equation 14 for the saturation-based techniques is necessary. It may be that WS+AW is most effective in many cases where MWD is actually possible, thus the improvements from WS+AW carry over to WS+AW+MWD. On OPT-LIN, the choice of configuration of the techniques still does not seem to have much impact, with similar performance to the configurations using an individual technique.
| Solved | KNAP (783) | DEC-LIN (398) | OPT-LIN (489) |
|---|---|---|---|
| Exact | 664 | 282 | 250 |
| Exact+WS | 674 | 284 | 249 |
| Exact+AW | 666 | 282 | 248 |
| Exact+WS+AW | 683 | 287 | 247 |
| Exact+MWD | 687 | 285 | 248 |
| Exact+MWD+MWI | 685 | 275 | 248 |
| Exact+WS+AW+MWD | 695 | 284 | 248 |
| Exact+WS+AW+MWD+MWI | 698 | 280 | 249 |
| RoundingSat | 691 | 281 | 253 |
| RoundingSat+WS+AW | 709 | 282 | 251 |
6 Conclusion and Future Work
We presented novel techniques to generate stronger reduced constraints in both division-based [12] and saturation-based [18] reduction methods. As in established work [21], we can indeed prove dominance relationships between the various reduction methods, which guarantee that reduced constraints obtained from one are at least as strong as those from another. The experiments show that stronger reduced constraints can improve the solver performance for different solvers and benchmarks, but not uniformly across all problems. While there are improvements on crafted knapsack benchmarks, and the competition decision benchmark for Exact, we observe little difference on competition optimisation benchmarks. Perhaps more surprisingly, in competition decision benchmarks we see a case of worsening performance for MWD+MWI compared to MWD, despite their dominance relationship.
Hence our theoretical results provide a better understanding of reduction methods and the freedom there is in reducing constraints before addition. Empirically there is a lesser understood relationship between the strength of the reduced reason constraint, the strength of the learned constraint after all iterations of constraint addition in the conflict analysis, and the effect of the learned constraints on solver performance. However, these relationships are complex, because they involve the reduction and resolution of multiple reason constraints with the conflict constraint. With the insights of the paper we also see avenues to strengthen the reduced constraints further. For example, in division-based reduction, relaxing Negative Slack Condition (Requirement 2) to Weak Negative Slack Condition (Requirement 3) (as in saturation-based reduction) could lead to a smaller divisor or an increase in the amount of superfluous and anti-superfluous literals.
We also saw how some combinations of reduction techniques can be effective, but they use heuristics, e.g. to choose between division- and saturation-based reduction for specific constraints. These heuristics are much less studied and can have a big impact on empirical performance which deserves further study.
References
- [1] Gilles Audemard and Laurent Simon. On the glucose SAT solver. Int. J. Artif. Intell. Tools, 27(1):1840001:1–1840001:25, February 2018. doi:10.1142/S0218213018400018.
- [2] Danel Le Berre, Pierre Marquis, Stefan Mengel, and Romain Wallon. On Irrelevant Literals in Pseudo-Boolean Constraint Learning. In Proceedings of the Twenty-Ninth International Joint Conference on Artificial Intelligence, pages 1148–1154, July 2020. doi:10.24963/ijcai.2020/160.
- [3] Daniel Le Berre and Anne Parrain. The sat4j library, release 2.2. J. Satisf. Boolean Model. Comput., 7(2-3):59–6, 2010. doi:10.3233/sat190075.
- [4] Sam Buss and Jakob Nordström. Proof complexity and SAT solving. In Armin Biere, Marijn Heule, Hans van Maaren, and Toby Walsh, editors, Handbook of Satisfiability - Second Edition, volume 336 of Frontiers in Artificial Intelligence and Applications, pages 233–350. IOS Press, 2021. doi:10.3233/FAIA200990.
- [5] Donald Chai and Andreas Kuehlmann. A fast pseudo-boolean constraint solver. In Proceedings of the 40th Annual Design Automation Conference, pages 830–835, Anaheim CA USA, June 2003. ACM. doi:10.1145/775832.776041.
- [6] Donald Chai and Andreas Kuehlmann. A fast pseudo-boolean constraint solver. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 24:305–317, 2005. doi:10.1109/TCAD.2004.842808.
- [7] Stephen A. Cook. The complexity of theorem-proving procedures. In Michael A. Harrison, Ranan B. Banerji, and Jeffrey D. Ullman, editors, Proceedings of the 3rd Annual ACM Symposium on Theory of Computing, May 3-5, 1971, Shaker Heights, Ohio, USA, STOC ’71, pages 151–158, New York, NY, USA, 1971. ACM. doi:10.1145/800157.805047.
- [8] W. Cook, C.R. Coullard, and Gy. Turán. On the complexity of cutting-plane proofs. Discrete Applied Mathematics, 18(1):25–38, September 1987. doi:10.1016/0166-218X(87)90039-4.
- [9] Jo Devriendt. Pisinger’s knapsack instances in opb format, July 2020. doi:10.5281/zenodo.3939055.
- [10] Jo Devriendt. Watched Propagation of 0-1 Integer Linear Constraints. In Helmut Simonis, editor, Principles and Practice of Constraint Programming, pages 160–176, Cham, 2020. Springer International Publishing. doi:10.1007/978-3-030-58475-7_10.
- [11] Jo Devriendt. Exact: Evaluating cutting-planes learning at the PB’24 competition. Slides, 2024.
- [12] Jan Elffers and Jakob Nordström. Divide and Conquer: Towards Faster Pseudo-Boolean Solving. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, pages 1291–1299, Stockholm, Sweden, July 2018. International Joint Conferences on Artificial Intelligence Organization. doi:10.24963/ijcai.2018/180.
- [13] Jan Elffers and Jakob Nordström. RoundingSat 2019: Recent work on PB solving. https://slides.com/jod/deck-26-29-32, July 2019.
- [14] Armin Haken. The intractability of resolution. Theor. Comput. Sci., 39:297–308, 1985. Third Conference on Foundations of Software Technology and Theoretical Computer Science. doi:10.1016/0304-3975(85)90144-6.
- [15] John N Hooker. Generalized resolution and cutting planes. Annals of Operations Research, 12:217–239, 1988.
- [16] Hannes Ihalainen, Jeremias Berg, and Matti Järvisalo. Ipbhs in pb’24 competition. Slides, 2024.
- [17] Christoph Jabs, Jeremias Berg, and Matti Järvisalo. PB-OLL-RS and MIXED-BAG in Pseudo-Boolean Competition 2024. PB Competition 2024, 2024.
- [18] Daniel Le Berre, Pierre Marquis, and Romain Wallon. On Weakening Strategies for PB Solvers. In Luca Pulina and Martina Seidl, editors, Theory and Applications of Satisfiability Testing – SAT 2020, pages 322–331, Cham, 2020. Springer International Publishing. doi:10.1007/978-3-030-51825-7_23.
- [19] Orestis Lomis, Jo Devriendt, Hendrik Bierlee, and Tias Guns. ML-KULeuven/SAT25_PB_reductions_experiments. Dataset, This research was partly funded by the European Research Council (ERC) under the EU Horizon 2020 research and innovation programme (Grant No 101002802, CHAT-Opt)., swhId: swh:1:dir:650c2f9b37926504a59a11a6dbf319620b311dc3 (visited on 2025-07-23). URL: https://github.com/ML-KULeuven/SAT25_PB_reductions_experiments, doi:10.4230/artifacts.24089.
- [20] J.P. Marques Silva and K.A. Sakallah. Grasp-a new search algorithm for satisfiability. In Proceedings of International Conference on Computer Aided Design, pages 220–227, 1996. doi:10.1109/ICCAD.1996.569607.
- [21] Gioni Mexi, Timo Berthold, Ambros Gleixner, and Jakob Nordström. Improving conflict analysis in mip solvers by pseudo-boolean reasoning. arXiv preprint arXiv:2307.14166, 2023. doi:10.48550/arXiv.2307.14166.
- [22] Shiwei Pan, Yiyuan Wang, Shaowei Cai, Jiangnan Li, Wenbo Zhu, and Minghao Yin. Cashwmaxsat-disjcad: Solver description. MaxSAT Evaluation 2024, 2024:25, 2024.
- [23] David Pisinger. Where are the hard knapsack problems? Comput. Oper. Res., 32(9):2271–2284, 2005. doi:10.1016/j.cor.2004.03.002.
- [24] Roussel, Olivier. Pseudo-Boolean Competition of 2024. https://www.cril.univ-artois.fr/PB24/.
