docs: def sample_state_vector(state: np.ndarray,
                          indices: List[int],
                          repetitions: int=1) -> np.ndarray:
      """Samples repeatedly from measurements in the computational basis.
  
      Note that this does not modify the passed in state.
  
      Args:
          state: The multi-qubit wavefunction to be sampled. This is an array of
              2 to the power of the number of qubit complex numbers, and so
              state must be of size ``2**integer``.  The state can be a vector of
              size ``2**integer`` or a tensor of shape ``(2, 2, ..., 2)``.
          indices: Which qubits are measured. The state is assumed to be supplied
              in big endian order. That is the xth index of v, when expressed as
              a bitstring, has its largest values in the 0th index.
          repetitions: The number of times to sample the state.
  
      Returns:
          Measurement results with True corresponding to the ``|1⟩`` state.
          The outer list is for repetitions, and the inner corresponds to
          measurements ordered by the supplied qubits. These lists
          are wrapped as an numpy ndarray.
  
      Raises:
          ValueError: ``repetitions`` is less than one or size of ``state`` is not
              a power of 2.
          IndexError: An index from ``indices`` is out of range, given the number
              of qubits corresponding to the state.
      """
      if repetitions < 0:
          raise ValueError('Number of repetitions cannot be negative. Was {}'
                           .format(repetitions))
      num_qubits = _validate_num_qubits(state)
      _validate_indices(num_qubits, indices)
  
      if repetitions == 0 or len(indices) == 0:
          return np.zeros(shape=(repetitions, len(indices)))
  
      # Calculate the measurement probabilities.
      probs = _probs(state, indices, num_qubits)
  
      # We now have the probability vector, correctly ordered, so sample over
      # it. Note that we us ints here, since numpy's choice does not allow for
      # choosing from a list of tuples or list of lists.
      result = np.random.choice(len(probs), size=repetitions, p=probs)
      # Convert to bools and rearrange to match repetition being the outer list.
      return np.transpose([(1 & (result >> i)).astype(np.bool) for i in
                           range(len(indices))])