feat: Semantic Minimisation during Conflict Analysis by ImkoMarijnissen · Pull Request #406 · ConSol-Lab/Pumpkin

ImkoMarijnissen · 2026-03-31T08:02:34Z

Closes #397.

After discussing with @maartenflippo, I implemented a very simple implementation of the conjoin function from "Semantic Learning for Lazy Clause Generation - Feydy et al.".

Some anecdotal examples of the effect:
For an RCPSP instance (01.dzn), the number of failures goes from 3,711 to 3,376 and for another instance (J120_60_5), the number of failures to get to a solution of 108 is reduced from 28,303 to 27,855. For foxgeesecorn, the number of failures to get to an objective of 32 goes from 114,811 to 81,268.

There are a few things which are not entirely clear to me:

Currently, whenever replacing a predicate with a fully new one (e.g., we replace $[x \geq 5]$ and $[x \neq 5]$ with $[x \geq 6]$), then I do a check that it will not be resolved on next to avoid infinite loops. Is this the correct way to handle it or is something else going wrong?
In the paper, the conjoin function is underspecified, and it is somewhat unclear what exactly it does; for now, we assume that the elements in the working nogood are in the left side of the rewrite rules, and the added propagation reasons are on the right side of the rewrite rules. It was unclear to us what the reason for this is, but it appears to create incorrect nogoods otherwise.
I have removed the check that a predicate has not already been seen. We think that this led to incorrectness but it would be good to double-check.

TODOs

Implement more efficiently, likely with a data structure which is similar to the one used for semantic minimisation.
Do not log all initial bounds but only when they are used
Profile on larger benchmark set

Experimentation

In general, it appears to significantly improve the number of instances for which a solution is found at the cost of proving optimality on instances. This could be due to the fact that there are 24 OOM errors compared to the 42 OOM errors in main. The MiniZinc score is also improved (even when filtering out instances where an error occurred; i.e., OOMs) quite significantly. This could be due to the fact that the average primal integral also appears to be significantly reduced.

Overall Results

main

{'ERROR': 47,
 'OPTIMAL': 104,
 'SATISFIABLE': 141,
 'UNKNOWN': 96,
 'UNSATISFIABLE': 5}

new

{'ERROR': 29,
 'OPTIMAL': 101,
 'SATISFIABLE': 156,
 'UNKNOWN': 102,
 'UNSATISFIABLE': 5}

MiniZinc Score

{
    'main': 119.32,
    'new': 148.68
}

Average Primal Integral

{
    'main': 49.45,
    'new': 29.55
}

…nces

… in semantic minimiser

…ified clause

This reverts commit b99b962.

…logging

…tive minimiser when when replaced

maartenflippo · 2026-04-01T23:35:31Z

+            while lower_bound != i32::MIN
+                && let Some((lb_updated, _)) = self.domains[domain].holes.get(&(lower_bound - 1))
+                && *lb_updated
+                && context.get_checkpoint_for_predicate(predicate!(domain != lower_bound - 1))
+                    == Some(0)
+            {
+                lower_bound -= 1;
+                context.explain_root_assignment(predicate!(domain != lower_bound));
+            }


If I understand this correctly, it introduces $[x \neq v]$ for the initial holes. Why not just iterate the holes? Also note that if we introduce $\top \rightarrow [x \ge 5]$, then there is no need to introduce $\top \rightarrow [x \ne v]$ for $v < 5$.

It only introduces the hole(s) when we have an element $[x \geq v]$ in the nogood, and a sequence of holes caused the lower-bound to become $v'$ (such that $v'$ > $v$)

Hmm, I am not 100% sure I understand what you mean. Could you give a concrete example?

ImkoMarijnissen · 2026-07-15T08:40:29Z

Can we remove semantic minimisation in extract_final_nogood?

…cy checking until after presence checking + setting value to 0

…ic constraint

maartenflippo

Sorry :). More changes

