<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def ignored_double_corner( intersection, tangent_s, tangent_t, edge_nodes1, edge_nodes2 ):
 """Check if an intersection is an "ignored" double corner. .. note:: This is a helper used only by :func:`ignored_corner`, which in turn is only used by :func:`classify_intersection`. Helper for :func:`ignored_corner` where both ``s`` and ``t`` are ``0``. Does so by checking if either edge through the ``t`` corner goes through the interior of the other surface. An interior check is done by checking that a few cross products are positive. Args: intersection (.Intersection):
 An intersection to "diagnose". tangent_s (numpy.ndarray):
 The tangent vector (``2 x 1`` array) to the first curve at the intersection. tangent_t (numpy.ndarray):
 The tangent vector (``2 x 1`` array) to the second curve at the intersection. edge_nodes1 (Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]):
 The nodes of the three edges of the first surface being intersected. edge_nodes2 (Tuple[numpy.ndarray, numpy.ndarray, numpy.ndarray]):
 The nodes of the three edges of the second surface being intersected. Returns: bool: Indicates if the corner is to be ignored. """

    # Compute the other edge for the ``s`` surface.
    prev_index = (intersection.index_first - 1) % 3
    prev_edge = edge_nodes1[prev_index]
    alt_tangent_s = _curve_helpers.evaluate_hodograph(1.0, prev_edge)
    # First check if ``tangent_t`` is interior to the ``s`` surface.
    cross_prod1 = _helpers.cross_product(
        tangent_s.ravel(order="F"), tangent_t.ravel(order="F")
    )
    # A positive cross product indicates that ``tangent_t`` is
    # interior to ``tangent_s``. Similar for ``alt_tangent_s``.
    # If ``tangent_t`` is interior to both, then the surfaces
    # do more than just "kiss" at the corner, so the corner should
    # not be ignored.
    if cross_prod1 >= 0.0:
        # Only compute ``cross_prod2`` if we need to.
        cross_prod2 = _helpers.cross_product(
            alt_tangent_s.ravel(order="F"), tangent_t.ravel(order="F")
        )
        if cross_prod2 >= 0.0:
            return False

    # If ``tangent_t`` is not interior, we check the other ``t``
    # edge that ends at the corner.
    prev_index = (intersection.index_second - 1) % 3
    prev_edge = edge_nodes2[prev_index]
    alt_tangent_t = _curve_helpers.evaluate_hodograph(1.0, prev_edge)
    # Change the direction of the "in" tangent so that it points "out".
    alt_tangent_t *= -1.0
    cross_prod3 = _helpers.cross_product(
        tangent_s.ravel(order="F"), alt_tangent_t.ravel(order="F")
    )
    if cross_prod3 >= 0.0:
        # Only compute ``cross_prod4`` if we need to.
        cross_prod4 = _helpers.cross_product(
            alt_tangent_s.ravel(order="F"), alt_tangent_t.ravel(order="F")
        )
        if cross_prod4 >= 0.0:
            return False

    # If neither of ``tangent_t`` or ``alt_tangent_t`` are interior
    # to the ``s`` surface, one of two things is true. Either
    # the two surfaces have no interior intersection (1) or the
    # ``s`` surface is bounded by both edges of the ``t`` surface
    # at the corner intersection (2). To detect (2), we only need
    # check if ``tangent_s`` is interior to both ``tangent_t``
    # and ``alt_tangent_t``. ``cross_prod1`` contains
    # (tangent_s) x (tangent_t), so it's negative will tell if
    # ``tangent_s`` is interior. Similarly, ``cross_prod3``
    # contains (tangent_s) x (alt_tangent_t), but we also reversed
    # the sign on ``alt_tangent_t`` so switching the sign back
    # and reversing the arguments in the cross product cancel out.
    return cross_prod1 > 0.0 or cross_prod3 < 0.0