class_docstr: The finite discrete distribution.
  
  The FiniteDiscrete distribution is parameterized by either probabilities or
  log-probabilities of a set of `K` possible outcomes, which is defined by
  a strictly ascending list of `K` values.
  
  Note: log_prob, prob, cdf, mode, and entropy are differentiable with respect
  to `logits` or `probs` but not with respect to `outcomes`.
  
  #### Mathematical Details
  
  The probability mass function (pmf) is,
  
  ```none
  pmf(x; pi, qi) = prod_j pi_j**[x == qi_j]
  ```
  
  #### Examples
  
  ```python
  
  # Initialize a discrete distribution with 4 possible outcomes and the 2nd
  # outcome being most likely.
  dist = FiniteDiscrete([1., 2., 4., 8.], probs=[0.1, 0.4, 0.3, 0.2])
  dist.prob(2.)
  # ==> 0.4
  
  # Using logits to initialize a discrete distribution with 4 possible outcomes
  # and the 2nd outcome being most likely.
  dist = FiniteDiscrete([1., 2., 4., 8.], logits=np.log([0.1, 0.4, 0.3, 0.2]))
  dist.prob(2.)
  # ==> 0.4
  ```
code: def _parameter_control_dependencies(self, is_init):
      assertions = []
  
      # For `logits` and `probs`, we only want to have an assertion on what the
      # user actually passed. For now, we access the underlying categorical's
      # _logits and _probs directly. After the 2019-10-01 deprecation, it would
      # also work to use .logits() and .probs().
      logits = self._categorical._logits
      probs = self._categorical._probs
      outcomes = self._outcomes
      validate_args = self._validate_args
  
      # Build all shape and dtype checks during the `is_init` call.
      if is_init:
  
          def validate_equal_last_dim(tensor_a, tensor_b, message):
              event_size_a = tf.compat.dimension_value(
                  tensor_a.shape[-1]
              )
              event_size_b = tf.compat.dimension_value(
                  tensor_b.shape[-1]
              )
              if event_size_a is not None and event_size_b is not None:
                  if event_size_a != event_size_b:
                      raise ValueError(message)
              elif validate_args:
                  return assert_util.assert_equal(
                      tf.shape(tensor_a)[-1],
                      tf.shape(tensor_b)[-1],
                      message=message,
                  )
  
          message = "Size of outcomes must be greater than 0."
          if tensorshape_util.num_elements(outcomes.shape) is not None:
              if tensorshape_util.num_elements(outcomes.shape) == 0:
                  raise ValueError(message)
          elif validate_args:
              assertions.append(
                  tf.assert_greater(
                      tf.size(outcomes), 0, message=message
                  )
              )
  
          if logits is not None:
              maybe_assert = validate_equal_last_dim(
                  outcomes,
                  # pylint: disable=protected-access
                  self._categorical._logits,
                  # pylint: enable=protected-access
                  message="Last dimension of outcomes and logits must be equal size.",
              )
              if maybe_assert:
                  assertions.append(maybe_assert)
  
          if probs is not None:
              maybe_assert = validate_equal_last_dim(
                  outcomes,
                  probs,
                  message="Last dimension of outcomes and probs must be equal size.",
              )
              if maybe_assert:
                  assertions.append(maybe_assert)
  
          message = "Rank of outcomes must be 1."
          ndims = tensorshape_util.rank(outcomes.shape)
          if ndims is not None:
              if ndims != 1:
                  raise ValueError(message)
          elif validate_args:
              assertions.append(
                  assert_util.assert_rank(outcomes, 1, message=message)
              )
  
      if not validate_args:
          assert not assertions  # Should never happen.
          return []
  
      if is_init != tensor_util.is_ref(outcomes):
          assertions.append(
              assert_util.assert_equal(
                  tf.math.is_strictly_increasing(outcomes),
                  True,
                  message="outcomes is not strictly increasing.",
              )
          )
  
      return assertions
  
imports: import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import ascending
  from tensorflow_probability.python.bijectors import softmax_centered
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.distributions import categorical
  from tensorflow_probability.python.distributions import distribution
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import distribution_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import reparameterization
  from tensorflow_probability.python.internal import tensor_util
  from tensorflow_probability.python.internal import tensorshape_util
label_desc: Use image node_id 19 for calling the FiniteDiscrete obj's underlying member method code with example usage: obj._parameter_control_dependencies(is_init) and returns: assertions, list, assert_util