src/sage/graphs/generators: speed up Golay code graph construction

Reimplement shortened_000_111_extended_binary_Golay_code_graph() to
load its vertices and edges from compressed, pickled data. This speeds
up the construction significantly, and eliminates a persistent CI
warning about the corresponding test being slow.

Author: orlitzky

src/sage/graphs/generators/distance_regular.pyx

@@ -487,35 +487,46 @@ def shortened_000_111_extended_binary_Golay_code_graph():
 
     EXAMPLES::
 
-        sage: # long time, needs sage.modules sage.rings.finite_rings
-        sage: G = graphs.shortened_000_111_extended_binary_Golay_code_graph()   # 25 s
+        sage: # needs sage.modules sage.rings.finite_rings
+        sage: G = graphs.shortened_000_111_extended_binary_Golay_code_graph()
         sage: G.is_distance_regular(True)
         ([21, 20, 16, 9, 2, 1, None], [None, 1, 2, 3, 16, 20, 21])
 
     ALGORITHM:
 
-    Compute the extended binary Golay code. Compute its subcode whose codewords
-    start with 000 or 111. Remove the first 3 entries from all the codewords
-    from the new linear code and compute its coset graph.
+    The vertices and edges of this graph have been precomputed and
+    pickled, so truthfully, we just unpickle them and pass them to the
+    Graph constructor. But the algorithm used to compute those
+    vertices and edges in the first place is,
+
+    #. Compute the extended binary Golay code.
+    #. Compute its subcode whose codewords start with 000 or 111.
+    #. Remove the first 3 entries from all the codewords from the
+       new linear code and compute its coset graph.
+
+    This construction is tested in ``generators_test.py``, where the
+    result is compared (up to isomorphism) with the result from this
+    method.
 
     REFERENCES:
 
-    Description and construction of this graph can be found in [BCN1989]_ p. 365.
+    The description and construction of this graph can be found in
+    [BCN1989]_, page 365.
     """
-    from sage.coding.linear_code import LinearCode
+    import lzma
+    from importlib.resources import as_file, files
+    from pickle import load
 
-    code = codes.GolayCode(GF(2))
-    C_basis = code.basis()
+    # Path to the pickled-and-xz'd list of (vertices, edges)
+    ppath = files('sage.graphs.generators').joinpath(
+      "shortened_000_111_extended_binary_Golay_code_graph.pickle.xz"
+    )
 
-    # now special shortening
-    v = C_basis[0] + C_basis[1] + C_basis[2]  # v has 111 at the start
-    C_basis = C_basis[3:]
-    C_basis.append(v)
-    C_basis = list(map(lambda x: x[3:], C_basis))
+    with as_file(ppath) as p:
+        with lzma.open(p) as f:
+            vs_and_es = load(f, fix_imports=False)
 
-    code = LinearCode(Matrix(GF(2), C_basis))
-
-    G = code.cosetGraph()
+    G = Graph(vs_and_es, format='vertices_and_edges')
     G.name("Shortened 000 111 extended binary Golay code")
     return G