Allow continuous relaxation of inequality-constrained ordinal dims

Summary:
`_setup_continuous_relaxation` in `optimize_mixed.py` blanket-excludes all
constrained discrete dimensions from continuous relaxation, forcing them into
discrete local search even when they have high cardinality. This is overly
conservative for inequality constraints and causes severe performance
degradation.

**Problem:** When ordinal parameters (e.g., integers 0-50) participate in
linear inequality constraints (e.g., `x1 + x2 + x3 <= 100`), they are kept
as discrete dims regardless of cardinality. In mixed search spaces, this
inflates the discrete combination count (e.g., 51^4 x 20 = 135M), forces
`optimize_acqf_mixed_alternating`, and with default optimizer budgets
(`raw_samples=1024`, `maxiter_init=100`, `maxiter_alternating=64`) across
many sequential candidates, produces ~900K+ acquisition function evaluations
-- taking hours instead of minutes.

**Fix:** Only exclude dimensions participating in **equality** constraints
from continuous relaxation. Inequality-constrained dims are now eligible for
relaxation because `_optimize_acqf_batch` already handles rounding-induced
constraint violations: it applies `post_processing_func` (rounding), checks
feasibility, projects infeasible candidates back via SLSQP, and re-rounds
(see `optimize.py` lines 528-574).

**Why this is safe for inequality but not equality constraints:**
- *Inequality*: The feasible region has interior. SLSQP easily finds a nearby
  feasible point after rounding, and re-rounding a near-integer point rarely
  re-violates.
- *Equality*: The feasible set is a hyperplane. Rounding pushes points off the
  hyperplane, SLSQP projects back (to a non-integer point), re-rounding pushes
  off again -- the cycle may not converge.

Differential Revision: D99304800

Author: ItsMrLin

botorch/optim/optimize_mixed.py

