<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def bezier_value_check(coeffs, s_val, rhs_val=0.0):
 r"""Check if a polynomial in the Bernstein basis evaluates to a value. This is intended to be used for root checking, i.e. for a polynomial :math:`f(s)` and a particular value :math:`s_{\ast}`: Is it true that :math:`f\left(s_{\ast}\right) = 0`? Does so by re-stating as a matrix rank problem. As in :func:`~bezier._algebraic_intersection.bezier_roots`, we can rewrite .. math:: f(s) = (1 - s)^n g\left(\sigma\right) for :math:`\sigma = \frac{s}{1 - s}` and :math:`g\left(\sigma\right)` written in the power / monomial basis. Now, checking if :math:`g\left(\sigma\right) = 0` is a matter of checking that :math:`\det\left(C_g - \sigma I\right) = 0` (where :math:`C_g` is the companion matrix of :math:`g`). Due to issues of numerical stability, we'd rather ask if :math:`C_g - \sigma I` is singular to numerical precision. A typical approach to this using the singular values (assuming :math:`C_g` is :math:`m \times m`) is that the matrix is singular if .. math:: \sigma_m < m \varepsilon \sigma_1 \Longleftrightarrow \frac{1}{\kappa_2} < m \varepsilon (where :math:`\kappa_2` is the 2-norm condition number of the matrix). Since we also know that :math:`\kappa_2 < \kappa_1`, a stronger requirement would be .. math:: \frac{1}{\kappa_1} < \frac{1}{\kappa_2} < m \varepsilon. This is more useful since it is **much** easier to compute the 1-norm condition number / reciprocal condition number (and methods in LAPACK are provided for doing so). Args: coeffs (numpy.ndarray):
 A 1D array of coefficients in the Bernstein basis representing a polynomial. s_val (float):
 The value to check on the polynomial: :math:`f(s) = r`. rhs_val (Optional[float]):
 The value to check that the polynomial evaluates to. Defaults to ``0.0``. Returns: bool: Indicates if :math:`f\left(s_{\ast}\right) = r` (where :math:`s_{\ast}` is ``s_val`` and :math:`r` is ``rhs_val``). """

    if s_val == 1.0:
        return coeffs[-1] == rhs_val

    shifted_coeffs = coeffs - rhs_val
    sigma_coeffs, _, effective_degree = _get_sigma_coeffs(shifted_coeffs)
    if effective_degree == 0:
        # This means that all coefficients except the ``(1 - s)^n``
        # term are zero, so we have ``f(s) = C (1 - s)^n``. Since we know
        # ``s != 1``, this can only be zero if ``C == 0``.
        return shifted_coeffs[0] == 0.0

    sigma_val = s_val / (1.0 - s_val)
    lu_mat, one_norm = lu_companion(-sigma_coeffs[::-1], sigma_val)
    rcond = _reciprocal_condition_number(lu_mat, one_norm)
    # "Is a root?" IFF Singular IF ``1/kappa_1 < m epsilon``
    return rcond < effective_degree * _SINGULAR_EPS