code: def _reduce_inequalities(inequalities, symbols):
      # helper for reduce_inequalities
  
      poly_part, abs_part = {}, {}
      other = []
  
      for inequality in inequalities:
          expr, rel = inequality.lhs, inequality.rel_op  # rhs is 0
  
          # check for gens using atoms which is more strict than free_symbols to
          # guard against EX domain which won't be handled by
          # reduce_rational_inequalities
          gens = expr.atoms(Symbol)
  
          if len(gens) == 1:
              gen = gens.pop()
          else:
              common = expr.free_symbols & symbols
              if len(common) == 1:
                  gen = common.pop()
                  other.append(
                      _solve_inequality(Relational(expr, 0, rel), gen)
                  )
                  continue
              else:
                  raise NotImplementedError(
                      filldedent(
                          """
                      inequality has more than one symbol of interest.
                      """
                      )
                  )
  
          if expr.is_polynomial(gen):
              poly_part.setdefault(gen, []).append((expr, rel))
          else:
              components = expr.find(
                  lambda u: u.has(gen)
                  and (
                      u.is_Function or u.is_Pow and not u.exp.is_Integer
                  )
              )
              if components and all(
                  isinstance(i, Abs) for i in components
              ):
                  abs_part.setdefault(gen, []).append((expr, rel))
              else:
                  other.append(
                      _solve_inequality(Relational(expr, 0, rel), gen)
                  )
  
      poly_reduced = [
          reduce_rational_inequalities([exprs], gen)
          for gen, exprs in poly_part.items()
      ]
      abs_reduced = [
          reduce_abs_inequalities(exprs, gen)
          for gen, exprs in abs_part.items()
      ]
  
      return And(*(poly_reduced + abs_reduced + other))
  
imports: import itertools
  from sympy.calculus.util import continuous_domain, periodicity, function_range
  from sympy.core import sympify
  from sympy.core.exprtools import factor_terms
  from sympy.core.relational import Relational, Lt, Ge, Eq
  from sympy.core.symbol import Symbol, Dummy
  from sympy.sets.sets import Interval, FiniteSet, Union, Intersection
  from sympy.core.singleton import S
  from sympy.core.function import expand_mul
  from sympy.functions.elementary.complexes import Abs
  from sympy.logic import And
  from sympy.polys import Poly, PolynomialError, parallel_poly_from_expr
  from sympy.polys.polyutils import _nsort
  from sympy.solvers.solveset import solvify, solveset
  from sympy.utilities.iterables import sift, iterable
  from sympy.utilities.misc import filldedent
label_desc: Use image node_id 10 for calling a global function with example usage: _reduce_inequalities(inequalities, symbols) and returns: And