docs: def check_param_list_validity(self, param_list):
          """
          Parameters
          ----------
          param_list : list.
              Contains four elements, each being a numpy array. Either all of the
              arrays should be 1D or all of the arrays should be 2D. If 2D, the
              arrays should have the same number of columns. Each column being a
              particular set of parameter values that one wants to predict with.
              The first element in the list should be the index coefficients. The
              second element should contain the 'outside' intercept parameters if
              there are any, or None otherwise. The third element should contain
              the shape parameters if there are any or None otherwise. The fourth
              element should contain the nest coefficients if there are any or
              None otherwise. Default == None.
  
          Returns
          -------
          None. Will check whether `param_list` and its elements meet all
          requirements specified above and required for correct calculation of
          the probabilities to be predicted.
          """
          if param_list is None:
              return None
  
          # Make sure there are four elements in param_list
          check_type_and_size_of_param_list(param_list, 4)
  
          # Make sure each element in the list is a numpy array or is None
          check_type_of_param_list_elements(param_list)
  
          # Make sure each array in param_list has the same number of dimensions
          check_dimensional_equality_of_param_list_arrays(param_list)
  
          # If using 2D arrays, ensure each array has the same number of columns.
          if len(param_list[0].shape) == 2:
              check_num_columns_in_param_list_arrays(param_list)
  
          # Make sure each array has the correct number of elements
          num_index_coefs = len(self.ind_var_names)
  
          check_num_rows_of_parameter_array(param_list[0],
                                            num_index_coefs,
                                            'param_list[0]')
  
          if param_list[1] is not None:
              num_intercepts = (0 if self.intercept_names is None else
                                len(self.intercept_names))
  
              check_num_rows_of_parameter_array(param_list[1],
                                                num_intercepts,
                                                'param_list[1]')
  
          if param_list[2] is not None:
              num_shapes = (0 if self.shape_names is None else
                            len(self.shape_names))
  
              check_num_rows_of_parameter_array(param_list[2],
                                                num_shapes,
                                                'param_list[2]')
  
          if param_list[3] is not None:
              num_nests = (0 if self.nest_names is None else
                           len(self.nest_names))
  
              check_num_rows_of_parameter_array(param_list[3],
                                                num_nests,
                                                'param_list[3]')
  
          return None