docs: def check_reduced_horizontal_grid(self, ds):
          """
          5.3 A "reduced" longitude-latitude grid is one in which the points are
          arranged along constant latitude lines with the number of points on a
          latitude line decreasing toward the poles.
  
          Recommend that this type of gridded data be stored using the compression
          scheme described in Section 8.2, "Compression by Gathering". The
          compressed latitude and longitude auxiliary coordinate variables are
          identified by the coordinates attribute.
  
          :param netCDF4.Dataset ds: An open netCDF dataset
          :rtype: list
          :return: List of results
          """
          ret_val = []
          # Create a set of coordinate varaibles defining `compress`
          lats = set(cfutil.get_latitude_variables(ds))
          lons = set(cfutil.get_longitude_variables(ds))
  
          for name in self._find_geophysical_vars(ds):
              coords = getattr(ds.variables[name], 'coordinates', None)
              axis_map = cfutil.get_axis_map(ds, name)
              # If this variable has no coordinate that defines compression
              if 'C' not in axis_map:
                  continue
  
              valid_rgrid = TestCtx(BaseCheck.HIGH, self.section_titles['5.3'])
              # Make sure reduced grid features define coordinates
              valid_rgrid.assert_true(isinstance(coords, basestring) and coords,
                                      "reduced grid feature {} must define coordinates attribute"
                                      "".format(name))
              # We can't check anything else if there are no defined coordinates
              if not isinstance(coords, basestring) and coords:
                  continue
  
              coord_set = set(coords.split())
  
              # Make sure it's associated with valid lat and valid lon
              valid_rgrid.assert_true(len(coord_set.intersection(lons)) > 0,
                                      '{} must be associated with a valid longitude coordinate'.format(name))
              valid_rgrid.assert_true(len(coord_set.intersection(lats)) > 0,
                                      '{} must be associated with a valid latitude coordinate'.format(name))
              valid_rgrid.assert_true(len(axis_map['C']) == 1,
                                      '{} can not be associated with more than one compressed coordinates: '
                                      '({})'.format(name, ', '.join(axis_map['C'])))
  
              for compressed_coord in axis_map['C']:
                  coord = ds.variables[compressed_coord]
                  compress = getattr(coord, 'compress', None)
                  valid_rgrid.assert_true(isinstance(compress, basestring) and compress,
                                          "compress attribute for compression coordinate {} must be a non-empty string"
                                          "".format(compressed_coord))
                  if not isinstance(compress, basestring):
                      continue
                  for dim in compress.split():
                      valid_rgrid.assert_true(dim in ds.dimensions,
                                              "dimension {} referenced by {}:compress must exist"
                                              "".format(dim, compressed_coord))
              ret_val.append(valid_rgrid.to_result())
  
          return ret_val