def statistic(G):
    """Return the smallest number such that Alice has a winning strategy.

    EXAMPLES:

    From http://www.dlsu.edu.ph/conferences/dlsu_research_congress/2014/_pdf/proceedings/TPHS-I-011-FT.pdf::

        sage: [statistic(graphs.PathGraph(r)) for r in range(2,12)]
        [2, 2, 3, 3, 3, 3, 3, 3, 3, 3]
    
        sage: [statistic(graphs.CycleGraph(r)) for r in range(2,10)]
        [2, 3, 3, 3, 3, 3, 3, 3]
    
        sage: [statistic(graphs.StarGraph(r)) for r in range(2,10)]
        [2, 2, 2, 2, 2, 2, 2, 2]
    
        sage: [statistic(graphs.CompleteGraph(r)) for r in range(2,10)]
        [2, 3, 4, 5, 6, 7, 8, 9]

    Proposition 4 of the reference seems to miss some corner cases.
    W(3) and W(4) are complete graphs, so Proposition 5 applies.  

    However, W(5) and W(7) seem to be special::

        sage: [statistic(graphs.WheelGraph(r)) for r in range(5,12)] 
        [3, 4, 3, 4, 4, 4, 4]
    
        sage: [[statistic(graphs.CompleteBipartiteGraph(r, s)) for r in range(1,6)] for s in range(1,6)]
        [[2, 2, 2, 2, 2],
        [2, 3, 3, 3, 3],
        [2, 3, 3, 3, 3],
        [2, 3, 3, 3, 3],
        [2, 3, 3, 3, 3]]

    The following contradicts Theorem 1, but is in agreement with
    http://ssltest.cs.umd.edu/~gasarch/TOPICS/graphcolgame/tree3.pdf,
    Theorem 3::

        sage: statistic(graphs.PetersenGraph())
        4

    from wikipedia::

        sage: [statistic(graphs.CompleteGraph(2).cartesian_product(graphs.PathGraph(r))) for r in range(1,6)]
        [2, 3, 3, 4, 4]
    
        sage: [statistic(graphs.CompleteGraph(2).cartesian_product(graphs.CycleGraph(r))) for r in range(1,5)]
        [2, 3, 4, 4]
    
        sage: [statistic(graphs.CompleteGraph(2).cartesian_product(graphs.CompleteGraph(r))) for r in range(1,5)]
        [2, 3, 4, 5]

    """
    G = G.relabel(immutable=True, inplace=False)
    for k in range(G.chromatic_number(), max(G.degree())+2):
        if Alice_wins(G, k):
            return k

def normalize_colours(D):
    """
    From left to right, use small colours first.
    """
    pi = [None]*(max(D)+1)
    i = 0
    for e in D:
        if e is not None and pi[e] is None:
            pi[e] = i
            i += 1
    return tuple([None if e is None else pi[e] for e in D])

@cached_function
def Alice_wins(G, k, C=None):
    """Return whether C is a winning position for Alice, who wants to
    properly color the graph.

    Expect that the vertices are labelled 0,1,...

    """
    def children(D):
        if all(c is None for c in D):
            colours = 1
        else:
            colours = min(k, max(D)+2)
        for v, c in enumerate(D):
            if c is None:
                for d in range(colours):
                    if not any(D[u] == d for u in G.neighbor_iterator(v)):
                        yield D[:v] + tuple([d]) + D[v+1:]

    if C is None:
        C = tuple([None]*G.num_verts())

    uncoloured_vertices = C.count(None)
    if uncoloured_vertices == 0:
        return True

    # let Alice colour a vertex
    for D in children(C):
        # if C was missing precisely one vertex, and we could
        # colour it, Alice wins
        if uncoloured_vertices == 1:
            return True
        # Alice wins if there is a D such that all moves of Bob make Alice win
        has_colouring = False
        for E in children(D):
            has_colouring = True
            if not Alice_wins(G, k, normalize_colours(E)):
                break
        else:
            if has_colouring:
                return True
    return False