{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"# Introduction to Graph-theory\n",
"\n",
"[Graph-theory](https://en.wikipedia.org/wiki/Graph_theory) is the study of graphs,\n",
"which are mathematical structures used to model pairwise relations between objects.\n",
"\n",
"Graphs are among the most ubiquitous models of both natural and human-made structures.\n",
"They can model many types of relations and process dynamics in physical, biological\n",
"and social systems. In computer science, they can represent networks of communication,\n",
"data organization, computational devices, the flow of computation, etc.\n",
"Graphs are one of the principal objects of study in\n",
"[discrete mathematics](https://en.wikipedia.org/wiki/Discrete_mathematics).\n",
"\n",
"\n",
"\n",
"| alias | name used in Graph-theory | description | syntax |\n",
"|---|:---:|---|---|\n",
"|node, vertice, point| **node** | an intersection of edges | `g.add_node('x')` |\n",
"| edge, line, link| **edge** | the line that connects intersections | `g.add_edge('a','b')`|\n",
"| the weight, cost or value of an edge | **value** | numeric value of an edge | `g.add_edge('a','b',value=4)`|\n",
"|in-degree | **in_degree**| the number of incoming edges | `g.in_degree('a')` |\n",
"|out-degree| **out_degree**| the number of outgoing edges| `g.out_degree('b')` |\n",
"|path| **path**| an ordered collection of nodes | (a list of nodes) |\n",
"|distance, length, costs| **---** | the sum of values of a set of edges | (number) |\n",
"| subgraph | **subgraph**| the nodes and edges of *g'* exists in *g* ||\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To add nodes the syntax is simple"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Graph(1 nodes, 0 edges)\n"
]
}
],
"source": [
"from graph import Graph\n",
"g = Graph()\n",
"g.add_node('C')\n",
"print(g)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To associate the node with an object, you can use the `obj` keyword like this:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"g.add_node('C', obj={'monty':'python'})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This save you from managing the objects externally and permits algorithms to use the object directly.\n",
"\n",
"To retrieve the object use:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'monty': 'python'}"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.node('C')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And to delete the node use:\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"g.del_node('C')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To add edges the syntax is equally simple:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Graph(2 nodes, 1 edges)\n"
]
}
],
"source": [
"from graph import Graph\n",
"g = Graph()\n",
"g.add_edge('A', 'B', value=4)\n",
"print(g)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To get all edges use:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"data": {
"text/plain": [
"[('A', 'B', 4)]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.edges()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Or to view a specific edge `value`, use:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.edge('A', 'B')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you see, `g.edges()` returns a list of immutable tuples with `(from, to, value)`. \n",
"\n",
"Note that it isn't necessary to add the nodes first. When you use `g.add_edge(...)` the library will detect that the nodes haven't been created and add them quietly."
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"If you need to update the value on the edge just use `g.add_edge('A','B', value=10)` again.\n",
"The edge works like a dictionary, where the pair of node `'A'` and `'B'` is the key where the `10` is the value.\n",
"\n",
"In some cases it is not required for the graph to be directed. Mathematicians call this undirected.\n",
"In Python a principal philosophy is that *explicit is better than implicit*, so in graph-theory *undirected* is interpreted as bidirectional. To make this explicit when adding edges, either add an edge for both directions, or use the keyword `bidirectional` which is a helper for doing these to step in one step:\n",
"\n",
"|this... | ...is the same as this|\n",
"|---|---|\n",
"|`g.add_edge('A','B')` `g.add_edge('B','A')`|`g.add_edge('A','B', bidirectional=True)`|\n",
"\n",
"In other cases multiple edges between nodes are required. Graph-theory allows this using\n",
"dummy nodes. Here's an example:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The graph will store the in- and -out-degree of every node when the edges are added and removed, so the in_degree and out_degree is available immediately e.g. ($O(1)$ [computational complexity](https://wiki.python.org/moin/TimeComplexity)). Here's an example:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.in_degree('A')"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.out_degree('A')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, to delete an edge, simply use:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"g.del_edge('A','B')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To replicate the graph in the image in the begging of this section, we will use a helper from the graphs initialization methods `from_list`:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"g = Graph(from_list=[(1,2),(2,3),(3,4),(4,5),(5,6),(5,1),(2,5)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we can't create a bidirectional graph implicitly, we can do so explicitly:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"g.from_list([(end,start,value) for start,end,value in g.edges()])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I chose this example deliberately as it illustrates the ability to update the graph from a list of nodes, even if that list comes from the graph itself. I also wanted to show the idiomatic use of list comprehensions for reading `start`, `end`, `value` from the method `g.edges()`.\n",
"\n",
"The reverse operation `to_list` also exists:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(1, 2, 1),\n",
" (1, 5, 1),\n",
" (2, 3, 1),\n",
" (2, 5, 1),\n",
" (2, 1, 1),\n",
" (3, 4, 1),\n",
" (3, 2, 1),\n",
" (4, 5, 1),\n",
" (4, 3, 1),\n",
" (5, 6, 1),\n",
" (5, 1, 1),\n",
" (5, 2, 1),\n",
" (5, 4, 1),\n",
" (6, 5, 1),\n",
" (1,),\n",
" (2,),\n",
" (3,),\n",
" (4,),\n",
" (5,),\n",
" (6,)]"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.to_list()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The method lists all edges first, followed by all nodes"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If, you have the need to lookup particular edges or values directly `to_dict` may be more convenient:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1: {2: 1, 5: 1},\n",
" 2: {3: 1, 5: 1, 1: 1},\n",
" 3: {4: 1, 2: 1},\n",
" 4: {5: 1, 3: 1},\n",
" 5: {6: 1, 1: 1, 2: 1, 4: 1},\n",
" 6: {5: 1}}"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.to_dict()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`to_dict`s inverse operation is `from_dict`, which behaves in the exact same way as `to_list`/`from_list`:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"g2 = Graph(from_dict=g.to_dict())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we created `g2` from `g`."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{1: {2: 1, 5: 1},\n",
" 2: {3: 1, 5: 1, 1: 1},\n",
" 5: {6: 1, 1: 1, 2: 1, 4: 1},\n",
" 3: {4: 1, 2: 1},\n",
" 4: {5: 1, 3: 1},\n",
" 6: {5: 1}}"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g2.to_dict()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This may seem as a long way to copy when the libray already has the method `g.copy()`. The difference between the two methods, though, is that `g2=Graph(from_list(g.to_list()))` does not copy the reference to objects that you may have set using `g.add_node('a', obj='!!!')`. `g.copy()` will copy there reference too."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [],
"source": [
"from graph import Graph\n",
"\n",
"g = Graph()\n",
"g.add_edge('A', 'B', value=4) # a direct edge\n",
"g.add_edge('A', 'ab', value=2) # dummy edge from A to dummy node ab\n",
"g.add_edge('ab', 'B', value=2) # dummy edge from dummy node ab to B"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"Creating these dummy nodes by hand isn't very effective, so if you have a list of edges like in the example below it is good to know that nodes can be any hashable object, e.g. tuples, strings, numbers, ..."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('A', ('A', 'B', 4), 4)\n",
"('A', ('A', 'B', 3), 3)\n",
"('A', ('A', 'B', 2), 2)\n",
"(('A', 'B', 4), 'B', 0)\n",
"(('A', 'B', 3), 'B', 0)\n",
"(('A', 'B', 2), 'B', 0)\n"
]
}
],
"source": [
"L = [('A','B',4), ('A','B',3), ('A','B',2)]\n",
"g = Graph()\n",
"for edge in L:\n",
" start,end,value = edge # using the edge tuple as dummy node.\n",
" g.add_edge(start, edge, value) # adding the value on the way to the dummy node.\n",
" g.add_edge(edge, end, 0) # adding zero as the value has already been added.\n",
"\n",
"for edge in g.edges():\n",
" print(edge)"
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"The benefit of doing this is that most algorithms are simpler to implement (and understand!) when dummy nodes are explicit. As an outset you will always know your list of \"real\" nodes and can hence exclude dummy nodes when reading through the list of nodes. It would for example be silly to search for a dummy node when looking for the shortest path between two \"real\" nodes, as it is a pragmatic assumption that the algorithm will only have to search for the shortest path between two meaningful points."
]
},
{
"cell_type": "markdown",
"metadata": {
"pycharm": {
"name": "#%% md\n"
}
},
"source": [
"### Inspecting the source code\n",
"\n",
"Since we are at this, you can count on all algorithms being available directly on the `Graph` class,\n",
"so that, for example the shortest path algorithm is available as:\n",
"\n",
"```\n",
"g.shortest_path('A','B')\n",
"```\n",
"\n",
"All the documentation is also available using the built-in help menu:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"jupyter": {
"outputs_hidden": false
},
"pycharm": {
"name": "#%%\n"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on function shortest_path in module graph:\n",
"\n",
"shortest_path(self, start, end, memoize=False, avoids=None)\n",
" :param start: start node\n",
" :param end: end node\n",
" :param memoize: boolean (stores paths in a cache for faster repeated lookup)\n",
" :param avoids: optional. A frozen set of nodes that cannot be on the path.\n",
" :return: distance, path as list\n",
"\n"
]
}
],
"source": [
"help(Graph.shortest_path)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you want a more detail description of what is going on, it is often helpful to directly to the specific function."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [],
"source": [
"import inspect"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" def shortest_path(self, start, end, memoize=False, avoids=None):\n",
" \"\"\"\n",
" :param start: start node\n",
" :param end: end node\n",
" :param memoize: boolean (stores paths in a cache for faster repeated lookup)\n",
" :param avoids: optional. A frozen set of nodes that cannot be on the path.\n",
" :return: distance, path as list\n",
" \"\"\"\n",
" if not memoize:\n",
" return shortest_path(graph=self, start=start, end=end, avoids=avoids)\n",
"\n",
" if self._cache is None:\n",
" self._cache = ShortestPathCache(graph=self)\n",
" return self._cache.shortest_path(start, end, avoids=avoids)\n",
"\n"
]
}
],
"source": [
"print(inspect.getsource(Graph.shortest_path))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here you see that Graph wraps the function `shortest_path` and, should you choose to use the keyword `memoize=True` that it uses the class `ShortestPathCache`.\n",
"\n",
"These can be inspected again in the same way:"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"def shortest_path(graph, start, end, avoids=None):\n",
" \"\"\" single source shortest path algorithm.\n",
" :param graph: class Graph\n",
" :param start: start node\n",
" :param end: end node\n",
" :param avoids: optional set,frozenset or list of nodes that cannot be a part of the path.\n",
" :return distance, path (as list),\n",
" returns float('inf'), [] if no path exists.\n",
" \"\"\"\n",
" if not isinstance(graph, (BasicGraph, Graph, Graph3D)):\n",
" raise TypeError(f\"Expected BasicGraph, Graph or Graph3D, not {type(graph)}\")\n",
" if start not in graph:\n",
" raise ValueError(f\"{start} not in graph\")\n",
" if end not in graph:\n",
" raise ValueError(f\"{end} not in graph\")\n",
" if avoids is None:\n",
" visited = set()\n",
" elif not isinstance(avoids, (frozenset, set, list)):\n",
" raise TypeError(f\"Expect obstacles as set or frozenset, not {type(avoids)}\")\n",
" else:\n",
" visited = set(avoids)\n",
"\n",
" q, minimums = [(0, 0, start, ())], {start: 0}\n",
" i = 1\n",
" while q:\n",
" (cost, _, v1, path) = heappop(q)\n",
" if v1 not in visited:\n",
" visited.add(v1)\n",
" path = (v1, path)\n",
"\n",
" if v1 == end: # exit criteria.\n",
" L = []\n",
" while path:\n",
" v, path = path[0], path[1]\n",
" L.append(v)\n",
" L.reverse()\n",
" return cost, L\n",
"\n",
" for _, v2, dist in graph.edges(from_node=v1):\n",
" if v2 in visited:\n",
" continue\n",
" prev = minimums.get(v2, None)\n",
" next_node = cost + dist\n",
" if prev is None or next_node < prev:\n",
" minimums[v2] = next_node\n",
" heappush(q, (next_node, i, v2, path))\n",
" i += 1\n",
" return float(\"inf\"), []\n",
"\n"
]
}
],
"source": [
"from graph import shortest_path # getting the function behind Graph.shortest_path\n",
"print(inspect.getsource(shortest_path)) # viewing the code"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The code is very well annotated, so if the code doesn't explain itself, feel free to ask for a more elaborate example on the [github repo](https://github.com/root-11/graph-theory/issues).\n",
"\n",
"Graph-theory tries to be transparent about everything it does. As the readme on the frontpage says: \n",
"\n",
"> with code you can explain to your boss"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Graphs ready for usage"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To ease the learning curve, I've added a collection of graphs that are ready for import.\n",
"Here's one that should be familiar to most Europeans:\n",
"\n",
""
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"from graphs import london_underground"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Graph(302 nodes, 698 edges)\n"
]
}
],
"source": [
"g = london_underground()\n",
"print(g)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Each node in the graph is the latitude, longitude and station name"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(51.5226, -0.1571, 'Baker Street')"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"g.node(11)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(51.5225, -0.1631, 'Marylebone')\n",
"(51.5234, -0.1466, \"Regent's Park\")\n",
"(51.5203, -0.17, 'Edgware Road (C)')\n",
"(51.5238, -0.1439, 'Great Portland Street')\n",
"(51.5142, -0.1494, 'Bond Street')\n",
"(51.5347, -0.174, \"St. John's Wood\")\n",
"(51.5472, -0.1803, 'Finchley Road')\n"
]
}
],
"source": [
"for station_nr in g.nodes(to_node=11):\n",
" print(g.node(station_nr))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's make a map"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[(-0.1571, 51.5226), (-0.1631, 51.5225), (-0.1466, 51.5234)]"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"stations = {station: g.node(station) for station in g.nodes()}\n",
"london_map = Graph()\n",
"for start,end,distance in g.edges():\n",
" lat1,lon1,name1 = stations[start]\n",
" lat2,lon2,name2 = stations[end]\n",
" london_map.add_edge((lon1,lat1), (lon2,lat2))\n",
"\n",
"london_map.nodes()[:3]"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"from graph.visuals import plot_2d"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot = plot_2d(london_map)\n",
"plot.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Not exactly what you expected? Well there's a reason why the London overground map is famous for its readability in comparison to raw latitudes and longitudes."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.11"
}
},
"nbformat": 4,
"nbformat_minor": 4
}