A trictionary is a pair of tree k and v. They have identical structure: each node in k has a corresponding node in v. The labels in k are called keys. Each key may be the label for multiple nodes in k, and the values for that key are the labels of all the corresponding nodes in v. A lookup function returns one of the values for a key. Specifically, a lookup function for a node in k is a function that takes v as an argument and returns the label for the corresponding node in v. Implement the generator function lookups, which takes as input a tree k and a key. It yields all lookup functions for nodes in k that have key as their label, the functions could be yielded in any order.

Sure, here's the implementation of the generator function `lookups` in Python:

def lookups(k, key):
    """
    Given a tree k and a key, yield all lookup functions for nodes in k that have key as their label.
    """
    if k.label == key:
        yield lambda v: v.label
    for child_k, child_v in zip(k.children, v.children):
        yield from lookups(child_k, key)
        yield from lookups(child_v, key)

This function checks if the label of the current node in `k` matches the given `key`. If it does, it yields a lambda function that takes in `v` and returns the label of the corresponding node in `v`. If not, it recursively calls `lookups` on all the children of `k` and `v`. The `yield from` keyword is used to yield all the lookup functions returned by the recursive calls.

Note that this assumes that the `Tree` class has a `label` attribute that stores the label of the node, and a `children` attribute that stores a list of child nodes.