Implementing a faster inbound neighbour similarity in Networkx
"Jaccard coefficient", not "Jacard" or "Jacquard": it's named after Paul Jaccard.
There are no docstrings. What do these functions do? What do they return?
The results of these functions depend on the global variable G. If you ever needed to generalize your program to operate on more than one graph at a time this dependency would become very inconvenient. The functions ought to either take the graph as an argument, or be methods on the graph class.
Is Gamma standard graph terminology for this function? I've seen it called 'neighbourhood' (or 'open neighbourhood' when it needs to be clear that u is not included).
Python has a built-in decorator functools.lru_cache for caching the results of a function. So you can write:

@lru_cache(maxsize=None)
def neighbourhood(g, u):
    "Return the set of vertices in the graph g that are adjacent to u."
    return set(g.successors(u)).union(g.predecessors(u))

Reuse the set of successors instead of discarding it:

@lru_cache(maxsize=None)
def neighbourhood(g, u):
    "Return the set of vertices in the graph g that are adjacent to u."
    result = set(g.successors(u))
    result.update(g.predecessors(u))
    return result

In common_friends and total_friends, there is no need to make a copy of the neighbourhood before taking the union/intersection. You can take the union/intersection directly:

def total_friends(g, u, v):
    """Return the number of vertices in the graph g that are in the
    neighbourhoods of u or v (or both).

    """
    return len(neighbourhood(g, u) | neighbourhood(g, v))

def common_friends(g, u, v):
    """Return the number of vertices in the graph g that are in the
    neighbourhoods of both u and v.

    """
    return len(neighbourhood(g, u) &amp; neighbourhood(g, v))