{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Chapter 1: Introduction\n", "\n", "This Sage notebook supplements [Chapter 1 of An Invitation to Enumeration](https://enumeration.ca/basics/introduction/) by Stephen Melczer, available on [enumeration.ca](https://enumeration.ca).\n", "\n", "An introduction to Sage can be downloaded as a [Sage notebook here](https://git.uwaterloo.ca/smelczer/intro-to-sage/-/raw/master/A%20Brief%20Introduction%20to%20Sage.ipynb?inline=false) or as a [static HTML file here](https://melczer.ca/files/SageIntro.html)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Code to Explore\n", "The code in this section helps illustrate topics from the text." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Virhanka-Fibonacci Numbers" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "We can compute v_n by taking a series expansion of the rational function\n" ] }, { "data": { "text/html": [ "\\[\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\verb|F|\\phantom{\\verb!x!}\\verb|=| -\\frac{1}{x^{2} + x - 1}\\]" ], "text/latex": [ "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\verb|F|\\phantom{\\verb!x!}\\verb|=| -\\frac{1}{x^{2} + x - 1}$$" ], "text/plain": [ "'F = ' -1/(x^2 + x - 1)" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "whose series expansion at the origin begins\n", "1 + 1*x + 2*x^2 + 3*x^3 + 5*x^4 + 8*x^5 + Order(x^6)\n" ] } ], "source": [ "print('We can compute v_n by taking a series expansion of the rational function')\n", "F = 1/(1-x-x^2)\n", "show('F = ', F)\n", "print(\"whose series expansion at the origin begins\")\n", "print(F.series(x,6))" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1 + 1*x + 2*x^2 + 3*x^3 + 5*x^4 + 8*x^5 + 13*x^6 + 21*x^7 + 34*x^8 + 55*x^9 + 89*x^10 + 144*x^11 + 233*x^12 + 377*x^13 + 610*x^14 + 987*x^15 + 1597*x^16 + 2584*x^17 + 4181*x^18 + 6765*x^19 + 10946*x^20 + 17711*x^21 + 28657*x^22 + 46368*x^23 + 75025*x^24 + 121393*x^25 + 196418*x^26 + 317811*x^27 + 514229*x^28 + 832040*x^29 + 1346269*x^30 + 2178309*x^31 + 3524578*x^32 + 5702887*x^33 + 9227465*x^34 + 14930352*x^35 + 24157817*x^36 + 39088169*x^37 + 63245986*x^38 + 102334155*x^39 + 165580141*x^40 + 267914296*x^41 + 433494437*x^42 + 701408733*x^43 + 1134903170*x^44 + 1836311903*x^45 + 2971215073*x^46 + 4807526976*x^47 + 7778742049*x^48 + 12586269025*x^49 + 20365011074*x^50 + 32951280099*x^51 + 53316291173*x^52 + 86267571272*x^53 + 139583862445*x^54 + 225851433717*x^55 + 365435296162*x^56 + 591286729879*x^57 + 956722026041*x^58 + 1548008755920*x^59 + 2504730781961*x^60 + 4052739537881*x^61 + 6557470319842*x^62 + 10610209857723*x^63 + 17167680177565*x^64 + 27777890035288*x^65 + 44945570212853*x^66 + 72723460248141*x^67 + 117669030460994*x^68 + 190392490709135*x^69 + 308061521170129*x^70 + 498454011879264*x^71 + 806515533049393*x^72 + 1304969544928657*x^73 + 2111485077978050*x^74 + 3416454622906707*x^75 + 5527939700884757*x^76 + 8944394323791464*x^77 + 14472334024676221*x^78 + 23416728348467685*x^79 + 37889062373143906*x^80 + 61305790721611591*x^81 + 99194853094755497*x^82 + 160500643816367088*x^83 + 259695496911122585*x^84 + 420196140727489673*x^85 + 679891637638612258*x^86 + 1100087778366101931*x^87 + 1779979416004714189*x^88 + 2880067194370816120*x^89 + 4660046610375530309*x^90 + 7540113804746346429*x^91 + 12200160415121876738*x^92 + 19740274219868223167*x^93 + 31940434634990099905*x^94 + 51680708854858323072*x^95 + 83621143489848422977*x^96 + 135301852344706746049*x^97 + 218922995834555169026*x^98 + 354224848179261915075*x^99 + Order(x^100)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We can compute many terms \n", "F.series(x,100)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n" ] } ], "source": [ "# Compare this to terms generated with the recurrence\n", "def fib_rec(n):\n", " if n==0 or n==1:\n", " return 1;\n", " else:\n", " return fib_rec(n-1) + fib_rec(n-2)\n", "\n", "print([fib_rec(k) for k in range(10)])" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "25 loops, best of 3: 11.2 ms per loop" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# However, it is much faster to use the matrix code discussed in the Chapter\n", "M = Matrix(ZZ,2,2,[1,1,1,0]) # matrix with rows [1,1] and [1,0]\n", "def bin_pow(n):\n", " if n == 1: return M\n", " elif n%2 == 0: return bin_pow(n/2)^2\n", " else: return bin_pow((n-1)/2)^2*M\n", "\n", "def fib(n): return add(bin_pow(n)[1])\n", "\n", "timeit('fib(10^6)')\t# compute v_(10^6)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "25 loops, best of 3: 8.63 ms per loop\n", "5 loops, best of 3: 45.9 ms per loop\n" ] } ], "source": [ "# Compared to other methods, the matrix method is much faster\n", "print(timeit('fib_rec(20)')) # 10^2 takes a long time\n", "print(timeit('(1/(1-x-x^2)).series(x,10^4)')) # 10^5 takes a long time" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]\n", "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]\n", "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]\n" ] } ], "source": [ "# Verify all methods give same sequence\n", "print([fib_rec(n) for n in range(20)])\n", "print([k for [k,_] in (1/(1-x-x^2)).series(x,20).coefficients()])\n", "print([1] + [fib(n) for n in range(1,20)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Catalan Numbers" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1 + 1*z + 2*z^2 + 5*z^3 + 14*z^4 + 42*z^5 + 132*z^6 + 429*z^7 + 1430*z^8 + 4862*z^9 + Order(z^10)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# We define the generating function of the Catalan numbers\n", "# First, tell Sage that \"z\" is a variable\n", "var('z') \n", "\n", "# Now define the function and print series coefficients\n", "C = (1 - sqrt(1-4*z))/2/z\n", "C.series(z,10)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862]" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# These coefficients match the formula from the text\n", "[binomial(2*n,n)/(n+1) for n in range(10)]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# If your Sage installation has access to the internet, \n", "# you can look up this sequence by running the command \n", "# oeis([binomial(2*n,n)/(n+1) for n in range(10)])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Code to Generate Material\n", "The code in this section was used to create figures, animations, or results discussed in the text." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Generate Walks in the Quarter Plane" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# First, we define all the functions to compute the walk and plot its output\n", "\n", "# Generate endpoints of random walk using steps in Steps \n", "def walkSum(Steps):\n", " wk = [[0, 0]]\n", " for k in Steps:\n", " wk.append([wk[-1][0]+k[0],wk[-1][1]+k[1]])\n", " return wk\n", "\n", "# Find index walk wk leaves non-negative quadrant\n", "def leaveIndex(wk):\n", " for k in range(len(wk)):\n", " if (wk[k][0]<0) or (wk[k][1]<0):\n", " return k;\n", " return len(wk)+1;\n", "\n", "# Plot the state of the random walk wk at time k\n", "# bd denotes the plot boundaries\n", "def singlePlot(wk, k, bd):\n", " if k < leaveIndex(wk):\n", " oldSteps = line(wk[0:k], color='black', thickness=2)\n", " newSteps = line(wk[k-1:k+1], color='red', thickness=2)\n", " else:\n", " oldSteps = line(wk[0:k], alpha=0.03, color='gray')\n", " newSteps = line(wk[k-1:k+1], alpha=0.03, color='gray', thickness=2)\n", " return oldSteps + newSteps\n", "\n", "# Plot the state of all random walks in WK at time k\n", "# bd denotes the plot boundaries\n", "def singleListPlot(WK, k, bd):\n", " plt = line([])\n", " for wk in WK:\n", " plt += singlePlot(wk,k,bd)\n", " \n", " # Define header text\n", " plt.set_axes_range(xmin=-bd,xmax=bd, ymin=-bd,ymax=bd)\n", " numLeft = len(list(filter(lambda x:leaveIndex(x)>k,WK)))\n", " txt = text(\"Number of steps: %s\" %(k),(0,1.05),axis_coords=True, horizontal_alignment=\"left\")\n", " txt += text(\"Walks in first quadrant: %s\" %(numLeft),(0,1),axis_coords=True,horizontal_alignment=\"left\")\n", " \n", " # Add plots and text, and set boundaries and aspect ratio\n", " plt = plt + txt\n", " plt.set_axes_range(xmin=-bd,xmax=bd, ymin=-bd,ymax=bd)\n", " return plt\n", "\n", "# Sequence of plots of first N steps of the random walks in WK\n", "# bd denotes the plot boundaries\n", "def plotWalk(WK, N, bd):\n", " return [singleListPlot(WK,k,bd) for k in range(1,N+1)]" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 202 graphics primitives" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# This code runs the above functions and animates the results\n", "\n", "# Define set of steps\n", "ST = [[1,0],[-1,0],[0,1],[0,-1]]\n", "\n", "# Define parameters K (number of walks) and N (number of steps)\n", "K = 100\n", "N = 10\n", "\n", "# Generate steps for K random walks of length N \n", "StepSeq = [[choice(ST) for k in range(N)] for j in range(K)]\n", "\n", "# Generate the random walks and find maximum coordinate\n", "WK = [walkSum(Steps) for Steps in StepSeq]\n", "bd = max(flatten(WK))\n", "\n", "# Get sequence of plots and convert to Sage Animation class\n", "ani = animate(plotWalk(WK, N, bd+1))\n", "\n", "# Here we just display the final frame\n", "ani[-1]\n", "\n", "# To save an animation in Sage, need imagemagick installed\n", "# On a Mac with Homebrew, run \"brew install imagemagick\" in the terminal\n", "# Then uncomment and run the following two lines\n", "# (the first should be the path to imagemagick)\n", "\n", "#os.environ[\"PATH\"]+=\":/usr/local/bin\"\n", "#ani.save(\"WalkAnimation.mp4\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Average Runtime of Quicksort" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Function returning average cost of quicksort on random permutation of size n\n", "def qsortcost(n):\n", " return (2*(n+1)*sum([1/k for k in range(1,n+1)]) - 4*n).n()\n", "\n", "# Function returning sorted version of array via quicksort, and number of comparisons used \n", "def qsort(arr):\n", " left = []\n", " equal = []\n", " right = []\n", "\n", " if len(arr) <= 1:\n", " return (arr, 0)\n", " else:\n", " pivot = arr[0]\n", " for x in arr[1:]:\n", " if x < pivot:\n", " left.append(x)\n", " elif x == pivot:\n", " equal.append(x)\n", " elif x > pivot:\n", " right.append(x)\n", " \n", " lsort, lcomp = qsort(left)\n", " rsort, rcomp = qsort(right)\n", " return lsort + equal + rsort, lcomp + rcomp + len(arr)-1\n", "\n", "# Return plot of average comparisons obtained by running quicksort on K random \n", "# permutations of size N, compared to actual average\n", "def qsortExperiment(N,K):\n", " LST = [qsort(Permutations(N).random_element())[1] for _ in range(K)]\n", "\n", " sums = [LST[0]]\n", " for k in LST[1:]:\n", " sums.append(k+sums[-1])\n", "\n", " plt = point([1,sums[0]/1])\n", " for k in range(len(sums)):\n", " plt += point([k+1,sums[k]/(k+1)])\n", " \n", " return plt + line([[0,qsortcost(N)],[K,qsortcost(N)]], color='red')" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 1002 graphics primitives" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "show(qsortExperiment(200,1000),dpi=200)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Euclidean Algorithm Limit Theorem" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "\\[\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\verb|The|\\phantom{\\verb!x!}\\verb|limiting|\\phantom{\\verb!x!}\\verb|density|\\phantom{\\verb!x!}\\verb|for|\\phantom{\\verb!x!}\\verb|the|\\phantom{\\verb!x!}\\verb|Euclidean|\\phantom{\\verb!x!}\\verb|Algorithm|\\phantom{\\verb!x!}\\verb|on|\\phantom{\\verb!x!}\\verb|polynomial|\\phantom{\\verb!x!}\\verb|pairs|\\phantom{\\verb!x!}\\verb|in|\\phantom{\\verb!x!}\\verb|\t| \\Bold{F}_{3}[x] \\phantom{\\verb!x!}\\verb|is|\\phantom{\\verb!x!}\\verb|\t| \\frac{3 \\, e^{\\left(-\\frac{1}{4} \\, n {\\left(\\frac{3 \\, s}{n} - 2\\right)}^{2}\\right)}}{2 \\, \\sqrt{\\pi n}}\\]" ], "text/latex": [ "$$\\newcommand{\\Bold}[1]{\\mathbf{#1}}\\verb|The|\\phantom{\\verb!x!}\\verb|limiting|\\phantom{\\verb!x!}\\verb|density|\\phantom{\\verb!x!}\\verb|for|\\phantom{\\verb!x!}\\verb|the|\\phantom{\\verb!x!}\\verb|Euclidean|\\phantom{\\verb!x!}\\verb|Algorithm|\\phantom{\\verb!x!}\\verb|on|\\phantom{\\verb!x!}\\verb|polynomial|\\phantom{\\verb!x!}\\verb|pairs|\\phantom{\\verb!x!}\\verb|in|\\phantom{\\verb!x!}\\verb|\t| \\Bold{F}_{3}[x] \\phantom{\\verb!x!}\\verb|is|\\phantom{\\verb!x!}\\verb|\t| \\frac{3 \\, e^{\\left(-\\frac{1}{4} \\, n {\\left(\\frac{3 \\, s}{n} - 2\\right)}^{2}\\right)}}{2 \\, \\sqrt{\\pi n}}$$" ], "text/plain": [ "'The limiting density for the Euclidean Algorithm on polynomial pairs in \\t' Univariate Polynomial Ring in x over Finite Field of size 3 ' is \\t' 3/2*e^(-1/4*n*(3*s/n - 2)^2)/sqrt(pi*n)" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Define the polynomial ring GF(p)[x]\n", "# CHANGE THE PRIME HERE IF YOU WANT TO PLAY AROUND\n", "p = 3\n", "R = PolynomialRing(GF(p),'x')\n", "S = Integers(p)\n", "x = R.gen()\n", "\n", "# EASteps(A,B,0) returns the number of steps the Euclidean algorithm \n", "# takes for the polynomials A and B\n", "def EASteps(A,B,steps):\n", " if B == 0: \n", " return steps\n", " (q,r) = A.quo_rem(B)\n", " return EASteps(B,r,steps+1)\n", "\n", "# Generate uniformly random polynomial of degree at most D\n", "def rpol(D):\n", " return add([S.random_element() * x^k for k in range(D+1)])\n", "\n", "# Returns the number of steps the Euclidean algorithm takes for a \n", "# random pair of polynomials with the larger one monic of degree D\n", "def randomEASteps(D):\n", " f = x^D + rpol(D-1)\n", " g = rpol(D-1)\n", " return EASteps(f,g,0)\n", "\n", "# Define limiting density\n", "var('s n P')\n", "density = sqrt(2)*exp(-n*(s/n-1+1/P)^2*P^2/(2*(P-1)))/(2*sqrt(pi*n)*sqrt((P-1)/P^2))\n", "show(\"The limiting density for the Euclidean Algorithm on polynomial pairs in \\t\", R,\" is \\t\", density.subs(P=p))" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 2 graphics primitives" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# First, we just plot the result of dividing random polys compared to limit curve\n", "# Set maximum degree (N) and number of pairs (K) of polynomials to generate\n", "# With the default p = 3, N = 500, and K = 2000 this should take 5 - 10 seconds\n", "# CHANGE N and K HERE IF YOU WANT TO PLAY AROUND\n", "N = 500\n", "K = 2000\n", "\n", "# Generate list of step counts\n", "lst = [randomEASteps(N) for k in range(K)]\n", "\n", "# Plot the count of points\n", "p1 = plot(point([(k,lst.count(k)) for k in range(N)],size=50,marker=\"x\", color=\"black\"))\n", "# Plot the limiting density (scaled to count divisions instead of probabilities)\n", "p2 = plot(K*density.subs(n=N,P=p),(min(lst),max(lst)), color=\"red\", thickness=2)\n", "# Superimpose the plots\n", "pt = p1 + p2\n", "# Set the axes of the plot\n", "pt.axes_range(xmin=min(lst),xmax=max(lst),ymin=0,ymax=pt.get_minmax_data()['ymax'])\n", "# Display the plot on screen\n", "pt" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "Graphics object consisting of 5 graphics primitives" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Now we do the animation\n", "# Returns the number of steps the Euclidean algorithm takes for a \n", "# random pair of polynomials with the larger one monic of degree D\n", "# *and* the polynomials used\n", "def randomEAStepsfg(D):\n", " f = x^D + rpol(D-1)\n", " g = rpol(D-1)\n", " return f,g,EASteps(f,g,0)\n", "\n", "# Set maximum degree (N) and number of pairs (K) of polynomials to generate\n", "# CHANGE N and K HERE IF YOU WANT TO PLAY AROUND\n", "N = 100\n", "K = 2000\n", "\n", "# Generate and record a sequence of K polynomial pairs with max degree N,\n", "# together with the count of divisions performed by the Euclidean Algorithm\n", "f_lst = []\n", "g_lst = []\n", "ct_lst = []\n", "for step in range(K+1):\n", " f, g, ct = randomEAStepsfg(N)\n", " f_lst += [f]\n", " g_lst += [g]\n", " ct_lst += [ct]\n", "\n", "# Generate a list of plots animating the running count of divisions \n", "# compared to the expected count from the limit density\n", "PT = []\n", "ym = -1\n", "for L in range(201):\n", " step = 10*L\n", " p1 = bar_chart([ct_lst[0:step+1].count(k) for k in range(N)], color='gray')\n", " p2 = plot((step+1)*density.subs(n=N,P=p),(min(ct_lst),max(ct_lst)), color=\"red\", thickness=2)\n", " pt = p1 + p2\n", " ym = max(ym,pt.get_minmax_data()['ymax'])\n", " F = f_lst[step]\n", " G = g_lst[step]\n", " pt += text(\"$%s$\" %(\"f(x) = \" + latex(F.lt()) + \"+ \\\\cdots +\" + latex(F.constant_coefficient())),(0.03,1.05),axis_coords=True, horizontal_alignment=\"left\", fontsize=14)\n", " pt += text(\"$%s$\" %(\"g(x) = \" + latex(G.lt()) + \"+ \\\\cdots +\" + latex(G.constant_coefficient())),(0.43,1.05),axis_coords=True, horizontal_alignment=\"left\", fontsize=14)\n", " pt += text(\"$%s$ runs\" %(step+1),(0.83,1.05),axis_coords=True, horizontal_alignment=\"left\", fontsize=14)\n", " pt.axes_range(xmin=min(ct_lst),xmax=max(ct_lst),ymin=0,ymax=ym)\n", " PT += [pt]\n", "\n", "# Generate an animation object from the list of plots\n", "ani = animate(PT)\n", "\n", "# Here we just display the final frame\n", "ani[-1]\n", "\n", "# Output and save the animation -- this *requires* extra software such as ImageMagick or ffmpeg\n", "# Uncomment and run the following line to save the animation\n", "# ani.save(\"EuclidAnimation.mp4\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "SageMath 9.4", "language": "sage", "name": "sagemath-9.4" }, "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.9.5" } }, "nbformat": 4, "nbformat_minor": 4 }