@@ -130,16 +130,22 @@ def _setup_continuous_relaxation(
     ``discrete_dims`` and ``post_processing_func`` is updated to round
     them to the nearest integer.
 
-    Dimensions that participate in constraints are NOT relaxed, as rounding
-    after projection could violate those constraints.
+    Dimensions that participate in equality constraints are NOT relaxed,
+    as rounding can push points off the constraint hyperplane and the
+    project-round cycle may not converge. Dimensions in inequality
+    constraints ARE eligible for relaxation because the feasible region
+    has interior and ``_optimize_acqf_batch`` already handles any
+    rounding-induced violations via SLSQP projection and re-rounding.
     """
 
-    # Identify dimensions involved in constraints
+    # Only exclude dimensions involved in equality constraints.
+    # Inequality-constrained dims can be safely relaxed: if rounding
+    # violates the constraint, _optimize_acqf_batch projects back via
+    # SLSQP and re-rounds (see optimize.py lines 528-574).
     constrained_dims: set[int] = set()
-    for constraints in [inequality_constraints, equality_constraints]:
-        if constraints is not None:
-            for indices, _, _ in constraints:
-                constrained_dims.update(indices.tolist())
+    if equality_constraints is not None:
+        for indices, _, _ in equality_constraints:
+            constrained_dims.update(indices.tolist())
 
     dims_to_relax, dims_to_keep = {}, {}
     for index, values in discrete_dims.items():

test/optim/test_optimize_mixed.py

@@ -1612,55 +1612,96 @@ def org_post_proc_func(X: Tensor) -> Tensor:
         self.assertAllClose(X[..., all_integer_dims], X[..., all_integer_dims].round())
 
     def test_setup_continuous_relaxation_excludes_constrained_dims(self) -> None:
-        """Test that _setup_continuous_relaxation keeps constrained discrete dims."""
+        """Test that _setup_continuous_relaxation only excludes equality-constrained
+        dims from relaxation. Inequality-constrained dims are eligible for
+        relaxation since _optimize_acqf_batch handles rounding-induced violations
+        via SLSQP projection.
+        """
         for dtype in (torch.float, torch.double):
             # Setup: 3 discrete dimensions
             # - Dim 0: Low cardinality (2 values) - kept regardless
-            # - Dim 1: High cardinality (50 values), participates in constraint - kept
+            # - Dim 1: High cardinality (50 values), inequality constraint - relaxed
             # - Dim 2: High cardinality (50 values), not constrained - relaxed
             discrete_dims: dict[int, list[float]] = {
                 0: [0.0, 1.0],  # Low cardinality - should be kept
-                1: list(range(50)),  # High cardinality, constrained - should be kept
+                1: list(range(50)),  # High card, ineq constrained - relaxed
                 2: list(range(50)),  # High cardinality, not constrained - relaxed
             }
             max_discrete_values = 20
-            # Constraint on dim 1: x[1] >= 10
+            # Inequality constraint on dim 1: x[1] >= 10
             inequality_constraints = [
                 (
                     torch.tensor([1], dtype=torch.long, device=self.device),
                     torch.tensor([1.0], dtype=dtype, device=self.device),
                     10.0,
                 )
             ]
-            # Execute: call _setup_continuous_relaxation
             dims_kept, post_processing_func = _setup_continuous_relaxation(
                 discrete_dims=discrete_dims,
                 max_discrete_values=max_discrete_values,
                 post_processing_func=None,
                 inequality_constraints=inequality_constraints,
             )
-            # Assert: dims 0 and 1 are kept (low cardinality and constrained)
+            # Dim 0 kept (low cardinality), dims 1 and 2 relaxed
             self.assertIn(0, dims_kept)
-            self.assertIn(1, dims_kept)
-            # Assert: dim 2 is NOT in dims_kept (relaxed)
+            self.assertNotIn(1, dims_kept)
             self.assertNotIn(2, dims_kept)
-            # Assert: post_processing_func is not None since dim 2 was relaxed
             self.assertIsNotNone(post_processing_func)
-            # Assert: post_processing_func rounds dim 2 but not dims 0 or 1
+            # post_processing_func rounds dims 1 and 2 but not dim 0
             X = torch.tensor(
-                [0.4, 25.3, 30.7],  # dim 0, 1, 2 with non-integer values
+                [0.4, 25.3, 30.7],
                 dtype=dtype,
                 device=self.device,
             )
             X_processed = post_processing_func(X)
-            # Dim 0 and 1 should remain unchanged (not rounded by this func)
             self.assertAllClose(
                 X_processed[0], torch.tensor(0.4, dtype=dtype, device=self.device)
             )
+            self.assertAllClose(
+                X_processed[1], torch.tensor(25.0, dtype=dtype, device=self.device)
+            )
+            self.assertAllClose(
+                X_processed[2], torch.tensor(31.0, dtype=dtype, device=self.device)
+            )
+
+    def test_setup_continuous_relaxation_excludes_equality_constrained(self) -> None:
+        """Test that equality-constrained dims are excluded from relaxation."""
+        for dtype in (torch.float, torch.double):
+            discrete_dims: dict[int, list[float]] = {
+                0: [0.0, 1.0],  # Low cardinality - kept
+                1: list(range(50)),  # High card, equality constrained - kept
+                2: list(range(50)),  # High card, unconstrained - relaxed
+            }
+            max_discrete_values = 20
+            equality_constraints = [
+                (
+                    torch.tensor([1], dtype=torch.long, device=self.device),
+                    torch.tensor([1.0], dtype=dtype, device=self.device),
+                    25.0,
+                )
+            ]
+            dims_kept, post_processing_func = _setup_continuous_relaxation(
+                discrete_dims=discrete_dims,
+                max_discrete_values=max_discrete_values,
+                post_processing_func=None,
+                equality_constraints=equality_constraints,
+            )
+            # Dims 0 and 1 kept; dim 2 relaxed
+            self.assertIn(0, dims_kept)
+            self.assertIn(1, dims_kept)
+            self.assertNotIn(2, dims_kept)
+            self.assertIsNotNone(post_processing_func)
+            X = torch.tensor(
+                [0.4, 25.3, 30.7],
+                dtype=dtype,
+                device=self.device,
+            )
+            X_processed = post_processing_func(X)
+            # Dim 1 should NOT be rounded (equality-constrained, kept discrete)
             self.assertAllClose(
                 X_processed[1], torch.tensor(25.3, dtype=dtype, device=self.device)
             )
-            # Dim 2 should be rounded to nearest valid value
+            # Dim 2 should be rounded
             self.assertAllClose(
                 X_processed[2], torch.tensor(31.0, dtype=dtype, device=self.device)
             )