Update documentation and error handling for inter-point constraints (#3003)

Summary:
## Motivation

This PR improves the documentation and error handling when attempting to use inter-point constraints within `optimize_acqf_mixed` which is not supported. It implements the solution to #2996 discussed in this issue.

### Have you read the [Contributing Guidelines on pull requests](https://github.com/pytorch/botorch/blob/main/CONTRIBUTING.md#pull-requests)?

Yes.

Pull Request resolved: #3003

Test Plan:
I verified my code by ensuring that the example posted in #2996 raises an error message. I did not add any tests, but would be happy to turn that example into a dedicated test if being pointed to the correct place for doing so.

EDIT: A minimal test has been added in 92140e9

## Related PRs

None.

Reviewed By: saitcakmak

Differential Revision: D81792795

Pulled By: Balandat

fbshipit-source-id: d54a7d225170f17049ea588d699e4345222afb4c

Author: AVHopp

botorch/optim/optimize.py

@@ -1055,6 +1055,9 @@ def optimize_acqf_mixed(
     For q > 1 this function always performs sequential greedy optimization (with
     proper conditioning on generated candidates).
 
+    NOTE: This method does not support the kind of "inter-point constraints" that
+    are supported by `optimize_acqf()`.
+
     Args:
         acq_function: An AcquisitionFunction
         bounds: A `2 x d` tensor of lower and upper bounds for each column of `X`
@@ -1076,19 +1079,12 @@ def optimize_acqf_mixed(
             `\sum_i (X[indices[i]] * coefficients[i]) = rhs`
         nonlinear_inequality_constraints: A list of tuples representing the nonlinear
             inequality constraints. The first element in the tuple is a callable
-            representing a constraint of the form `callable(x) >= 0`. In case of an
-            intra-point constraint, `callable()`takes in an one-dimensional tensor of
-            shape `d` and returns a scalar. In case of an inter-point constraint,
-            `callable()` takes a two dimensional tensor of shape `q x d` and again
-            returns a scalar. The second element is a boolean, indicating if it is an
+            representing a constraint of the form `callable(x) >= 0`. The `callable()`
+            takes in an one-dimensional tensor of shape `d` and returns a scalar.
+            The second element is a boolean, indicating if it is an
             intra-point or inter-point constraint (`True` for intra-point. `False` for
-            inter-point). For more information on intra-point vs inter-point
-            constraints, see the docstring of the `inequality_constraints` argument to
-            `optimize_acqf()`. The constraints will later be passed to the scipy
-            solver. You need to pass in `batch_initial_conditions` in this case.
-            Using non-linear inequality constraints also requires that `batch_limit`
-            is set to 1, which will be done automatically if not specified in
-            `options`.
+            inter-point). Since inter-point constraints are not supported by this
+            method, this has to be `True` and raises an error if being `False`.
         post_processing_func: A function that post-processes an optimization
             result appropriately (i.e., according to `round-trip`
             transformations).
@@ -1123,6 +1119,27 @@ def optimize_acqf_mixed(
         - a tensor of associated acquisition values of dim `num_restarts`
             if `return_best_only=False` else a scalar acquisition value.
     """
+    const_err_message = (
+        "Inter-point constraints are not supported for sequential optimization. "
+        "But the {}th {} constraint is defined as inter-point."
+    )
+    # Check for existence of inter-point constraints
+    # Code adapted from _validate_sequential_inputs
+    if inequality_constraints is not None:
+        for i, (indices, _, _) in enumerate(inequality_constraints):
+            if indices.ndim > 1:
+                raise UnsupportedError(const_err_message.format(i, "linear inequality"))
+    if equality_constraints is not None:
+        for i, (indices, _, _) in enumerate(equality_constraints):
+            if indices.ndim > 1:
+                raise UnsupportedError(const_err_message.format(i, "linear equality"))
+    if nonlinear_inequality_constraints is not None:
+        for i, (_, intra_point) in enumerate(nonlinear_inequality_constraints):
+            if not intra_point:
+                raise UnsupportedError(
+                    const_err_message.format(i, "non-linear inequality")
+                )
+
     if not return_best_only and q > 1:
         raise NotImplementedError("`return_best_only=False` is only supported for q=1.")
 
@@ -1283,8 +1300,7 @@ def optimize_acqf_discrete(
     """
     if isinstance(acq_function, OneShotAcquisitionFunction):
         raise UnsupportedError(
-            "Discrete optimization is not supported for"
-            "one-shot acquisition functions."
+            "Discrete optimization is not supported for one-shot acquisition functions."
         )
     if X_avoid is not None and unique:
         choices = _filter_invalid(X=choices, X_avoid=X_avoid)

test/optim/test_optimize.py

@@ -1649,15 +1649,18 @@ def test_optimize_acqf_list(self, mock_optimize_acqf, mock_optimize_acqf_mixed):
                 mock_optimize_acqf_mixed.side_effect = side_effect
                 orig_candidates = candidate_rvs[0].clone()
                 # Wrap the set_X_pending method for checking that call arguments
-                with mock.patch.object(
-                    MockAcquisitionFunction,
-                    "set_X_pending",
-                    wraps=mock_acq_function_1.set_X_pending,
-                ) as mock_set_X_pending_1, mock.patch.object(
-                    MockAcquisitionFunction,
-                    "set_X_pending",
-                    wraps=mock_acq_function_2.set_X_pending,
-                ) as mock_set_X_pending_2:
+                with (
+                    mock.patch.object(
+                        MockAcquisitionFunction,
+                        "set_X_pending",
+                        wraps=mock_acq_function_1.set_X_pending,
+                    ) as mock_set_X_pending_1,
+                    mock.patch.object(
+                        MockAcquisitionFunction,
+                        "set_X_pending",
+                        wraps=mock_acq_function_2.set_X_pending,
+                    ) as mock_set_X_pending_2,
+                ):
                     candidates, _ = optimize_acqf_list(
                         acq_function_list=mock_acq_function_list[:num_acqf],
                         bounds=bounds,
@@ -1934,6 +1937,77 @@ def test_optimize_acqf_mixed_empty_ff(self):
                 raw_samples=10,
             )
 
+    def test_optimize_acqf_mixed_inter_point_inequality_constraints(self):
+        mock_acq_function = MockAcquisitionFunction()
+        with self.assertRaisesRegex(
+            UnsupportedError,
+            expected_regex="Inter-point constraints are not supported for sequential "
+            "optimization. But the 0th linear inequality constraint is defined "
+            "as inter-point.",
+        ):
+            optimize_acqf_mixed(
+                acq_function=mock_acq_function,
+                q=1,
+                fixed_features_list=[{0: 0.0}],
+                bounds=torch.stack([torch.zeros(3), 4 * torch.ones(3)]),
+                num_restarts=2,
+                raw_samples=10,
+                inequality_constraints=[
+                    (  # Inter-point constraint: X[0, 0] - X[1, 0] >= 0
+                        torch.tensor([[0, 0], [1, 0]], dtype=torch.long),
+                        torch.tensor([1.0, -1.0]),
+                        0.0,
+                    )
+                ],
+            )
+
+    def test_optimize_acqf_mixed_inter_point_equality_constraints(self):
+        mock_acq_function = MockAcquisitionFunction()
+        with self.assertRaisesRegex(
+            UnsupportedError,
+            expected_regex="Inter-point constraints are not supported for sequential "
+            "optimization. But the 0th linear equality constraint is defined "
+            "as inter-point.",
+        ):
+            optimize_acqf_mixed(
+                acq_function=mock_acq_function,
+                q=1,
+                fixed_features_list=[{0: 0.0}],
+                bounds=torch.stack([torch.zeros(3), 4 * torch.ones(3)]),
+                num_restarts=2,
+                raw_samples=10,
+                equality_constraints=[
+                    (  # Inter-point constraint: X[0, 0] - X[1, 0] == 0
+                        torch.tensor([[0, 0], [1, 0]], dtype=torch.long),
+                        torch.tensor([1.0, -1.0]),
+                        0.0,
+                    )
+                ],
+            )
+
+    def test_optimize_acqf_mixed_inter_point_nonlinear_constraints(self):
+        mock_acq_function = MockAcquisitionFunction()
+        with self.assertRaisesRegex(
+            UnsupportedError,
+            expected_regex="Inter-point constraints are not supported for sequential "
+            "optimization. But the 0th non-linear inequality constraint is defined "
+            "as inter-point.",
+        ):
+            optimize_acqf_mixed(
+                acq_function=mock_acq_function,
+                q=1,
+                fixed_features_list=[{0: 0.0}],
+                bounds=torch.stack([torch.zeros(3), 4 * torch.ones(3)]),
+                num_restarts=2,
+                raw_samples=10,
+                nonlinear_inequality_constraints=[
+                    (  # Inter-point constraint: sum of all points >= 0
+                        lambda X: X.sum(dim=(-1, -2)),
+                        False,  # False indicates inter-point constraint
+                    )
+                ],
+            )
+
     def test_optimize_acqf_mixed_return_best_only_q2(self):
         mock_acq_function = MockAcquisitionFunction()
         with self.assertRaisesRegex(