human
Here's a good function header given the following:
I wrote the below code

    def _is_univariate(f):
        "Returns    True    if    'f'    is    univariate    in    its    last    variable.    "
        for monom in f.monoms():
            if any((m for m in monom[:(-1)])):
                return False
        return True
    def _subs_root(f, gen, zero):
        'Replace    generator    with    a    root    so    that    the    result    is    nice.    '
        p = f.as_expr({gen: zero})
        if (f.degree(gen) >= 2):
            p = p.expand(deep=False)
        return p
    def _solve_reduced_system(system, gens, entry=False):
        'Recursively    solves    reduced    polynomial    systems.    '
        if (len(system) == len(gens) == 1):
            zeros = list(roots(system[0], gens[(-1)]).keys())
            return [(zero,) for zero in zeros]
        basis = groebner(system, gens, polys=True)
        if ((len(basis) == 1) and basis[0].is_ground):
            if (not entry):
                return []
            else:
                return None
        univariate = list(filter(_is_univariate, basis))
        if (len(univariate) == 1):
            f = univariate.pop()
        else:
            raise NotImplementedError('only    zero-dimensional    systems    supported    (finite    number    of    solutions)')
        gens = f.gens
        gen = gens[(-1)]
        zeros = list(roots(f.ltrim(gen)).keys())
        if (not zeros):
            return []
        if (len(basis) == 1):
            return [(zero,) for zero in zeros]
        solutions = []
        for zero in zeros:
            new_system = []
            new_gens = gens[:(-1)]
            for b in basis[:(-1)]:
                eq = _subs_root(b, gen, zero)
                if (eq is not S.Zero):
                    new_system.append(eq)
            for solution in _solve_reduced_system(new_system, new_gens):
                solutions.append((solution + (zero,)))
        return solutions
    try:
        result = _solve_reduced_system(polys, opt.gens, entry=True)
    except CoercionFailed:
        raise...

What's a good function header?
assistant
#Here's a good function header.

def solve_generic(polys, opt):