human
What is a the Python code you requested given the following:
Complete the below
def build_computational_graph(outputs, remove_split=True, variable_style=_var_style, function_style=_func_style, rankdir='TB', remove_variable=False, show_name=True):

    ''''Builds a graph of functions and variables backward-reachable from outputs.
    Args:
    outputs(list): nodes from which the graph is constructed.
    Each element of outputs must be either :class:`Variable`
    object, :class:`VariableNode object, or :class:`Function` object.
    remove_split(bool): It must be ``True``. This argument is left for
    backward compatibility.
    variable_style(dict): Dot node style for variable.
    Possible keys are \'shape\', \'color\', \'fillcolor\', \'style\', and etc.
    function_style(dict): Dot node style for function.
    rankdir (str): Direction of the graph that must be
    TB (top to bottom), BT (bottom to top), LR (left to right)
    or RL (right to left).
    remove_variable (bool): If ``True``, :class:`~chainer.Variable` s are
    removed from the resulting computational graph. Only
    :class:`~chainer.Function` s are shown in the output.
    show_name (bool): If ``True``, the ``name`` attribute of each node is
    added to the label of the node. Default is ``True``.
    Returns:
    ComputationalGraph: A graph consisting of nodes and edges that
    are backward-reachable from at least one of ``outputs``.
    If ``unchain_backward`` was called in some variable in the
    computational graph before this function, backward step is
    stopped at this variable.
    For example, suppose that computational graph is as follows::
    |--> f ---> y
    x --+
    |--> g ---> z
    Let ``outputs = [y, z]``.
    Then the full graph is emitted.
    Next, let ``outputs = [y]``. Note that ``z`` and ``g``
    are not backward-reachable from ``y``.
    The resulting graph would be following::
    x ---> f ---> y
    See :class:`TestGraphBuilder` for details.
    .. note::
    The default behavior of :class:`~chainer.ComputationalGraph` has been
    changed from v1.23.0, so that it ouputs the richest representation of
    a graph as default, namely, styles are set and names of functions and
    variables are shown. To reproduce the same result as previous versions
    (<=...'''
assistant
#Here is the Python code you requested.
    if (not remove_split):
        raise ValueError('remove_split=False    is    not    supported    anymore')
    cands = []
    seen_edges = set()
    nodes = set()
    push_count = [0]
    def add_cand(cand):
        heapq.heappush(cands, ((- cand.rank), push_count[0], cand))
        push_count[0] += 1
    for o in outputs:
        if isinstance(o, variable.Variable):
            o = o.node
        add_cand(o)
        nodes.add(o)
    while cands:
        (_, _, cand) = heapq.heappop(cands)
        if isinstance(cand, variable.VariableNode):
            creator = cand.creator_node
            if ((creator is not None) and ((creator, cand) not in seen_edges)):
                add_cand(creator)
                seen_edges.add((creator, cand))
                nodes.add(creator)
                nodes.add(cand)
        elif isinstance(cand, function_node.FunctionNode):
            for input_ in cand.inputs:
                if ((input_ is not cand) and ((input_, cand) not in seen_edges)):
                    add_cand(input_)
                    seen_edges.add((input_, cand))
                    nodes.add(input_)
                    nodes.add(cand)
    return ComputationalGraph(list(nodes), list(seen_edges), variable_style, function_style, rankdir, remove_variable, show_name)