code: def symbolic_bounds(min, max, variables=None):
      """convert min,max to symbolic string for use in mystic's constraint parser
  
      Args:
          min (list[float]): list of lower bounds
          max (list[float]): list of upper bounds
          variables (list[str], default=None): list of variable names
  
      Notes:
          if ``variables=None``, then ``variables = ['x0', 'x1', ...]``;
          if ``variables='y'``, then ``variables = ['y0', 'y1', ...]``;
          otherwise use the explicit list of variables provided.
  
      Examples:
          >>> eqn = symbolic_bounds(min=[-10,None], max=[10,69], variables='y')
          >>> print(eqn)
          y0 >= -10.0
          y0 <= 10.0
          y1 <= 69.0
  
          >>> eqn = symbolic_bounds(min=[-1,-2], max=[1,2], variables=list('AB'))
          >>> print(eqn)
          A >= -1.0
          B >= -2.0
          A <= 1.0
          B <= 2.0"""
      inf = float("inf")
      if len(min) != len(max):
          raise ValueError("length of min and max are not consistent")
      # when 'some' of the bounds are given as 'None', replace with default
      for i in range(len(min)):
          if min[i] is None:
              min[i] = -inf
          if max[i] is None:
              max[i] = inf
      min = asarray(min)
      max = asarray(max)
      if _any((min > max), 0):
          raise ValueError(
              "each min[i] must be <= the corresponding max[i]"
          )
  
      if variables is None:
          variables = "x"
      has_base = isinstance(variables, str)
      lo = "%s >= %s"
      hi = "%s <= %s"
      if has_base:
          lo = variables + lo
          hi = variables + hi
          imin = enumerate(min)
          imax = enumerate(max)
      else:
          if len(min) != len(variables):
              raise ValueError(
                  "variables is not consistent with bounds"
              )
          imin = zip(variables, min)
          imax = zip(variables, max)
      # NOTE: we are stripping off leading zeros
      lo = "\n".join(
          lo % (i, str(float(j)).lstrip("0"))
          for (i, j) in imin
          if j != -inf
      )
      hi = "\n".join(
          hi % (i, str(float(j)).lstrip("0"))
          for (i, j) in imax
          if j != inf
      )
      return "\n".join([lo, hi]).strip()
  
imports: from numpy import ndarray, asarray, any
  from mystic._symbolic import solve
  from mystic.tools import list_or_tuple_or_ndarray, flatten
label_desc: Use image node_id 2 for calling a global function with example usage: symbolic_bounds(min, max, variables) and returns: str