Set Expressions (with Chainable Format) for Arithmetic and Relational Operations #1171

cprudhom · 2025-08-29T08:46:44Z

This PR takes the work from @gadavidd (#1107) and extracts the 4 impacting commits and places them back on the up-to-date develop branch.

… existing structure for integer expressions. + update headers Suggestion of improvements: detect constraints like `partition(SetVar[] sets, SetVar universe)`

jgFages · 2025-08-31T15:44:37Z

solver/src/main/java/org/chocosolver/solver/expression/discrete/set/BiReSetExpression.java

+                return model.allEqual(xSet, ySet);
+            case NE:
+                return model.allDifferent(xSet, ySet);
+            case CONTAINS:


Why having both SUBSET and CONTAINS ?
I think I prefer subset

jgFages · 2025-08-31T15:46:34Z

solver/src/main/java/org/chocosolver/solver/expression/discrete/set/BiReSetExpression.java

+            case CONTAINS:
+                return model.subsetEq(ySet, xSet);
+            case NOT_CONTAINS:
+                return model.disjoint(xSet, ySet);


if contains(x, y) means that y is a subset of x
I would expect not_contains(x, y) to mean that y is not a subset of x, which does not mean that both sets are disjoint. They might have one value in common.

Not necessarily. How would you express the following constraint otherwise ? "x should not contain the values of y ?"

I would use the term disjoint for that. It is much clearer.
"Should not contain the values of y" is confusing because a value of a set variable is a set.
Let say X has 2 solutions : {2,3} and {2,5,7}. If Y = {2}, then it does not contain the values of X. Yet, I guess it is not what you meant, you want both variables to have disjoint values.
Also, to contain is a directed concept (A contains B is different from B contains A) whereas disjointness is not.

I see what you mean. Therefore, I agree that DISJOINT should be a better name than NOT_CONTAINS

I agree as well. When I wrote this term, I was thinking from a user’s perspective. In that context, “contains” and “not contains” are more commonly used, but they introduce ambiguity. Using “subset” and “disjoint” makes the intended behavior much clearer.

ArthurGodet · 2025-08-31T16:02:34Z

solver/src/main/java/org/chocosolver/solver/expression/discrete/set/ArSetExpression.java

+    /**
+     * Checks if this set is a subset of a given set of integers.
+     *
+     * @param y the integer values to check.
+     * @return a boolean expression representing the subset relationship.
+     */
+    default ReExpression subSet(int... y) {
+        return new BiReSetExpression(SetOperator.SUBSET, this, this.getModel().setVar(Arrays.stream(y).toArray()));
+    }
+
+    /**
+     * Checks if this set is equal to a given set of integers.
+     *
+     * @param y the integer values to compare.
+     * @return a boolean expression representing equality.
+     */
+    default ReExpression eq(int... y) {
+        return new BiReSetExpression(SetOperator.EQ, this, this.getModel().setVar(Arrays.stream(y).toArray()));
+    }
+
+    /**
+     * Checks if this set does not contain a given set of integers.
+     *
+     * @param y the integer values to check.
+     * @return a boolean expression representing non-membership.
+     */
+    default ReExpression notContains(int... y) {
+        return new BiReSetExpression(SetOperator.NOT_CONTAINS, this, this.getModel().setVar(Arrays.stream(y).toArray()));
+    }
+
+    /**
+     * Checks if this set contains a given set of integers.
+     *
+     * @param y the integer values to check.
+     * @return a boolean expression representing membership.
+     */
+    default ReExpression contains(int... y) {
+        return new BiReSetExpression(SetOperator.CONTAINS, this, this.getModel().setVar(Arrays.stream(y).toArray()));
+    }
+
+    /**
+     * Checks if this set is different from a given set of integers.
+     *
+     * @param y the integer values to compare.
+     * @return a boolean expression representing inequality.
+     */
+    default ReExpression ne(int... y) {
+        return new BiReSetExpression(SetOperator.NE, this, this.getModel().setVar(Arrays.stream(y).toArray()));
+    }


I would have relied on the methods creating the BiReSetExpression from a ArSetExpression, once the SetVar created from y values, instead of relying on new BiReSetExpression() in these methods.

ArthurGodet · 2025-08-31T16:05:04Z