human
Complete the below
def _populate_var_to_app_to_idx(outputs, wrt, consider_constant):

    ''''Helper function for grad function.
    Parameters
    outputs
    a list of variables we want to take gradients of
    wrt
    a list of variables we want to take the gradient with
    respect to.
    consider_constant
    a list of variables not to backpropagate through.
    Returns
    var_to_app_to_idx:
    A dictionary mapping a variable to a second dictionary.
    The second dictionary maps apply nodes acting on this
    variable to the variable\'s index in the apply node\'s
    input list.
    This dictionary will only contain variables that
    meet two criteria:
    1) The elements of at least one output are a
    function of the elements of the variable
    2) The elements of the variable are a function of the
    elements of at least one member of wrt.
    This set is exactly the set of variables that connect
    the variables in wrt to the cost being differentiated.
    (A variable in consider_constant is not a function of
    anything)'
    '''
assistant
#Here is the Python code you requested.
    if (consider_constant is None):
        consider_constant = []
    else:
        try:
            iter(consider_constant)
        except TypeError:
            raise TypeError(('consider_constant    must    be    an    iterable    collection,    got    ' + str(type(consider_constant))))
        for elem in consider_constant:
            if (not isinstance(elem, gof.Variable)):
                raise TypeError(('Elements    of    consider_constant    must    be    variables,    but    got    ' + str(type(elem))))
    var_to_app_to_idx = OrderedDict()
    accounted_for = set([])
    def account_for(var):
        if (var in accounted_for):
            return
        accounted_for.add(var)
        if (var in consider_constant):
            return
        if (var.owner is not None):
            app = var.owner
            connection_pattern = _node_to_pattern(app)
            var_idx = app.outputs.index(var)
            for (i, ipt) in enumerate(app.inputs):
                if (not connection_pattern[i][var_idx]):
                    continue
                if (ipt not in var_to_app_to_idx):
                    var_to_app_to_idx[ipt] = OrderedDict()
                app_to_idx = var_to_app_to_idx[ipt]
                if (app not in app_to_idx):
                    app_to_idx[app] = []
                idx = app_to_idx[app]
                if (i not in idx):
                    idx.append(i)
                account_for(ipt)
    for output in outputs:
        account_for(output)
    visited = set([])
    def visit(var):
        if (var in visited):
            return
        if (var not in var_to_app_to_idx):
            return
        visited.add(var)
        nodes = var_to_app_to_idx[var]
        for node in nodes:
            connection_pattern = _node_to_pattern(node)
            for idx in nodes[node]:
                for (ii, output) in enumerate(node.outputs):
                    if connection_pattern[idx][ii]:
                        visit(output)
    for elem in wrt:
        visit(elem)
    orig_vars =...