maartenflippo · 2026-07-21T15:32:00Z

    Atomic: AtomicConstraint,
 {
+    pub fn reset_domain(&mut self, identified: Atomic::Identifier) {
+        let _ = self.domains.insert(identified, Domain::all_integers());


If the domain is not present, let's not insert anything

maartenflippo · 2026-07-21T15:34:03Z

+    /// Decides whether to apply semantic minimisation during conflict analysis; according to the
+    /// idea proposed in "Semantic Learning for Lazy Clause Generation - Feydy et al. (2013)".
+    ///
+    /// If this flag is present then the minimisation is turned on.
+    ///
+    /// Possible values: bool
+    #[arg(long = "iterative-minimisation", verbatim_doc_comment)]
+    iterative_minimisation: bool,


Should be true by default?

maartenflippo · 2026-07-21T15:35:54Z

+#[derive(Clone, Debug)]
+struct IterativeDomain {
+    lb: i32,
+    ub: i32,
+    holes: Vec<i32>,
+}


Seems like the VariableState?

There is probably a reason why this is necessary. In that case, please document it

maartenflippo · 2026-07-21T15:38:27Z

 impl Default for ResolutionResolver {
    fn default() -> Self {
-        ResolutionResolver::new(AnalysisMode::OneUIP, true)
+        ResolutionResolver::new(AnalysisMode::OneUIP, true, false)


Should the default be true?

maartenflippo · 2026-07-21T15:38:43Z

+        // println!("======================================================================");
+        // println!("C: {conflict_nogood:?}");


maartenflippo · 2026-07-21T15:39:00Z

+            // println!(
+            //     "WORKING NOGOOD: {:?}",
+            //     self.processed_nogood_predicates
+            //         .iter()
+            //         .copied()
+            //         .chain(
+            //             self.to_process_heap
+            //                 .keys()
+            //                 .map(|id| self.predicate_id_generator.get_predicate(id))
+            //         )
+            //         .collect::<Vec<_>>()
+            // );
            // Replace the predicate from the nogood that has been assigned last on the trail.


Commented code

maartenflippo · 2026-07-21T15:39:08Z

+            // println!("R: {:?} -> {next_predicate}", self.reason_buffer);
+


maartenflippo · 2026-07-21T15:39:22Z

            });
        // Ignore root level predicates.
        if dec_level == 0 {
+            // println!("{predicate:?} ROOT LEVEL");


maartenflippo · 2026-07-21T15:41:57Z

+        // println!(
+        //     "FINAL NOGOOD: {:?}",
+        //     self.processed_nogood_predicates
+        //         .iter()
+        //         .copied()
+        //         .chain(
+        //             self.to_process_heap
+        //                 .keys()
+        //                 .map(|id| self.predicate_id_generator.get_predicate(id))
+        //         )
+        //         .collect::<Vec<_>>()
+        // );


maartenflippo and others added 30 commits March 29, 2026 12:45

Move inference checker to its own file

2249e21

Move the deduction checker to pumpkin_checking

32d3af6

Build runtime verification into the resolution conflict resolver

f8e8080

Run deduction verification during tests

4232ef9

Fix CI to actually run deduction checks

c7f3147

Implement better printing of failed deduction checks

e33f843

Collect initial domains and the last propagation as supporting infere…

74a38a1

…nces

Do runtime verification of deductions when they are logged

b52740b

Verify deductions in tests

dbd4056

refactor(pumpkin-conflict-resolvers): Correctly log domain inferences…

e46a611

… in semantic minimiser

fix(pumpkin-conflict-resolvers): Log inference for freshly added fals…

9b9e7ee

…ified clause

Fix docs for atomic! macro

c1565e1

Apply fixes based on feedback in review

5064db2

Correctly log inferences for minimisation

18aa665

Remove redundant inferences introduced through minimisation

56e5a14

Do not disable recursive minimisation when proof logging

e1c9728

Fix compile error

5be0213

Work around assumptions by introducing them as initial domains

0194f65

Allow inconsistent premises in the deduction

9f3cc2f

feat: setup for removing elements during conflict analysis

ce38731

feat: adding statistics

69e6e7c

fix: time-table checker not passing with holes

a6cdcb4

Merge branch 'fix/time-table-checker' into feat/minimisation-during-ca

0fd347b

fix: swapping around of values

b99b962

Merge branch 'fix/time-table-checker' into feat/minimisation-during-ca

3f99bf2

Revert "fix: swapping around of values"

2c70913

This reverts commit b99b962.

fix: remove instead of add

a34897a

Merge branch 'fix/time-table-checker' into feat/minimisation-during-ca

ad663ad

feat: replacing predicates with new predicates + improving statistic …

954aba4

…logging

Merge branch 'main' into feat/minimisation-during-ca

376f4da

ImkoMarijnissen added 10 commits March 31, 2026 15:46

WIP: making progress

e737f83

fix: logging root-level deductions when inferring redundancy

ec13f55

fix: logging more root-level inferences + remove predicate from itera…

787449b

…tive minimiser when when replaced

Merge branch 'main' into feat/minimisation-during-ca

d2f0739

chore: clippy warnings

ac03d34

chore: clippy warnings duplicate crate

479b5e4

docs: adding documentation

7de5ba3

fix: only log in proof when necessary

f95f127

chore: remove unnecessary logging of unset parameters

607659d

fix: hole update after removing lower or upper-bound

61f2253

maartenflippo reviewed Apr 1, 2026

View reviewed changes

ImkoMarijnissen added 9 commits April 2, 2026 08:06

docs: adding documentation to iterative minimiser

081a5c7

refactor: changing to variable state

699c6af

refactor: allow removing of multiple elements at once

0cc079b

refactor: do not allocate or reset when unnecessary

99c1150

refactor: also remove not equals when introducing lower-bound

606834c

fix: issue with root bounds + issue with removing not actually removing

e06823d

fix: argument to pumpkin solver

a003524

Merge branch 'main' into feat/minimisation-during-ca

18ac726

Merge branch 'main' into feat/minimisation-during-ca

09cfc97

ImkoMarijnissen marked this pull request as ready for review July 15, 2026 08:36

ImkoMarijnissen added 7 commits July 15, 2026 14:59

feat: also adding rewriting based on added equalities

3f30772

refactor: some simplifications + adding documentation

eb73014

refactor: clarfiying result of processing + moving iterative redundan…

2376634

…cy checking until after presence checking + setting value to 0

fix: remove when replacing depeneding on the decision level

be866a4

feat: allow replacing of variable when it would be the asserting atom…

e8e13fa

…ic constraint

refactor: use simpler domain representation

3f8048d

refactor: use vec instead of hashset for storage

f6d7871

maartenflippo requested changes Jul 21, 2026

View reviewed changes

		// println!("======================================================================");
		// println!("C: {conflict_nogood:?}");

		// println!("R: {:?} -> {next_predicate}", self.reason_buffer);

Uh oh!

Conversation

ImkoMarijnissen commented Mar 31, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

TODOs

Experimentation

Overall Results

MiniZinc Score

Average Primal Integral

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

ImkoMarijnissen commented Jul 15, 2026

Uh oh!

maartenflippo left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

ImkoMarijnissen commented Mar 31, 2026 •

edited

Loading