Ticket #11880: trac_11880.patch

doc/en/reference/graphs.rst

@@ -24 +24 @@
    sage/graphs/graph_generators
    sage/graphs/digraph_generators
    sage/graphs/graph_database
+   sage/graphs/isgci
 
 
 Low-level implementation

sage/graphs/all.py

@@ -15 +15 @@
 from sage.graphs.cliquer import *
 from graph_database import graph_db_info
 from graph_editor import graph_editor
+
+import sage.graphs.isgci
+from sage.graphs.isgci import graph_classes
 import sage.graphs.distances_all_pairs

new file sage/graphs/isgci.py

@@ +1 @@
+r"""
+Information System on Graph Classes and their Inclusions
+
+This module deals with anything related to the ISGCI database in Sage.
+
+The ISGCI database gathers information on graph classes and their inclusions in
+each other. It also contains information on the complexity of several
+computational problems. 
+
+It is available on the `GraphClasses.org website
+<http://www.graphclasses.org/>`_ maintained by H.N. de Ridder et al.
+
+How to use it ?
+---------------
+
+The current support of the ISGCI database is elementary, and aims at
+implementing a pure Sage/Python interface which is easier to deal with than a
+XML file. I hope this code will be rewritten many times until it stabilizes :-)
+
+Presently, it is possible to use this database through the variables and methods
+present in the ``graph_classes`` object. For instance ::
+
+    sage: Trees = graph_classes.Tree
+    sage: Chordal = graph_classes.Chordal
+
+It is then possible to check the inclusion of classes inside of others, if the
+information is available in the db::
+
+    sage: Trees <= Chordal
+    True
+
+And indeed, the trees are chordal graphs.
+
+.. WARNING::
+
+    At the moment, only the *yes* answers can be assumed to be true !
+
+    ISGCI may not contain the information necessary to prove that a class A is a
+    subset of a class B, but that does not mean that class A is **NOT** a subset
+    of B. It just means ISGCI has no idea. Hence, no **NO** answer can be
+    assumed to be true at the moment.
+
+    When asked to compare Trees and Chordal graphs, though, the correct answer
+    is returned (as ISGCI obviously does not contain any proof that all chordal
+    graphs are trees, which would be a mistake)::
+
+        sage: Chordal <= Trees
+        False
+
+Given a graph class, one can obtain its associated information in the
+ISGCI database with the :meth:`show
+<sage.graphs.isgci.GraphClass.show>` method::
+
+    sage: Chordal.show()
+    Class of graphs : Chordal
+    -------------------------
+    type                           :  base
+    ID                             :  gc_32
+    name                           :  chordal
+    <BLANKLINE>
+    Problems :
+    -----------
+    Independent set                :  Linear
+    Treewidth                      :  Polynomial
+    Weighted independent set       :  Linear
+    Cliquewidth expression         :  NP-complete
+    Weighted clique                :  Polynomial
+    Clique cover                   :  Polynomial
+    Domination                     :  NP-complete
+    Clique                         :  Polynomial
+    Colourability                  :  Linear
+    Cliquewidth                    :  Unbounded
+    3-Colourability                :  Linear
+    Recognition                    :  Linear
+
+It is possible to obtain the complete list of the classes stored in ISGCI by
+calling the :meth:`show_all <sage.graphs.isgci.show_all>` method
+(beware -- long output)::
+
+    sage: sage.graphs.isgci.show_all()
+    ID        | name                                     | type                 | smallgraph                              
+    ----------------------------------------------------------------------------------------------------------------------
+    gc_309    | $K_4$--minor--free                       | base                 | 
+    gc_541    | $N^*$                                    | base                 | 
+    gc_215    | $N^*$--perfect                           | base                 | 
+    gc_5      | $P_4$--bipartite                         | base                 | 
+    gc_3      | $P_4$--brittle                           | base                 | 
+    gc_6      | $P_4$--comparability                     | base                 | 
+    gc_7      | $P_4$--extendible                        | base                 | 
+    ...
+
+This lets one find a class which does not appear in ``graph_classes`` (and
+should really be replaced by a proper search method). Given the ISGCI ID code
+corresponding to a classe, the :meth:`get_class_from_id
+<sage.graphs.isgci.GraphClasses.get_class_from_id>` method returns the
+corresponding graph class::
+
+    sage: GC = graph_classes.get_class_from_id("gc_5")
+    sage: GC
+    Graph class : $P_4$--bipartite
+
+Predefined classes
+------------------
+
+The ``graph_classes.*`` currently lists the following graph classes
+
+.. list-table::
+   :widths: 20 30
+   :header-rows: 1
+
+   * - Class
+     - Related methods
+
+   * - BinaryTrees
+
+     - :meth:`BalancedTree <sage.graphs.graph_generators.GraphGenerators.BalancedTree>`,
+       :meth:`is_tree <sage.graphs.generic_graph.GenericGraph.is_tree>`
+
+   * - Bipartite
+
+     - :meth:`BalancedTree <sage.graphs.graph_generators.GraphGenerators.BalancedTree>`,
+       :meth:`is_bipartite <sage.graphs.graph.Graph.is_bipartite>`
+
+   * - Block
+
+     - :meth:`blocks_and_cut_vertices <sage.graphs.generic_graph.GenericGraph.blocks_and_cut_vertices>`,
+
+   * - Chordal
+
+     - :meth:`is_chordal <sage.graphs.generic_graph.GenericGraph.is_chordal>`
+
+   * - Clique
+
+     - :meth:`CompleteGraph <sage.graphs.graph_generators.GraphGenerators.CompleteGraph>`,
+       :meth:`is_clique <sage.graphs.generic_graph.GenericGraph.is_clique>`
+
+   * - Comparability
+     -
+
+   * - Gallai
+
+     - :meth:`is_gallai_tree <sage.graphs.generic_graph.GenericGraph.is_gallai_tree>`
+
+   * - Grid
+
+     - :meth:`Grid2dGraph <sage.graphs.graph_generators.GraphGenerators.Grid2dGraph>`,
+       :meth:`GridGraph <sage.graphs.graph_generators.GraphGenerators.GridGraph>`
+
+   * - Interval
+
+     - :meth:`RandomInterval <sage.graphs.graph_generators.GraphGenerators.RandomInterval>`,
+       :meth:`IntervalGraph <sage.graphs.graph_generators.GraphGenerators.IntervalGraph>`,
+       :meth:`is_interval <sage.graphs.generic_graph.GenericGraph.is_interval>`
+
+   * - Line
+
+     - :meth:`line_graph_forbidden_subgraphs <sage.graphs.graph_generators.GraphGenerators.line_graph_forbidden_subgraphs>`,
+       :meth:`is_line_graph <sage.graphs.graph.Graph.is_line_graph>`
+
+   * - Modular
+
+     - :meth:`modular_decomposition <sage.graphs.graph.Graph.modular_decomposition>`
+
+   * - Outerplanar
+
+     - :meth:`is_circular_planar <sage.graphs.generic_graph.GenericGraph.is_circular_planar>`
+
+   * - Perfect
+
+     - :meth:`is_perfect <sage.graphs.graph.Graph.is_perfect>`
+
+   * - Planar
+
+     - :meth:`is_planar <sage.graphs.generic_graph.GenericGraph.is_planar>`
+
+   * - Split
+
+     - :meth:`is_split <sage.graphs.graph.Graph.is_split>`
+
+   * - Tree
+
+     - :meth:`trees <sage.graphs.graph_generators.GraphGenerators.trees>`,
+       :meth:`is_tree <sage.graphs.generic_graph.GenericGraph.is_tree>`
+
+   * - UnitDisk
+     -
+
+   * - UnitInterval
+
+     - :meth:`is_interval <sage.graphs.generic_graph.GenericGraph.is_interval>`
+
+
+Information for developpers
+----------------------------
+
+* The database is not *so* large, but enough to prevent it from being loaded at
+  Sage's startup. The internal methods using the database should often be
+  preceded by a call to :meth:`_load_ISGCI_if_not_loaded
+  <sage.graphs.isgci._load_ISGCI_if_not_loaded>` or to
+  :meth:`_build_class_digraph_if_not_built
+  <sage.graphs.isgci._build_class_digraph_if_not_built>`.
+
+* Once the database has been accessed once, the information is extracted from
+  the ``.sobj`` files in which it is stored and their information can be
+  accessed by the following variables :
+
+  * ``sage.graphs.isgci.classes`` (dictionary) 
+  * ``sage.graphs.isgci.inclusions`` (list of dictionaries)
+  * ``sage.graphs.isgci.class_digraph`` (DiGraph)
+
+  Note that the digraph is only built if necessary (for instance if the user
+  tried to compare two classes).
+
+* The ``DiGraph`` object ``sage.graphs.isgci.class_digraph`` has for vertex set
+  the ID of the graph classes. This digraph contains an edge `uv` if the graph
+  class represented by `u` is larger (not necessarily strictly) than the one
+  represented by `v`.
+
+  Though it represents inclusions of sets, this ``DiGraph`` is **NOT
+  ACYCLIC**. Several entries exist in the ISGCI database whise represent the
+  same graph class::
+
+    sage: Berge = graph_classes.get_class_from_id("gc_274"); Berge
+    Graph class : Berge
+    sage: Perfect = graph_classes.get_class_from_id("gc_56"); Perfect
+    Graph class : perfect
+    sage: Berge <= Perfect
+    True
+    sage: Perfect <= Berge
+    True
+      
+  (Which is the same as)::
+
+    sage: Perfect == Berge
+    True
+
+  Indeed ::
+
+    sage: sage.graphs.isgci.class_digraph.is_directed_acyclic()
+    False
+
+ToDo list
+---------
+
+Technical things :
+
+* Find a proper way to find a graph class which does not appear in
+  ``graph_classes`` by can be listed by :meth:`show_all
+  <sage.graphs.isgci.show_all>`.
+
+* Some of the graph classes appearing in ``graph_classes.*`` already have a
+  recognition algorithm in Sage. It would be so nice to be able to write ``g in
+  Trees``, ``g in Perfect``, ``g in Chordal``, ... `:-)`
+
+Long-term stuff :
+
+* To be able to ask questions to ISGCI from the inside of Sage, easily enough,
+  related to any information it contains (for instance everything that can be
+  done through the website)
+
+* Write generic recognition algorithms for specific classes (when a graph class
+  is defined by the exclusion of subgraphs, one can write a generic algorithm
+  checking the existence of each of the graphs, and this method already exists
+  in Sage).
+
+* Modify our algorithms so that they could use the properties of a graph class
+  to improve their performances. Right now, the same algorithm is used to find
+  an independent set in a tree, in a planar graph, or any other graph.
+
+
+AUTHORS:
+--------
+
+* H.N. de Ridder et al. (ISGCI database)
+* Nathann Cohen (Sage implementation) 
+
+Methods
+-------
+"""
+
+classes = {}
+inclusions = []
+class_digraph = None
+
+
+#*****************************************************************************
+#      Copyright (C) 2011 Nathann Cohen <nathann.cohen@gmail.com>            
+#
+# Distributed  under  the  terms  of  the  GNU  General  Public  License (GPL)
+#                         http://www.gnu.org/licenses/
+#*****************************************************************************
+
+_XML_FILE = "isgci_sage.xml"
+
+def _download_db():
+    r"""
+    Downloads the current version of the ISGCI db
+
+    EXAMPLE::
+
+        sage: sage.graphs.isgci._download_db() # Not tested -- requires internet
+    """
+
+    from sage.misc.misc import SAGE_TMP
+    import urllib2
+    u = urllib2.urlopen('http://www.graphclasses.org/data.zip')
+    localFile = open(SAGE_TMP+'isgci.zip', 'w')
+    localFile.write(u.read())
+    localFile.close()
+    import os, zipfile
+    z = zipfile.ZipFile(SAGE_TMP+'isgci.zip')
+    z.extract(_XML_FILE, SAGE_TMP)
+
+def _create_db():
+    r"""
+    Parses the ISGCI database and returns its content as Python objects.
+
+    EXAMPLE::
+
+        sage: sage.graphs.isgci._create_db() # Not tested -- requires internet
+    """
+    from sage.misc.misc import SAGE_TMP
+    import xml.dom.minidom
+    from xml.dom.minidom import Node
+
+    # This method is there to parse the XML file containing the ISGCI
+    # database. It is admittedly not very pretty, but it builds the class we
+    # want from the XML file and that's more or less all we ask it to do :-p
+
+    doc = xml.dom.minidom.parse(SAGE_TMP+_XML_FILE)
+    
+    classes = {}
+
+    giveme = lambda x,y : str(x.getAttribute(y))
+
+    for node in doc.getElementsByTagName("GraphClass"):
+        ID = str(node.getAttribute("id"))
+        Dl = {}
+        smallgraph = []
+        Dl["ID"] = giveme(node, "id")
+        problems = {}
+        for node2 in node.childNodes:
+            name = str(node2.nodeName)
+            if name == "name":
+                Dl[name] = str(node2.childNodes[0].nodeValue)
+
+            elif name ==  "smallgraph":
+                smallgraph.append(str(node2.childNodes[0].nodeValue))
+
+            elif name == "problem":
+                problems[giveme(node2, "name")] = giveme(node2, "complexity")
+
+        Dl["problems"] = problems
+
+        if smallgraph:
+            Dl["smallgraph"] = smallgraph
+
+        if giveme(node, "type"):
+            Dl["type"] = giveme(node, "type")
+
+    
+        classes[giveme(node, "id")] = Dl
+
+    inclusions = []
+    for node in doc.getElementsByTagName("incl"):
+        Dl = {}
+        for name in ["proper", "confidence", "super", "sub"]:
+            if giveme(node, name):
+                Dl[name] = giveme(node, name)            
+
+        for node2 in node.childNodes:
+            name = str(node2.nodeName)
+            if name == "ref":
+                Dl[name] = str(node2.childNodes[0].nodeValue)
+
+        inclusions.append(Dl)
+
+    return classes, inclusions
+
+def update_db(verbose = False):
+    r"""
+    Updates the current version of the ISGCI database by download it from internet.
+
+    This method downloads the ISGCI database from the website `GraphClasses.org
+    <http://www.graphclasses.org/>`_.  
+
+    It then extracts the zip file and parses its XML content, which is stored as
+    two .sobj files, the first one representing the graph classes, and the
+    second representing their inclusions.
+
+    Depending on the rights of the user running Sage when this command is run,
+    one attempt is made at saving its result in Sage's directory so that all
+    users would benefit from it. If the rights are not sufficient, the .sobj
+    files are saved to the current user's directory, so that he will be the only
+    one to benefit from the update.
+
+    INPUT:
+
+    - ``verbose`` (boolean) -- whether to output information of the update
+      process.
+
+    EXAMPLE::
+
+        sage: sage.graphs.isgci.update_db() # Not tested -- requires internet
+    """
+    from sage.misc.misc import SAGE_TMP, SAGE_ROOT, SAGE_LOCAL, SAGE_DB
+    global classes, inclusions, class_digraph
+    
+    try:
+        _download_db()
+    except:
+        raise Exception("There has been a problem while downloading or unzipping the ISGCI database O_o")
+
+
+    if verbose:
+        print "Database downloaded"
+
+    classes, inclusions = _create_db()
+
+    if verbose:
+        print "XML file converted to Python dictionaries"
+    
+
+    from sage.all import save
+    
+    # Trying to save to Sage's directory
+    try:
+        save(classes, SAGE_ROOT+'/data/graphs/isgci_classes.sobj')
+        save(inclusions, SAGE_ROOT+'/data/graphs/isgci_inclusions.sobj')
+        inclusions = class_digraph = None
+        classes = {}
+        if verbose:
+            print "Database saved to .sobj files in "+SAGE_ROOT+'/data/graphs/'
+
+        return
+    except IOError:
+        pass
+
+    # Trying to save to the user's home directory
+    try:
+        save(classes, SAGE_DB+"/isgci_classes.sobj")
+        save(inclusions, SAGE_DB+"/isgci_inclusions.sobj")
+        classes = inclusions = class_digraph = None
+        if verbose:
+            print "Database saved to .sobj files in "+SAGE_DB
+
+        return
+
+    except IOError:
+        pass
+
+    # Gloops !
+    raise Exception("Sage is unable to write the files to your"+
+                    "computer ! This shouldn't have happened. "+
+                    "Could you report the bug ? ;-)")
+
+def get_ISGCI():
+    r"""
+    Returns the contents of the ISGCI database.
+
+    This method is mostly for internal use, but often provides useful
+    information during debugging operations.
+
+    OUTPUT:
+
+    A pair ``(classes, inclusions)`` where ``classes`` is a dict of dict, and
+    ``inclusions`` is a list of dicts.
+    
+    .. NOTE::
+
+        This method returns the data contained in the most recent version of the
+        ISGCI database present on the computer. See ``update_db`` to update it.
+
+    EXAMPLE::
+
+        sage: classes, inclusions = sage.graphs.isgci.get_ISGCI()
+    """
+
+    import os.path
+    from sage.all import save, load
+    from sage.misc.misc import SAGE_TMP, SAGE_ROOT, SAGE_LOCAL, SAGE_DB
+
+    try:
+        open(SAGE_DB+"/isgci_classes.sobj")
+
+        # Which copy is the most recent on the disk ?
+        if (os.path.getmtime(SAGE_DB+"/isgci_classes.sobj") >
+            os.path.getmtime(SAGE_ROOT+"/data/graphs/isgci_classes.sobj")):
+            
+            classes = load(SAGE_DB+"/isgci_classes.sobj")
+            inclusions = load(SAGE_DB+"/isgci_inclusions.sobj")
+
+        else:
+            classes = load(SAGE_ROOT+"/data/graphs/isgci_classes.sobj")
+            inclusions = load(SAGE_ROOT+"/data/graphs/isgci_inclusions.sobj")
+
+    except IOError as e:
+        # No local version of the file exists
+        classes = load(SAGE_ROOT+"/data/graphs/isgci_classes.sobj")
+        inclusions = load(SAGE_ROOT+"/data/graphs/isgci_inclusions.sobj")
+
+    return classes, inclusions
+
+def show_all():
+    r"""
+    Prints all graph classes stored in ISGCI
+
+    EXAMPLE::
+
+        sage: sage.graphs.isgci.show_all()
+        ID        | name                                     | type                 | smallgraph                              
+        ----------------------------------------------------------------------------------------------------------------------
+        gc_309    | $K_4$--minor--free                       | base                 | 
+        gc_541    | $N^*$                                    | base                 | 
+        gc_215    | $N^*$--perfect                           | base                 | 
+        gc_5      | $P_4$--bipartite                         | base                 | 
+        gc_3      | $P_4$--brittle                           | base                 | 
+        gc_6      | $P_4$--comparability                     | base                 | 
+        gc_7      | $P_4$--extendible                        | base                 | 
+        ...
+    """
+    global classes
+    _load_ISGCI_if_not_loaded()
+    classes_list = classes.values()
+
+    # We want to print the different fields, and this dictionary stores the
+    # maximal number of characters of each field.
+    MAX = {
+        "ID" : 0,
+        "type" : 0,
+        "smallgraph": 0,
+        "name": 0
+        }
+
+    # We sort the classes alphabetically, though we would like to display the
+    # meaningful classes at the top of the list
+    classes_list.sort(key = lambda x:x.get("name","zzzzz")+"{0:4}".format(int(x["ID"].split('_')[1])))
+
+    # Maximum width of a field
+    MAX_LEN = 40
+
+    # Computing te max of each field with the database
+    for key in MAX:
+        MAX[key] = len(max(map(lambda x:str(x.get(key,"")),classes_list), key = len))
+
+    # At most MAX characters per field
+    for key, length in MAX.iteritems():
+        MAX[key] = min(length, MAX_LEN)
+
+    # Head of the table
+    print ("{0:"+str(MAX["ID"])+"} | {1:"+str(MAX["name"])+"} | {2:"+str(MAX["type"])+"} | {3:"+str(MAX["smallgraph"])+"}").format("ID", "name", "type", "smallgraph")
+    print "-"*(sum(MAX.values())+9)
+
+    # Entries
+    for entry in classes_list:
+        ID = entry.get("ID","") 
+        name = entry.get("name","")
+        type = entry.get("type","")
+        smallgraph = entry.get("smallgraph","")
+        print ("{0:"+str(MAX["ID"])+"} | {1:"+str(MAX["name"])+"} | {2:"+str(MAX["type"])+"} | ").format(ID, name[:MAX_LEN], type[:MAX_LEN])+str(smallgraph)[:MAX_LEN]
+
+def _load_ISGCI_if_not_loaded():
+    r"""
+    Load ISGI if not loaded already
+
+    This is here to avoid having to load the db when Sage starts
+    """
+    global classes, inclusions
+    if classes == {}:
+        classes, inclusions = get_ISGCI()
+
+def _build_class_digraph_if_not_built():
+    r"""
+    Builds the class digraph
+    """
+    global classes, inclusions, class_digraph
+
+    if not (class_digraph is None):
+        return
+
+    _load_ISGCI_if_not_loaded()
+
+    from sage.graphs.digraph import DiGraph
+    class_digraph = DiGraph()
+    class_digraph.add_vertices(classes.keys())
+
+    for edge in inclusions:
+        if edge.get("confidence","") == "unpublished":
+            continue
+
+        class_digraph.add_edge(edge['super'], edge['sub'])
+    
+    inclusions = []
+
+class GraphClass:
+    r"""
+    An instance of this class represents a Graph Class, matching some entry in
+    the ISGCI database.
+
+    EXAMPLE:
+
+    Testing the inclusion of two classes::
+
+        sage: Chordal = graph_classes.Chordal
+        sage: Trees = graph_classes.Tree
+        sage: Trees <= Chordal
+        True
+        sage: Chordal <= Trees
+        False
+
+    TEST::
+
+        sage: Trees >= Chordal
+        False
+        sage: Chordal >= Trees
+        True
+    """
+    def __init__(self, name, gc_id):
+        self._name = name
+        self._gc_id = gc_id
+
+    def __repr__(self):
+        r"""
+        Returns a short description of the class
+
+        EXAMPLE::
+
+            sage: graph_classes.Chordal
+            Graph class : Chordal
+        """
+        return self._name+" graphs"
+
+    def __hash__(self):
+        r"""
+        Returns the class' ID
+        """
+        return self._gc_id
+
+    def __le__(self, other):
+        return other.__ge__(self)
+
+    def __ge__(self, other):
+        global class_digraph, classes
+
+        _build_class_digraph_if_not_built()
+
+        return (class_digraph.shortest_path(self._gc_id,other._gc_id) != [])
+
+    def __eq__(self, other):
+        return self.__ge__(other) and other.__ge__(self)
+
+    def __lt__(self, other):
+        raise Exception("Not Implemented")
+
+    __gt__ = __ne__ = __lt__
+
+    def show(self):
+        r"""
+        Prints the information of ISGCI about the current class.
+
+        EXAMPLE::
+
+            sage: graph_classes.Chordal.show()
+            Class of graphs : Chordal
+            -------------------------
+            type                           :  base
+            ID                             :  gc_32
+            name                           :  chordal
+            <BLANKLINE>
+            Problems :
+            -----------
+            Independent set                :  Linear
+            Treewidth                      :  Polynomial
+            Weighted independent set       :  Linear
+            Cliquewidth expression         :  NP-complete
+            Weighted clique                :  Polynomial
+            Clique cover                   :  Polynomial
+            Domination                     :  NP-complete
+            Clique                         :  Polynomial
+            Colourability                  :  Linear
+            Cliquewidth                    :  Unbounded
+            3-Colourability                :  Linear
+            Recognition                    :  Linear
+        """
+        global classes
+        _load_ISGCI_if_not_loaded()
+
+        classs = classes[self._gc_id]
+        print "Class of graphs : "+self._name
+        print "-"*(len(self._name)+18)
+
+        for key, value in classs.iteritems():
+            if value != "" and key != "problems":
+                print "{0:30} : ".format(key),
+                print value
+
+        print "\nProblems :"
+        print "-"*11
+        for key, value in classs["problems"].iteritems():
+            if value != "":
+                print "{0:30} : ".format(key),
+                print value
+        
+
+
+class GraphClasses:
+    def get_class_from_id(self, ID):
+        r"""
+        Returns the class corresponding to the given ID in the ISGCI database.
+
+        EXAMPLE:
+
+        With an existing ID::
+
+            sage: Cographs = graph_classes.get_class_from_id("gc_151")
+            sage: Cographs
+            Graph class : cograph
+
+        With a wrong ID::
+
+            sage: graph_classes.get_class_from_id(-1)
+            Traceback (most recent call last):
+            ...
+            ValueError: The given class ID does not exist in the ISGCI database. Is the db too old ? You can update it with sage.graphs.isgci.update_db().
+        """
+        global classes
+        _load_ISGCI_if_not_loaded()
+        if ID in classes:
+            c = classes[ID]
+
+            if "name" in c and c["name"] != "":
+                name = c["name"]
+            else:
+                name = "class "+str(ID)
+
+            return GraphClass(name, ID)
+
+        else:
+            raise ValueError("The given class ID does not exist in the ISGCI database. Is the db too old ? You can update it with sage.graphs.isgci.update_db().")
+
+graph_classes = GraphClasses()
+
+
+
+
+
+
+# Any object added to this list should also appear in the class' documentation, at the top of the file.
+graph_classes.BinaryTrees = GraphClass("BinaryTrees", "gc_847")
+graph_classes.Bipartite = GraphClass("Bipartite", "gc_69")
+graph_classes.Block = GraphClass("Block", "gc_93")
+graph_classes.Chordal = GraphClass("Chordal", "gc_32")
+graph_classes.Clique = GraphClass("Clique", "gc_141")
+graph_classes.Comparability = GraphClass("Comparability", "gc_72")
+graph_classes.Gallai = GraphClass("Gallai", "gc_73")
+graph_classes.Grid = GraphClass("Grid", "gc_464")
+graph_classes.Interval = GraphClass("Interval", "gc_234")
+graph_classes.Line = GraphClass("Line", "gc_249")
+graph_classes.Modular = GraphClass("Modular", "gc_50")
+graph_classes.Outerplanar = GraphClass("Outerplanar", "gc_110")
+graph_classes.Perfect = GraphClass("Perfect", "gc_56")
+graph_classes.Planar = GraphClass("Planar", "gc_43")
+graph_classes.Split = GraphClass("Split", "gc_39")
+graph_classes.Tree = GraphClass("Tree", "gc_342")
+graph_classes.UnitDisk = GraphClass("UnitDisk", "gc_389")
+graph_classes.UnitInterval = GraphClass("UnitInterval", "gc_299")
+