{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Setup\n", "\n", "Once the notebook is started, the package can be imported." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import drg" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The central class is `drg.DRGParameters`, which can be given an intersection array in the form of two lists or tuples of the same length." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {5, 4, 2; 1, 1, 4}" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl = drg.DRGParameters([5, 4, 2], [1, 1, 4])\n", "syl" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of an intersection array, parameters $(k, \\lambda, \\mu)$ for a strongly regular graph or classical parameters $(d, b, \\alpha, \\beta)$ may also be specified." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {3, 2; 1, 1}" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "petersen = drg.DRGParameters(3, 0, 1)\n", "petersen" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {7, 6, 5, 4, 3, 2, 1; 1, 2, 3, 4, 5, 6, 7}" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q7 = drg.DRGParameters(7, 1, 0, 1)\n", "q7" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The intersection array (given in any of the forms above) may also contain variables. Substitution of variables is possible using the `subs` method. Note that the diameter must be constant." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {6, 4, 2; 1, 2, 3}" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "r = var(\"r\")\n", "fam = drg.DRGParameters([2*r^2*(2*r+1), (2*r-1)*(2*r^2+r+1), 2*r^2], [1, 2*r^2, r*(4*r^2-1)])\n", "fam1 = fam.subs(r == 1)\n", "fam1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Parameter computation\n", "\n", "As a `drg.DRGParameters` object is being constructed, its intersection numbers are computed. If any of them is determined to be negative or nonintegral, then an exception is thrown and the construction is aborted. Several other conditions are also checked, for example that the sequences $\\{b_i\\}_{i=0}^d$ and $\\{c_i\\}_{i=0}^d$ are non-ascending and non-descending, respectively, and that $b_j \\ge c_i$ if $i + j \\le d$. The handshake lemma is also checked for each subconstituent. If the graph is determined to be antipodal, then the covering index is also checked for integrality.\n", "\n", "The number of vertices, their valency and the diameter of the graph can be obtained with the `order`, `valency`, and `diameter` methods." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(36, 5, 3)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.order(), syl.valency(), syl.diameter()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The entire array of intersection numbers can be obtained with the `pTable` method, which returns a `drg.Array3D` object implementing a three-dimensional array." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0: [ 1 0 0 0]\n", " [ 0 5 0 0]\n", " [ 0 0 20 0]\n", " [ 0 0 0 10]\n", "\n", "1: [0 1 0 0]\n", " [1 0 4 0]\n", " [0 4 8 8]\n", " [0 0 8 2]\n", "\n", "2: [ 0 0 1 0]\n", " [ 0 1 2 2]\n", " [ 1 2 11 6]\n", " [ 0 2 6 2]\n", "\n", "3: [ 0 0 0 1]\n", " [ 0 0 4 1]\n", " [ 0 4 12 4]\n", " [ 1 1 4 4]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.pTable()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The subsets of intersection numbers $\\{a_i\\}_{i=1}^d$, $\\{b_i\\}_{i=0}^{d-1}$ and $\\{c_i\\}_{i=1}^d$ can be obtained as tuples with the `aTable`, `bTable`, and `cTable` methods, respectively. There is also a method `intersectionArray` returning the entire intersection array as a pair of tuples." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(0, 2, 1)\n", "(5, 4, 2)\n", "(1, 1, 4)\n", "((5, 4, 2), (1, 1, 4))\n" ] } ], "source": [ "print(syl.aTable())\n", "print(syl.bTable())\n", "print(syl.cTable())\n", "print(syl.intersectionArray())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Eigenvalues can be computed using the `eigenvalues` method. They are sorted in the decreasing order; if there is a variable in the intersection array, then the order is derived under the assumption that the variable takes a (large\n", "enough) positive value. If there is more than one variable, a warning is issued that the given ordering is not necessarily correct. This can be avoided by explicitly specifying an order of the variables using the `set_vars` method (see the [DRG-d3-2param.ipynb](DRG-d3-2param.ipynb) notebook for an example). The ordering of eigenvalues (and thus the ordering of corresponding parameters) can also be changed later using the `reorderEigenvalues` method, which accepts an ordering of the indices of the nontrivial eigenvalues (i.e., integers from $1$ to $d$).\n", "\n", "Once the ordering of eigenvalues is determined, the cosine sequences and multiplicities of the eigenvalues can be computed using the `cosineSequences` and `multiplicities` methods. The multiplicities are checked to be integral." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(5, 2, -1, -3)\n", "(1, 16, 10, 9)\n", "[ 1 1 1 1]\n", "[ 1 2/5 -1/20 -1/5]\n", "[ 1 -1/5 -1/5 2/5]\n", "[ 1 -3/5 1/5 -1/5]\n" ] } ], "source": [ "print(syl.eigenvalues())\n", "print(syl.multiplicities())\n", "print(syl.cosineSequences())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The eigenmatrix and dual eigenmatrix can be computed using the `eigenmatrix` and `dualEigenmatrix` methods. The `is_formallySelfDual` method checks whether the two matrices are equal (using the current ordering of eigenvalues)." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 1 5 20 10]\n", "[ 1 2 -1 -2]\n", "[ 1 -1 -4 4]\n", "[ 1 -3 4 -2]\n", "[ 1 16 10 9]\n", "[ 1 32/5 -2 -27/5]\n", "[ 1 -4/5 -2 9/5]\n", "[ 1 -16/5 4 -9/5]\n", "False\n" ] } ], "source": [ "print(syl.eigenmatrix())\n", "print(syl.dualEigenmatrix())\n", "print(syl.is_formallySelfDual())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The Krein parameters can be computed using the `kreinParameters` method, which returns a `drg.Array3D` object. The Krein parameters are checked to be nonnegative." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0: [ 1 0 0 0]\n", " [ 0 16 0 0]\n", " [ 0 0 10 0]\n", " [ 0 0 0 9]\n", "\n", "1: [ 0 1 0 0]\n", " [ 1 44/5 22/5 9/5]\n", " [ 0 22/5 2 18/5]\n", " [ 0 9/5 18/5 18/5]\n", "\n", "2: [ 0 0 1 0]\n", " [ 0 176/25 16/5 144/25]\n", " [ 1 16/5 4 9/5]\n", " [ 0 144/25 9/5 36/25]\n", "\n", "3: [ 0 0 0 1]\n", " [ 0 16/5 32/5 32/5]\n", " [ 0 32/5 2 8/5]\n", " [ 1 32/5 8/5 0]" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.kreinParameters()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Classical parameters can be computed using the `is_classical` method, which returns a list of all tuples of classical parameters, or `False` if the graph is not classical." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(3, 1, 0, 2)]" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fam1.is_classical()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The method `genPoly_parameters` returns the tuple $(g, s, t)$ if the parameters correspond to those of a collinearity graph of a generalized $g$-gon of order $(s, t)$, or `(False, None, None)` if there is no such generalized $g$-gon." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(6, 2, 2)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "drg.DRGParameters([6, 4, 4], [1, 1, 3]).genPoly_parameters()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the existence of a strongly regular graph for which $(g, s, t)$ are defined does not imply the existence of a corresponding generalized quadrangle. A distance-regular graph $\\Gamma$ of diameter at least $3$ has these parameters defined precisely when $\\Gamma$ is isomorphic to the collinearity graph of a corresponding generalized $g$-gon.\n", "\n", "All the methods mentioned above store their results, so subsequent calls will not redo the computations. Note that one does not need to call the methods in the order given here - if some required computation has not been done before, it will be performed when needed. Where applicable, the methods above also take three named boolean parameters `expand`, `factor`, and `simplify` (all set to `False` by default), which control how the returned expression(s) will be manipulated. In the case when there are no variables in use, setting these parameters has no effect." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Parameters of derived graphs\n", "\n", "In some cases, the parameters of a distance-regular graph imply the existence of another distance-regular graph which can be derived from the original graph. This is true for imprimitive graphs (i.e., antipodal or bipartite), but sometimes, new distance-regular graphs can be obtained by taking subgraphs or by merging classes.\n", "\n", "The antipodality of a graph can be checked with the `is_antipodal` method, which returns the covering index for antipodal graphs, and `False` otherwise. The parameters of the antipodal quotient of an antipodal graph can then be obtained with the `antipodalQuotient` method." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n" ] }, { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {7, 6, 5; 1, 2, 3}" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(q7.is_antipodal())\n", "q7.antipodalQuotient()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The bipartiteness of a graph can be checked with the `is_bipartite` method. The parameters of the bipartite half of a bipartite graph can then be obtained with the `bipartiteHalf` method." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n" ] }, { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {21, 10, 3; 1, 6, 15}" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(q7.is_bipartite())\n", "q7.bipartiteHalf()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In some cases, distance-regularity of the local graph can be established (for instance, for tight graphs). In these cases, the parameters of the local graph can then be obtained with the `localGraph` method." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {16, 5; 1, 8}" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "drg.DRGParameters([27, 10, 1], [1, 10, 27]).localGraph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, the distance-regularity of a subconstituent (i.e., a graph induced by vertices at a given distance from a vertex) can be established in certain cases. Their parameters can be obtained using the `subconstituent` method. Usually, distance-regularity is derived from triple intersection numbers (see below), which are not computed by default. To force this computation, the parameter `compute` can be set to `True`." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {144, 125, 32, 1; 1, 8, 125, 144}" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "drg.DRGParameters([204, 175, 48, 1], [1, 12, 175, 204]).subconstituent(2, compute = True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that calling `localGraph()` is equivalent to calling `subconstituent(1)`. The `localGraph` method also accepts the `compute` parameter.\n", "\n", "The complement of a strongly regular graph is also strongly regular. If the complement is connected, its parameters can be obtained with the `complementaryGraph` method." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {6, 2; 1, 4}" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "petersen.complementaryGraph()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Sometimes, merging classes of the underlying association scheme yields a new distance-regular graph. Its parameters (or the parameters of a connected component if the resulting graph is disconnected) can be obtained with the `mergeClasses` method, which takes the indices of classes which will be merged into the first class of the new scheme (i.e., the distances in the original graph which will correspond to adjacency in the new graph)." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parameters of a distance-regular graph with intersection array {63, 30, 1; 1, 30, 63}" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q7.mergeClasses(2, 3, 6)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that `mergeClasses(2)` gives the parameters of the bipartite half for bipartite graphs, and of the complement for non-antipodal strongly regular graphs.\n", "\n", "A dictionary mapping the merged indices to parameters of a new graphs for all possibilities can be obtained using the `distanceGraphs` method." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{(1,\n", " 2): Parameters of a distance-regular graph with intersection array {28, 15, 6, 1; 1, 6, 15, 28},\n", " (1,\n", " 2,\n", " 3,\n", " 4,\n", " 5,\n", " 6): Parameters of a distance-regular graph with intersection array {126, 1; 1, 126},\n", " (1,\n", " 3,\n", " 5): Parameters of a distance-regular graph with intersection array {63, 62, 1; 1, 62, 63},\n", " (1,\n", " 3,\n", " 5,\n", " 7): Parameters of a distance-regular graph with intersection array {64, 63; 1, 64},\n", " (1,\n", " 4,\n", " 5): Parameters of a distance-regular graph with intersection array {63, 32, 1; 1, 32, 63},\n", " (1,\n", " 5): Parameters of a distance-regular graph with intersection array {28, 27, 16; 1, 12, 28},\n", " (1,\n", " 7): Parameters of a distance-regular graph with intersection array {8, 7, 6, 5; 1, 2, 3, 8},\n", " (2,): Parameters of a distance-regular graph with intersection array {21, 10, 3; 1, 6, 15},\n", " (2,\n", " 3,\n", " 6): Parameters of a distance-regular graph with intersection array {63, 30, 1; 1, 30, 63},\n", " (2,\n", " 4,\n", " 6): Parameters of a distance-regular graph with intersection array {63; 1},\n", " (2,\n", " 6): Parameters of a distance-regular graph with intersection array {28, 15; 1, 12},\n", " (3,\n", " 7): Parameters of a distance-regular graph with intersection array {36, 35, 16; 1, 20, 36},\n", " (4,): Parameters of a distance-regular graph with intersection array {35, 16; 1, 20},\n", " (6,): Parameters of a distance-regular graph with intersection array {7, 6, 5; 1, 2, 3},\n", " (7,): Parameters of a distance-regular graph with intersection array {1; 1}}" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "q7.distanceGraphs()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Feasibility checking\n", "\n", "To check whether a given parameter set is feasible, the `check_feasible` method may be called. This method calls other `check_*` methods which perform the actual checks. Selected checks may also be skipped by providing a parameter skip with a list of strings identifying checks to be skipped.\n", "\n", "The following checks are available (see article for a detailed description):\n", "\n", "* `sporadic`: sporadic nonexistence results,\n", "* `family`: nonexistence results for families of intersection arrays,\n", "* `2graph`: checks related to $2$-graphs and Taylor graphs,\n", "* `classical`: nonexistence results for families of intersection arrays with classical parameters,\n", "* `combinatorial`: conditions derived from combinatorial arguments,\n", "* `conference`: checks for conference graphs,\n", "* `geodeticEmbedding`: checks related to geodetic embeddings,\n", "* `2design`: checks related to $2$-designs,\n", "* `hadamard`: checks related to Hadamard matrices,\n", "* `antipodal`: checks related to antipodal covers,\n", "* `genPoly`: checks related to generalized polygons,\n", "* `clawBound`: claw bound check (Brouwer & Van Lint),\n", "* `terwilliger`: checks related to Terwilliger graphs,\n", "* `secondEigenvalue`: checks related to the second largest eigenvalue,\n", "* `localEigenvalue`: checks related to the eigenvalues of local graphs,\n", "* `absoluteBound`: absolute bound checking on eigenvalue multiplicities.\n", "\n", "After running all the checks described above, the `check_feasbile` method calls itself on all already derived graphs (antipodal quotient, bipartite half, complement, $2$-graph derivation where applicable), and then also on each parameter set for distance-regular graphs obtained by merging classes. To avoid repetitions, a list of checked intersection arrays is maintained. This step can be skipped by setting the derived parameter to `False`.\n", "\n", "If the parameter set is feasible (i.e., it passes all checks), then `check_feasible` returns without error. Otherwise, a `drg.InfeasibleError` exception is thrown indicating the reason for nonexistence and providing a reference." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "ename": "InfeasibleError", "evalue": "complement: nonexistence by GavrilyukMakhnev05", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mInfeasibleError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdrg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mDRGParameters\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mInteger\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m266\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mInteger\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m220\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mInteger\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m210\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_feasible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m/home/janos/repos/git/sage-drg/jupyter/drg/drg.pyc\u001b[0m in \u001b[0;36mcheck_feasible\u001b[0;34m(self, checked, skip, derived)\u001b[0m\n\u001b[1;32m 689\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomplement\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcheck_feasible\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchecked\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 690\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mInfeasibleError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mAssertionError\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mex\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 691\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mInfeasibleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpart\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"complement\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 692\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mia\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpart\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistance_graphs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mitems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 693\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mInfeasibleError\u001b[0m: complement: nonexistence by GavrilyukMakhnev05" ] } ], "source": [ "drg.DRGParameters(266, 220, 210).check_feasible()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Details on the given references are available in the `drg.references` submodule." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'authors': [('Gavrilyuk', ('Alexander', 'L.')),\n", " ('Makhnev', ('Alexander', 'Alexeevich'))],\n", " 'fjournal': 'Doklady Akademii Nauk',\n", " 'journal': 'Dokl. Akad. Nauk',\n", " 'number': 6,\n", " 'pages': (727, 730),\n", " 'title': 'Krein graphs without triangles',\n", " 'type': 'article',\n", " 'volume': 403,\n", " 'year': 2005}" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import drg.references\n", "drg.references.refs[\"GavrilyukMakhnev05\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Details on the nonexistence may also be extracted from the exception." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Part: ()\n", "Reason : coclique bound exceeded\n", "Authors : [('Koolen', ('Jack', 'H.')), ('Park', ('Jongyook',))]\n", "Title : Shilla distance-regular graphs\n", "Theorem : Thm. 3.\n" ] } ], "source": [ "try:\n", " drg.DRGParameters([65, 44, 11], [1, 4, 55]).check_feasible()\n", "except drg.InfeasibleError as ex:\n", " print(\"Part: %s\" % (ex.part, ))\n", " print(\"Reason : %s\" % ex. reason)\n", " for r, thm in ex.refs:\n", " ref = drg.references.refs[r]\n", " print(\"Authors : %s\" % ref[\"authors\"])\n", " print(\"Title : %s\" % ref[\"title\"])\n", " print(\"Theorem : %s\" % thm)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Partitions and triple intersection numbers\n", "\n", "For a given parameter set, the distance partition corresponding to a vertex can be obtained with the `distancePartition` method, which returns a graph representing the distance partition." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Distance partition of {5, 4, 2; 1, 1, 4}" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.distancePartition()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A distance partition corresponding to two vertices can be obtained by passing the distance between them as an argument to `distancePartition`." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "1-distance partition of {5, 4, 2; 1, 1, 4}" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.distancePartition(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that edges are shown between any pair of cells such that their distances from either of the initial vertices differ by at most $1$. To show all the distance partitions corresponding to at most two vertices, the `show_distancePartitions` may be used (see below).\n", "\n", "For a given triple of distances $(U, V, W)$ such that $p^W_{UV} > 0$, the method `tripleEquations` gives the solution to the system of equations relating triple intersection numbers to the intersection numbers, augmented by equations derived from the Krein condition for each triple $(i, j, h)$ $(1 \\le i, j, h \\le d)$ such that $q^h_{ij} = 0$. The solution is\n", "returned as a `drg.Array3D` object." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0: [0 0 0 0]\n", " [0 1 0 0]\n", " [0 0 0 0]\n", " [0 0 0 0]\n", "\n", "1: [0 0 1 0]\n", " [0 0 0 0]\n", " [1 0 3 0]\n", " [0 0 0 0]\n", "\n", "2: [0 0 0 0]\n", " [0 0 2 2]\n", " [0 2 2 4]\n", " [0 2 4 2]\n", "\n", "3: [0 0 0 0]\n", " [0 0 0 0]\n", " [0 0 6 2]\n", " [0 0 2 0]" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.tripleEquations(1, 1, 2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the solution is not unique, one or more parameters will be present in the solution." ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0: [0 0 0 0]\n", " [0 0 1 0]\n", " [0 0 0 0]\n", " [0 0 0 0]\n", "\n", "1: [0 0 0 1]\n", " [0 0 0 0]\n", " [0 1 2 1]\n", " [0 0 0 0]\n", "\n", "2: [ 0 0 0 0]\n", " [ 0 0 3 1]\n", " [ 0 r2 r2 + 4 -2*r2 + 4]\n", " [ 1 -r2 + 2 -r2 + 4 2*r2 + 1]\n", "\n", "3: [ 0 0 0 0]\n", " [ 0 0 0 0]\n", " [ 0 -r2 + 3 -r2 + 6 2*r2 - 1]\n", " [ 0 r2 - 1 r2 -2*r2 + 3]" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.tripleEquations(1, 2, 3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Parameters may also be set explicitly by passing a `params` argument with a dictionary mapping the name of the parameter to the triple of distances it represents." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0: [0 0 0 0]\n", " [0 0 0 1]\n", " [0 0 0 0]\n", " [0 0 0 0]\n", "\n", "1: [0 0 0 1]\n", " [0 0 0 0]\n", " [0 0 4 0]\n", " [0 0 0 0]\n", "\n", "2: [ 0 0 0 0]\n", " [ 0 0 4 0]\n", " [ 0 -1/2*a + 4 -1/2*a + 4 a]\n", " [ 0 1/2*a 1/2*a + 4 -a + 4]\n", "\n", "3: [ 0 0 0 0]\n", " [ 0 0 0 0]\n", " [ 0 1/2*a 1/2*a + 4 -a + 4]\n", " [ 1 -1/2*a + 1 -1/2*a a]" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "syl.tripleEquations(1, 3, 3, params = {\"a\": (3, 3, 3)})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If the appropriate triple intersection number is computed to be zero, an edge will not be shown in the distance partition." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 8 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 22 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 34 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 28 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "syl.show_distancePartitions()" ] } ], "metadata": { "celltoolbar": "Raw Cell Format", "kernelspec": { "display_name": "SageMath 8.2.beta8", "language": "", "name": "sagemath" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 2 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython2", "version": "2.7.14" } }, "nbformat": 4, "nbformat_minor": 2 }