class_docstr: A class for partitioning the (non-)dominated space into hyper-cells.
  
  Note: this assumes maximization. Internally, it multiplies outcomes by -1
  and performs the decomposition under minimization.
  
  This class is abstract to support to two applications of Alg 1 from
  [Lacour17]_: 1) partitioning the space that is dominated by the Pareto
  frontier and 2) partitioning the space that is not dominated by the
  Pareto frontier.
  
  :meta private:
docstr: Update non-dominated front and decomposition.
  
  Args:
      Y: A `(batch_shape) x n x m`-dim tensor of new, incremental outcomes.
code: def update(self, Y: Tensor) -> None:
      r"""Update non-dominated front and decomposition.
  
      Args:
          Y: A `(batch_shape) x n x m`-dim tensor of new, incremental outcomes.
      """
      if self._update_neg_Y(Y=Y):
          self.reset()
      else:
          if (
              self.num_outcomes == 2
              or self._neg_pareto_Y.shape[-2] == 0
          ):
              # If there are two objective, recompute the box decomposition
              # because the partitions can be computed analytically.
              # If the current pareto set has no points, recompute the box
              # decomposition.
              self.reset()
          else:
              # only include points that are better than the reference point
              better_than_ref = (Y > self.ref_point).all(dim=-1)
              Y = Y[better_than_ref]
              Y_all = torch.cat([self._neg_pareto_Y, -Y], dim=-2)
              pareto_mask = is_non_dominated(-Y_all)
              # determine the number of points in Y that are Pareto optimal
              num_new_pareto = pareto_mask[-Y.shape[-2] :].sum()
              self._neg_pareto_Y = Y_all[pareto_mask]
              if num_new_pareto > 0:
                  # update local upper bounds for the minimization problem
                  (
                      self._U,
                      self._Z,
                  ) = update_local_upper_bounds_incremental(
                      # this assumes minimization
                      new_pareto_Y=self._neg_pareto_Y[-num_new_pareto:],
                      U=self._U,
                      Z=self._Z,
                  )
                  # use the negative local upper bounds as the new pareto
                  # frontier for the minimization problem and perform
                  # box decomposition on dominated space.
                  self._get_partitioning()
  
imports: from __future__ import annotations
  from abc import ABC, abstractmethod
  from typing import Optional
  import torch
  from botorch.exceptions.errors import BotorchError
  from botorch.utils.multi_objective.box_decompositions.utils import _expand_ref_point, _pad_batch_pareto_frontier, update_local_upper_bounds_incremental
  from botorch.utils.multi_objective.pareto import is_non_dominated
  from torch import Tensor
  from torch.nn import Module
label_desc: Use image node_id 2 for calling the FastPartitioning obj's underlying member method code with example usage: obj.update(Y) without return types