{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "bUtVZFq-qXoU" }, "source": [ "# Multiary Complex Model of GPCR Signaling Activations\n", "\n", "This notebook is the Supplemental Material for ``Watabe et al. Multiary complex formations in GPCR signaling activations. arXiv:xxx.xxxxxx (2020)\"." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "colab": {}, "colab_type": "code", "id": "GfhizJYLqXoj" }, "outputs": [], "source": [ "# Multiary Complex Model in GPCR signaling activation\n", "import os\n", "import sys\n", "import numpy\n", "\n", "%matplotlib inline\n", "import matplotlib.pylab as plt\n", "\n", "from ecell4.prelude import *" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "n3Ind7RzqvPU" }, "source": [ "## Parameters" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": {}, "colab_type": "code", "id": "Tj93vmz4qgUo" }, "outputs": [], "source": [ "class ParConfigs() :\n", "\n", " '''\n", " Set Parameters\n", " '''\n", "\n", " # Set model parameters \n", " def __init__(self, user_configs_dict = None):\n", "\n", " self.A = 10000. # Cell-Area: µm^2\n", " self.T = 4.977 # Receptor concetration: receptors/µm^2\n", " self.r0 = int(self.T*self.A)\n", "\n", " # ligand-receptor first-order interactions\n", " # Phi <==> M\n", " # Phi' <==> M'\n", " # M' <==> D'\n", " # dissociation rates\n", " self.dl0 = 1.00 # 1/sec\n", " self.dl1 = 1.00 # 1/sec\n", " self.dl2 = 1.00 # 1/sec\n", "\n", " # equilibrium constants\n", " self.Kl0 = 1.00 # nM\n", " self.Kl1 = None\n", " self.Kl2 = None\n", "\n", " # receptor-Gprotein first-order interactions\n", " # Phi <==> G Phi\n", " # Phi' <==> G Phi'\n", " # dissociation rates\n", " self.dg0 = 1.00 # 1/sec\n", " self.dg1 = 1.00 # 1/sec\n", " \n", " # equilibrium constants\n", " self.Kg0 = 1.00 # nM\n", " self.Kg1 = None\n", " \n", " # ligand-(receptor-Gprotein) first-order interactions\n", " # G Phi <==> G M\n", " # G Phi' <==> G M'\n", " # G M' <==> G D'\n", " # dissociation rates\n", " self.da0 = 1.00 # 1/sec\n", " self.da1 = 1.00 # 1/sec\n", " self.da2 = 1.00 # 1/sec\n", " \n", " # equilibrium constants\n", " self.Ka0 = 1.00 # nM\n", " self.Ka1 = None\n", " self.Ka2 = None\n", " \n", " # Gprotein-(ligand-receptor) first-order interactions \n", " # M <==> G M\n", " # M' <==> G M'\n", " # D' <==> G D'\n", " # dissociation rates\n", " self.db0 = 1.00 # 1/sec\n", " self.db1 = 1.00 # 1/sec\n", " self.db2 = 1.00 # 1/sec\n", " \n", " # equilibrium constants\n", " self.Kb0 = 1.00 # nM\n", " self.Kb1 = None\n", " self.Kb2 = None\n", " \n", " # receptor-receptor interactions:\n", " # Phi + Phi <==> Phi'\n", " # M + Phi <==> M'\n", " # M + M <==> D'\n", " # dissociation rates\n", " self.dx0 = 1.00 # 1/sec\n", " self.dx1 = 1.00 # 1/sec\n", " self.dx2 = 1.00 # 1/sec\n", "\n", " # equilibrium constants\n", " self.Kx0 = None\n", " self.Kx1 = None\n", " self.Kx2 = None\n", "\n", " # receptor-Gprotein coupling\n", " # G Phi + Phi <==> G Phi'\n", " # G M + Phi <==> G M'\n", " # G Phi + M <==> G M'\n", " # G M + M <==> G D'\n", " # dissociation rates\n", " self.dy0 = 1.00 # 1/sec\n", " self.dy1 = 1.00 # 1/sec\n", " self.dy2 = 1.00 # 1/sec\n", " self.dy3 = 1.00 # 1/sec\n", "\n", " # equilibrium constants\n", " self.Ky0 = None\n", " self.Ky1 = None\n", " self.Ky2 = None\n", " self.Ky3 = None\n", "\n", " def get_r0(self):\n", "\n", " r0 = self.r0\n", "\n", " return r0\n", "\n", " def get_dl(self):\n", "\n", " dl0 = self.dl0\n", " dl1 = self.dl1\n", " dl2 = self.dl2\n", "\n", " return dl0, dl1, dl2\n", "\n", " def get_kl(self, sigma_l1, sigma_l2):\n", "\n", " self.Kl1 = sigma_l1*self.Kl0\n", " self.Kl2 = sigma_l2*self.Kl0\n", "\n", " kl0 = self.dl0/self.Kl0 # 1/(sec nM)\n", " kl1 = self.dl1/self.Kl1 # 1/(sec nM)\n", " kl2 = self.dl2/self.Kl2 # 1/(sec nM)\n", "\n", " return kl0, kl1, kl2\n", "\n", " def get_dg(self):\n", "\n", " dg0 = self.dg0\n", " dg1 = self.dg1\n", "\n", " return dg0, dg1\n", "\n", " def get_kg(self, sigma_g1):\n", "\n", " self.Kg1 = sigma_g1*self.Kg0\n", "\n", " kg0 = self.dg0/self.Kg0\n", " kg1 = self.dg1/self.Kg1\n", "\n", " return kg0, kg1\n", "\n", " def get_da(self):\n", "\n", " da0 = self.da0\n", " da1 = self.da1\n", " da2 = self.da2\n", "\n", " return da0, da1, da2\n", "\n", " def get_ka(self, alpha, sigma_a1, sigma_a2):\n", "\n", " self.Ka0 = alpha*self.Kl0\n", " self.Ka1 = sigma_a1*self.Ka0\n", " self.Ka2 = sigma_a2*self.Ka0\n", "\n", " ka0 = self.da0/self.Ka0\n", " ka1 = self.da1/self.Ka1\n", " ka2 = self.da2/self.Ka2\n", "\n", " return ka0, ka1, ka2\n", "\n", " def get_db(self):\n", "\n", " db0 = self.db0\n", " db1 = self.db1\n", " db2 = self.db2\n", "\n", " return db0, db1, db2\n", "\n", " def get_kb(self, beta, sigma_b1, sigma_b2):\n", "\n", " self.Kb0 = beta*self.Kg0\n", " self.Kb1 = sigma_b1*self.Kb0\n", " self.Kb2 = sigma_b2*self.Kb0\n", "\n", " kb0 = self.db0/self.Kb0\n", " kb1 = self.db1/self.Kb1\n", " kb2 = self.db2/self.Kb2\n", "\n", " return kb0, kb1, kb2\n", "\n", " def get_dx(self):\n", "\n", " dx0 = self.dx0\n", " dx1 = self.dx1\n", " dx2 = self.dx2\n", "\n", " return dx0, dx1, dx2\n", "\n", " def get_kx(self, kx, N):\n", "\n", " self.Kx0 = self.T/kx # 1/µm^2\n", " self.Kx1 = (self.Kl1*self.Kx0)/self.Kl0 # 1/µm^2\n", " self.Kx2 = (self.Kl2*self.Kl1*self.Kx0)/(self.Kl0**2) # 1/µm^2\n", "\n", " kx0 = self.dx0/self.Kx0 # µm^2/sec\n", " kx1 = self.dx1/self.Kx1 # µm^2/sec\n", " kx2 = self.dx2/self.Kx2 # µm^2/sec\n", "\n", " return kx0/N, kx1/N, kx2/N\n", "\n", " def get_dy(self):\n", "\n", " dy0 = self.dy0\n", " dy1 = self.dy1\n", " dy2 = self.dy2\n", " dy3 = self.dy3\n", "\n", " return dy0, dy1, dy2, dy3\n", "\n", " def get_ky(self, sigma_y0, sigma_y1, sigma_y2, sigma_y3):\n", "\n", " self.Ky0 = sigma_y0*self.Kx0\n", " self.Ky1 = sigma_y1*self.Kx1\n", " self.Ky2 = sigma_y2*self.Kx1\n", " self.Ky3 = sigma_y3*self.Kx2\n", "\n", " ky0 = self.dy0/self.Ky0 # µm^2/sec\n", " ky1 = self.dy1/self.Ky1 # µm^2/sec\n", " ky2 = self.dy2/self.Ky2 # µm^2/sec\n", " ky3 = self.dy3/self.Ky3 # µm^2/sec\n", "\n", " return ky0, ky1, ky2, ky3\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": {}, "colab_type": "code", "id": "gqYkBQ2YtN3M" }, "outputs": [], "source": [ "def run_N0(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1]\n", " RM = numpy.zeros(shape=(len(time)))\n", " RD = obs_data[:,2]\n", " G0 = obs_data[:,3]\n", " GM = obs_data[:,4]\n", " GD = numpy.zeros(shape=(len(time)))\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", "id": "LXZ_VA4G2XWg" }, "outputs": [], "source": [ "def run_N1(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1] + obs_data[:,2]\n", " RM = obs_data[:,3] + obs_data[:,4]\n", " RD = obs_data[:,5]\n", " G0 = obs_data[:,6] + obs_data[:,7]\n", " GM = obs_data[:,8] + obs_data[:,9]\n", " GD = obs_data[:,10]\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": {}, "colab_type": "code", "id": "ivHjmoQQ2t9U" }, "outputs": [], "source": [ "def run_N2(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1] + obs_data[:,2] + obs_data[:,3] + obs_data[:,4]\n", " RM = obs_data[:,5] + obs_data[:,6] + obs_data[:,7] + obs_data[:,8]\n", " RD = obs_data[:,9] + obs_data[:,10] + obs_data[:,11]\n", " G0 = obs_data[:,12] + obs_data[:,13] + obs_data[:,14] + obs_data[:,15]\n", " GM = obs_data[:,16] + obs_data[:,17] + obs_data[:,18] + obs_data[:,19]\n", " GD = obs_data[:,20] + obs_data[:,21] + obs_data[:,22]\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": {}, "colab_type": "code", "id": "cYEv1xLK28rJ" }, "outputs": [], "source": [ "def run_N3(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1] + obs_data[:,2] + obs_data[:,3] + obs_data[:,4] + obs_data[:,5] + obs_data[:,6]\n", " RM = obs_data[:,7] + obs_data[:,8] + obs_data[:,9] + obs_data[:,10] + obs_data[:,11] + obs_data[:,12]\n", " RD = obs_data[:,13] + obs_data[:,14] + obs_data[:,15] + obs_data[:,16] + obs_data[:,17]\n", " G0 = obs_data[:,18] + obs_data[:,19] + obs_data[:,20] + obs_data[:,21] + obs_data[:,22] + obs_data[:,23]\n", " GM = obs_data[:,24] + obs_data[:,25] + obs_data[:,26] + obs_data[:,27] + obs_data[:,28] + obs_data[:,29]\n", " GD = obs_data[:,30] + obs_data[:,31] + obs_data[:,32] + obs_data[:,33] + obs_data[:,34]\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "colab": {}, "colab_type": "code", "id": "ePecXuPb3MnW" }, "outputs": [], "source": [ "def run_N4(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1] + obs_data[:,2] + obs_data[:,3] + obs_data[:,4] + obs_data[:,5] + obs_data[:,6] + obs_data[:,7] + obs_data[:,8]\n", " RM = obs_data[:,9] + obs_data[:,10] + obs_data[:,11] + obs_data[:,12] + obs_data[:,13] + obs_data[:,14] + obs_data[:,15] + obs_data[:,16]\n", " RD = obs_data[:,17] + obs_data[:,18] + obs_data[:,19] + obs_data[:,20] + obs_data[:,21] + obs_data[:,22] + obs_data[:,23]\n", " G0 = obs_data[:,24] + obs_data[:,25] + obs_data[:,26] + obs_data[:,27] + obs_data[:,28] + obs_data[:,29] + obs_data[:,30] + obs_data[:,31]\n", " GM = obs_data[:,32] + obs_data[:,33] + obs_data[:,34] + obs_data[:,35] + obs_data[:,36] + obs_data[:,37] + obs_data[:,38] + obs_data[:,39]\n", " GD = obs_data[:,40] + obs_data[:,41] + obs_data[:,42] + obs_data[:,43] + obs_data[:,44] + obs_data[:,45] + obs_data[:,46]\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", "id": "iI_GMdoc3a-B" }, "outputs": [], "source": [ "def run_N5(m, mols, obs0):\n", " # Create simulator (ODE)\n", " w = ode.World()\n", " w.bind_to(m)\n", " sim = ode.Simulator(w)\n", "\n", " # Initialization\n", " print (\"Initial condition\")\n", " for i in range(len(mols)) :\n", " obs0_i = int(round(obs0[i]))\n", " w.add_molecules(Species(\"%s\" % (mols[i])), obs0_i)\n", " print (mols[i], ':', obs0_i)\n", "\n", " sim.initialize()\n", "\n", " # Run simulator\n", " period = 50. # sec\n", "\n", " obs = FixedIntervalNumberObserver(1.0, mols)\n", " sim.run(period, [obs])\n", " obs_data = numpy.array(obs.data())\n", "\n", " time = obs_data[:,0]\n", " R0 = obs_data[:,1] + obs_data[:,2] + obs_data[:,3] + obs_data[:,4] + obs_data[:,5] + obs_data[:,6] + obs_data[:,7] + obs_data[:,8] + obs_data[:,9] + obs_data[:,10]\n", " RM = obs_data[:,11] + obs_data[:,12] + obs_data[:,13] + obs_data[:,14] + obs_data[:,15] + obs_data[:,16] + obs_data[:,17] + obs_data[:,18] + obs_data[:,19] + obs_data[:,20]\n", " RD = obs_data[:,21] + obs_data[:,22] + obs_data[:,23] + obs_data[:,24] + obs_data[:,25] + obs_data[:,26] + obs_data[:,27] + obs_data[:,28] + obs_data[:,29]\n", " G0 = obs_data[:,30] + obs_data[:,31] + obs_data[:,32] + obs_data[:,33] + obs_data[:,34] + obs_data[:,35] + obs_data[:,36] + obs_data[:,37] + obs_data[:,38] + obs_data[:,39]\n", " GM = obs_data[:,40] + obs_data[:,41] + obs_data[:,42] + obs_data[:,43] + obs_data[:,44] + obs_data[:,45] + obs_data[:,46] + obs_data[:,47] + obs_data[:,48] + obs_data[:,49]\n", " GD = obs_data[:,50] + obs_data[:,51] + obs_data[:,52] + obs_data[:,53] + obs_data[:,54] + obs_data[:,55] + obs_data[:,56] + obs_data[:,57] + obs_data[:,58]\n", "\n", " data = obs_data.T\n", "\n", " plt.plot(data[0], RM+RD+GM+GD, \"b-\", label=\"Bound states\")\n", " plt.plot(data[0], RM, \"-\", label=\"M\")\n", " plt.plot(data[0], RD, \"-\", label=\"D\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•M\")\n", " plt.plot(data[0], GM, \"-\", label=\"G•D\")\n", "\n", " plt.xlabel(\"Time [sec]\")\n", " plt.ylabel(\"Bounds\")\n", " plt.xlim(data[0][0], data[0][-1])\n", " plt.legend(loc=\"best\", shadow=True)\n", " plt.show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "yXi79P5sqXod" }, "source": [ "## The simplest ternary complex model (kx = 0)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 170 }, "colab_type": "code", "id": "34Is0yc9qXo9", "outputId": "d0a3f2c8-834e-43ea-d209-1fea35eb80d1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model-order: N = 0.0\n", "Ligand: L = 1.0\n", "G-protein: G = 1.0\n", "alpha-factor: a = 1.0\n", "Initial condition:\n", " r : 49770.0\n", " R : 0.0\n", " Gr : 0.0\n", " GR : 0.0\n" ] } ], "source": [ "# this is the ternary complex model (TCM): N=0\n", "N = 0.00\n", "\n", "# Inputs :\n", "# Ligand and G-protein concentrations\n", "L = 1.00\n", "G = 1.00\n", "\n", "# scaling factor\n", "alpha = 1.00\n", "\n", "# The lumped dimensionless parameter\n", "kx = 0.00\n", "\n", "mols = [\"r\", \"R\", \"Gr\", \"GR\"]\n", "\n", "par = ParConfigs()\n", "\n", "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "\n", "###############################################################\n", "print ('Model-order: N =', N)\n", "print ('Ligand: L =', L)\n", "print ('G-protein: G =', G)\n", "print ('alpha-factor: a =', alpha)\n", "print ('Initial condition:')\n", "for i in range(len(mols)) :\n", " print (' ', mols[i], ': ', obs0[i])\n", "###############################################################\n", "\n", "# ligands-receptors first-order coupling\n", "dl0, dl1, dl2 = par.get_dl()\n", "kl0, kl1, kl2 = par.get_kl(100, 100)\n", "\n", "# Gproteins-receptors first-order coupling\n", "dg0, dg1 = par.get_dg()\n", "kg0, kg1 = par.get_kg(100)\n", "\n", "# ligand-(Gproteins-receptors) first-order coupling\n", "da0, da1, da2 = par.get_da()\n", "ka0, ka1, ka2 = par.get_ka(alpha, 100, 100)\n", "\n", "# Gproteins-(ligand-receptors) first-order coupling\n", "db0, db1, db2 = par.get_db()\n", "kb0, kb1, kb2 = par.get_kb(alpha, 100, 100)\n", "\n", "## receptor-receptor second-order coupling\n", "#dx0, dx1, dx2 = par.get_dx()\n", "#kx0, kx1, kx2 = par.get_kx(kx, N)\n", "#\n", "## receptor-Gprotein second-order coupling\n", "#dy0, dy1, dy2, dy3 = par.get_dy()\n", "#ky0, ky1, ky2, ky3 = par.get_ky(1, 1, 1, 1)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 170 }, "colab_type": "code", "id": "-jIS0Fy_qXpM", "outputId": "92e61e26-1206-401e-962b-d1e0b8a53475", "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 364 }, "colab_type": "code", "id": "4LywjmpxtmcK", "outputId": "4c7258b8-6c64-430f-d838-2c95654aef4c" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "R : 0\n", "Gr : 0\n", "GR : 0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "run_N0(m, mols, obs0)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "zyBZZaKBqXp_" }, "source": [ "## The multiary complex model" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "zpyN2DqXqXp_" }, "source": [ "### Monovalent model (N = 1 and kx > 0)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 272 }, "colab_type": "code", "id": "UKgHrXzCqXqB", "outputId": "895c2425-b6aa-4fe6-e9a7-d01d6553a583" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model-order: N = 1.0\n", "Ligand: L = 1.0\n", "G-protein: G = 1.0\n", "alpha-factor: a = 1.0\n", "Initial condition:\n", " r : 49770.0\n", " rr : 0.0\n", " R : 0.0\n", " rR : 0.0\n", " RR : 0.0\n", " Gr : 0.0\n", " Grr : 0.0\n", " GR : 0.0\n", " GrR : 0.0\n", " GRR : 0.0\n" ] } ], "source": [ "# this is the monovalent model : N=1\n", "N = 1.00\n", "\n", "# Inputs :\n", "# Ligand and G-protein concentrations\n", "L = 1.00\n", "G = 1.00\n", "\n", "# scaling factor\n", "alpha = 1.00\n", "\n", "# The lumped dimensionless parameter (kx > 0)\n", "kx = 0.001\n", "\n", "# get model-parameters\n", "par = ParConfigs()\n", "\n", "mols = [\"r\", \"rr\", \"R\", \"rR\", \"RR\", \"Gr\", \"Grr\", \"GR\", \"GrR\", \"GRR\"]\n", "\n", "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "\n", "###############################################################\n", "print ('Model-order: N =', N)\n", "print ('Ligand: L =', L)\n", "print ('G-protein: G =', G)\n", "print ('alpha-factor: a =', alpha)\n", "print ('Initial condition:')\n", "for i in range(len(mols)) :\n", " print (' ', mols[i], ': ', obs0[i])\n", "###############################################################\n", "\n", "# ligands-receptors first-order coupling\n", "dl0, dl1, dl2 = par.get_dl()\n", "kl0, kl1, kl2 = par.get_kl(100, 100)\n", "\n", "# Gproteins-receptors first-order coupling\n", "dg0, dg1 = par.get_dg()\n", "kg0, kg1 = par.get_kg(100)\n", "\n", "# ligand-(Gproteins-receptors) first-order coupling\n", "da0, da1, da2 = par.get_da()\n", "ka0, ka1, ka2 = par.get_ka(alpha, 100, 100)\n", "\n", "# Gproteins-(ligand-receptors) first-order coupling\n", "db0, db1, db2 = par.get_db()\n", "kb0, kb1, kb2 = par.get_kb(alpha, 100, 100)\n", "\n", "# receptor-receptor second-order coupling\n", "dx0, dx1, dx2 = par.get_dx()\n", "kx0, kx1, kx2 = par.get_kx(kx, N)\n", "\n", "# receptor-Gprotein second-order coupling\n", "dy0, dy1, dy2, dy3 = par.get_dy()\n", "ky0, ky1, ky2, ky3 = par.get_ky(1, 1, 1, 1)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 646 }, "colab_type": "code", "id": "xpx_QMpjqXqH", "outputId": "35244e93-393d-43c9-fc05-c96f24e22372" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n", "r + r > rr | 0.00020092425155716296\n", "rr > r + r | 1.0\n", "R + r > rR | 2.0092425155716294e-06\n", "rR > R + r | 1.0\n", "R + R > RR | 2.0092425155716296e-08\n", "RR > R + R | 1.0\n", "rr > rR | 0.01\n", "rR > rr | 1.0\n", "rR > RR | 0.01\n", "RR > rR | 1.0\n", "rr > Grr | 0.01\n", "Grr > rr | 1.0\n", "rR > GrR | 0.01\n", "GrR > rR | 1.0\n", "RR > GRR | 0.01\n", "GRR > RR | 1.0\n", "Gr + r > Grr | 0.00020092425155716296\n", "Grr > Gr + r | 1.0\n", "GR + r > GrR | 2.0092425155716294e-06\n", "GrR > GR + r | 1.0\n", "Gr + R > GrR | 2.0092425155716294e-06\n", "GrR > Gr + R | 1.0\n", "GR + R > GrR | 2.0092425155716296e-08\n", "GrR > GR + R | 1.0\n", "Grr > GrR | 0.01\n", "GrR > Grr | 1.0\n", "GrR > GRR | 0.01\n", "GRR > GrR | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", "\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", " # receptor dimerization\n", " r + r == rr | (kx0, dx0)\n", " R + r == rR | (kx1, dx1)\n", " R + R == RR | (kx2, dx2)\n", "\n", " rr == rR | (kl1*L, dl1)\n", " rR == RR | (kl2*L, dl2)\n", "\n", " # dimers coupled with G-proteins\n", " rr == Grr | (kg1*G, dg1)\n", " rR == GrR | (kb1*G, db1)\n", " RR == GRR | (kb2*G, db2)\n", "\n", " Gr + r == Grr | (ky0, dy0)\n", " GR + r == GrR | (ky1, dy1)\n", " Gr + R == GrR | (ky2, dy2)\n", " GR + R == GrR | (ky3, dy3)\n", "\n", " Grr == GrR | (ka1*L, da1)\n", " GrR == GRR | (ka2*L, da2)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 466 }, "colab_type": "code", "id": "8uCvdCV5t3Hj", "outputId": "7ddd2de5-e059-42dc-ca89-74359ee939da" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "rr : 0\n", "R : 0\n", "rR : 0\n", "RR : 0\n", "Gr : 0\n", "Grr : 0\n", "GR : 0\n", "GrR : 0\n", "GRR : 0\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAEGCAYAAACpXNjrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deXxV1bn/8c+ThISQMCZhEJBBUUERxIhD62wVh6rXOlEHUKv1V2evbbXtrVVbq9ZrW4eq/CyFDldwrLOUC44/qQoaEEQLopWZMCQkJCHJOc/vj71DDpA5Jzkk5/t+vc5rn73O2ns/Z0PyZO2191rm7oiIiMRTSqIDEBGRzkfJRURE4k7JRURE4k7JRURE4k7JRURE4i4t0QG0t9zcXB86dGiiwxAR6TAWLFiw0d3zmrNN0iWXoUOHMn/+/ESHISLSYZjZv5u7jS6LiYhI3Cm5iIhI3Cm5iIhI3CVdn4uI7DkqKyv54osvKCsrS3QoAnTr1o199tmH9PT0Vu9LyUVEEuaLL76gV69e7L///qSk6EJKIkWjUdavX8+yZcsYOXJkq/899K8pIglTVlZGv379lFj2ACkpKfTr14/y8nJmzJjBtm3bWre/OMUlItIiSix7jpSUFMyMTZs28cYbb7RqX7os1gG4Q0kJlJXt/iovh4oKqK6GqqpgGfuKRCAa3f3lHixr9l/zqllvaBnv7ybJ66yzEh2B1KWgIJuCgkI++KDl+1By2QMUF0NBAXz8MaxeDRs2wPr1wbLmVVWV6CjbjlmiI5BE2ROSS2pqKqNHj8bdSU1N5eGHH+aoo45q02PWPMydm5vbaN1p06Zx8skns9dee8WlXlPMm2eYRVm6tOX7UHJpZ6WlMG8efPRR7Wv58trPMzOhXz/o2xcGDoRDDgne5+RAdjZ06xa8MjNr32dkQJcukJYWvGrep6YGy5SUnV9mwavmPdSWxa7XtRSJpwULEh0BZGZmUlBQAMCsWbO47bbbeOuttxIcVa1p06Zx0EEHNSm5NKVeU/zoR8GVjcsvD9Zb8vOv5NJOvv4aHnoIpkyBrVuDsmHDYNw4uOyyYDluXJBIRCQxtm7dSu/evQFwd370ox/x2muvYWb87Gc/44ILLuDNN9/k/vvv5+WXXwbg2muvJT8/n8mTJzN06FAmTZrESy+9RFVVFU8//TQHHHAAmzZtYuLEiRQWFjJ+/HjqmgE4EolwxRVXMH/+fMyMyy+/nMGDBzN//nwuuugiMjMzmTdvHr/5zW946aWXKC8v56ijjuLxxx/n2Wef3a3ep59+ys0330xpaSm5ublMmzaNAQMG8OCDD/LYY4+RlpbGqFGjmDFjRpucSyWXNvbhh/DAA/D008H6eecFySQ/H/r0SWxsInuSG28MLg/H09ix8LvfNVynvLycsWPHUlFRwdq1a5k7dy4Azz33HAUFBSxcuJCNGzdy2GGHccwxxzR6zNzcXD766CP+8Ic/cP/99/PEE09wxx138M1vfpOf//znvPLKK0yZMmW37QoKCli9ejWLFy8GoKioiF69evHwww9z//33k5+fDwTJ7Oc//zkAl1xyCS+//DLnnnvuTvWqqqq47rrreOGFF8jLy2PmzJn89Kc/ZerUqdxzzz18+eWXZGRkUFRU1JzT2Sy6TaMNRKPw97/D0UfD+PHw6qtw002wYgU8+SScfLISi8ieouay2Geffcbrr7/OpZdeirvz7rvvMnHiRFJTU+nXrx/HHnssH374YaP7O+eccwA49NBD+eqrrwB4++23ufjiiwE4/fTTd7SOYg0fPpwVK1Zw3XXX8frrr9OjR4869//GG29w+OGHM3r0aObOncuSJUt2q/P555+zePFivvWtbzF27Fh++ctfsmrVKgAOPvhgLrroIv7617+SltZ27Qu1XOIsGoXvfQ/+9CcYOhR++1u44gro3j3RkYns2RprYbSHI488ko0bN1JYWFjnpSuAtLQ0ojW3WgIVFRU7fZ6RkQEENwpUV1fvKLdGOi569+7NwoULmTVrFo888ghPPfUUU6dO3alORUUFP/jBD5g/fz6DBw/mF7/4xW7Hh+CS3oEHHsi8efN2++yVV17h7bff5sUXX+Suu+5iyZIlbZJk1HKJo2gUvv/9ILH87GewbFnQ1FdiEekYPvvsMyKRCDk5ORxzzDHMnDmTSCRCYWEhb7/9NuPHj2fIkCF8+umnbN++neLiYubMmdPofo855hj+9re/AfDaa6+xZcuW3eps3LiRaDTKd77zHe666y4++ugjALp3705JSQlQm8hyc3MpLS3lmWee2bF9bL3999+fwsLCHcmlqqqKJUuWEI1GWblyJccffzz33XcfRUVFlJaWtuKM1U8tlzhxhx/8AJ54Ikgsd96pO6xEOoKaPhcI/uKfPn06qamp/Md//Afz5s1jzJgxmBn33Xcf/fv3B+D888/n4IMPZsSIERxyyCGNHuP2229n4sSJjBs3jmOPPZa99957tzqrV6/msssu29Eq+vWvfw3A5MmTufrqq3d01F955ZWMHj2aoUOHcthhh+3Yftd6zzzzDNdffz3FxcVUV1dz4403st9++3HxxRdTXFyMu3PTTTfRq1evVp/Dulh9Tb/OKj8/3+M9WZg7XHcdPPII3Hor3H23EotIUyxYsIBDDz000WFIjAULFvDJJ58QjUa5PLwX2cwWuHt+c/ajy2Kt5B501j/yCNxyixKLiAgoubSKe5BQfv/7oG/lvvuUWEREQMmlVX7yk+AZlmuvDZZKLCIiASWXFvrgA7jnHrjySnjwQSUWEZFYSi4t9OCDwS3G99+vxCIisqs2Sy5mNtXMNpjZ4piyPmY228yWhcveYbmZ2YNmttzMFpnZuJhtJoX1l5nZpJjyQ83sk3CbB62xJ5TiaO1aeOqpYFC3eh6iFRFJam3ZcpkGTNil7FZgjruPAOaE6wCnAiPC11XAoxAkI+B24HBgPHB7TUIK61wVs92ux2ozjz0WzJVy7bXtdUQRaStmxiWXXLJjvbq6mry8PM4444wERtXxtVlycfe3gc27FJ8FTA/fTwfOjin/swf+CfQyswHAKcBsd9/s7luA2cCE8LMe7j7Pgwd1/hyzrza1fXuQXE47Dfbdtz2OKCJtKSsri8WLF1NeXg7A7NmzGThwYIKj6vjau8+ln7uvBQiXNQPMDwRWxtRbFZY1VL6qjvI2N3NmMHnXDTe0x9FEpD2ceuqpvPLKKwA8+eSTTJw4McERdXx7yvAvdfWXeAvK69652VUEl9DqHHahqdyDjvyRI+Gkk1q8GxGpwx0vLeHTNVvjus9Re/Xg9m8f2Gi9Cy+8kDvvvJMzzjiDRYsWcfnll/POO+/ENZZk094tl/XhJS3C5YawfBUwOKbeIGBNI+WD6iivk7tPcfd8d8/Py8trcfDz5gUz5113ne4QE+lMDj74YL766iuefPJJTjvttESH0ym0d8vlRWAScE+4fCGm/Fozm0HQeV/s7mvNbBZwd0wn/snAbe6+2cxKzOwI4H3gUuChtg7+wQehZ0+49NK2PpJI8mlKC6MtnXnmmdxyyy28+eabbNq0KaGxdAZtllzM7EngOCDXzFYR3PV1D/CUmV0BfA2cF1Z/FTgNWA6UAZcBhEnkLqBmhp473b3mJoH/Q3BHWibwWvhqM6tWwTPPBMO8ZGW15ZFEJBEuv/xyevbsyejRo3nzzTcTHU6H12bJxd3r6xE7sY66DlxTz36mAlPrKJ8PHNSaGJvj0UeD+VquqTNKEenoBg0axA26Uydu9pQO/T1aeTk8/jiceSYMG5boaEQknuqaLOu4447juOOOa/9gOhEN/9IEM2bApk26/VhEpKmUXBrhHgypf9BBoD9kRESaRpfFGvHOO7BwIUyZotuPRUSaSi2XRjzyCPTpAxddlOhIREQ6DiWXRrz1Fnz729CtW6IjERHpOJRcGrBuHaxfD4cckuhIREQ6FiWXBhQUBMuxYxMbh4i0ndTUVMaOHcuBBx7ImDFjeOCBB4hGo4kOq8NTh34DFi4MlmPGJDYOEWk7mZmZFIR/SW7YsIHvfve7FBcXc8cddyQ4so5NLZcGFBTA0KHQq1eiIxGR9tC3b1+mTJnCww8/TDBwiLSUWi4NKChQq0Wk3bx2K6z7JL777D8aTr2nWZsMHz6caDTKhg0b6NevX3zjSSJqudSjrAz+9S/1t4gkI7VaWk8tl3osXhwMVKnkItJOmtnCaCsrVqwgNTWVvn37Nl5Z6qWWSz10p5hI8iksLOTqq6/m2muvxTQkR6uo5VKPgoJgYrAhQxIdiYi0pfLycsaOHUtVVRVpaWlccskl3HzzzYkOq8NTcqlHTWe+/ngR6dwikUiiQ+iUdFmsDtEoLFqkS2IiIi2l5FKHL76AbduUXEREWkrJpQ7qzBcRaR0llzoUFEBaGowalehIREQ6JiWXOhQUwMiRkJGR6EhERDomJZc6LFyoS2IiIq2h5LKLwkJYvVrJRSRZrF+/nu9+97sMHz6cQw89lCOPPJLnn3++3vrTpk3DzJgzZ86Osueffx4z45lnnmmPkDsEJZdd1Ayzr+Qi0vm5O2effTbHHHMMK1asYMGCBcyYMYNVq1Y1uN3o0aN58sknd6zPmDGDMRrldidKLruouVNM/09EOr+5c+eSnp7O1VdfvaNsyJAhXHfddQ1ud/TRR/PBBx9QVVVFaWkpy5cvZ6z+It2JntDfxcKFMGgQ5OQkOhKR5HLvB/fy2ebP4rrPA/ocwI/H/7jez5csWcK4cePq/fzZZ5/liiuuYMKECcyYMWNHuZlx0kknMWvWLIqLiznzzDP58ssv4xp7R6eWyy4KCnRJTCRZXXPNNYwZM4bDDjsMgD/96U8UFxczc+ZMNm7cuFPdCy+8kBkzZjBjxgwmTpyYiHD3aAlpuZjZTcD3AAc+AS4DBgAzgD7AR8Al7l5pZhnAn4FDgU3ABe7+Vbif24ArgAhwvbvPak1cFRWwdCmcfXZr9iIiLdFQC6OtHHjggTz77LM71h955BE2btxIfn4+AJMmTeLdd99lwoQJ5Obm7rTt+PHjWbx4MZmZmey3337tGndH0O4tFzMbCFwP5Lv7QUAqcCFwL/Bbdx8BbCFIGoTLLe6+L/DbsB5mNirc7kBgAvAHM0ttTWxLlkAkopaLSLI44YQTqKio4NFHH91RVlZWtuP9eeedR1FR0U6XxGL9+te/5u67727zODuiRF0WSwMyzSwN6AasBU4Aau7jmw7UtB/OCtcJPz/RgokWzgJmuPt2d/8SWA6Mb01Q6swXSS5mxt///nfeeusthg0bxvjx45k0aRL33ntvk7Y/9dRTOf7449s4yo6p3S+LuftqM7sf+BooB/4BLACK3L06rLYKGBi+HwisDLetNrNiICcs/2fMrmO3aZGFCyE7G4YPb81eRKQjGTBgQL0tk7pMnjyZyZMn71Y+bdq0+AXVCSTislhvglbHMGAvIAs4tY6qNZNY1zWjijdQXtcxrzKz+WY2v7CwsN7YauZwSdFtDiIirZKIX6MnAV+6e6G7VwHPAUcBvcLLZACDgDXh+1XAYIDw857A5tjyOrbZibtPcfd8d8/Py8urM6hoVHeKiYjESyKSy9fAEWbWLew7ORH4FHgDODesMwl4IXz/YrhO+Plcd/ew/EIzyzCzYcAI4IOWBvXVV1BSouQiIhIPiehzed/MniG43bga+BiYArwCzDCzX4Zlfww3+SPwFzNbTtBiuTDczxIze4ogMVUD17h7i+crrRn2RZ35IiKtl5DnXNz9duD2XYpXUMfdXu5eAZxXz35+BfwqHjEVFAR9LQcdFI+9iYgkN3VdhwoK4IADIDMz0ZGIiHR8Si4hdeaLJKeWDLmfl5fHIYccwogRIzjllFN477332jHijkHJBdi8Gb7+WslFJNm0dMj9Cy64gI8//phly5Zx6623cs4557B06dJ2irpjUHIBFi0KlurMF0kuLR1yP9bxxx/PVVddxZQpU9oixA5LQ+6jO8VE9gTr7r6b7UvjO+R+xsgD6P+Tn9T7eUuH3N/VuHHjePzxx1sVa2ejlgvB1MapqdC3b6IjEZFEas6Q+7GCR+8kllouBA9Pdu8OVteAMiLSLhpqYbSV1gy5H+vjjz9m5MiRbR5vR6KWC7XJRUSSS2uH3Ad46623mDJlCldeeWWbxtrRqOVCkFyysxMdhYi0t5oh92+66Sbuu+8+8vLyyMrKanTI/ZkzZ/Luu+9SVlbGsGHDePbZZ9Vy2YWSC2q5iCSzeA25LzvTZTGgtFTJRUQknpRcUMtFRCTelFxQn4tIIkWj0USHIKF4/lsouaCWi0iidOvWjXXr1inB7AGi0Sjr1q2jqqoqLvtThz7qcxFJlH322YeCggLWrFmD6UGzhKuqquLrr78mGo2Slta69JD0yaW6GioqlFxEEiE9PZ3MzExmz55Nz549SUnRxZREc3eKiooYP3636bWaJemTS0lJsFRyEUmMgw46iKqqKpYuXRq3SzLScmlpaRx++OEcccQRrdtPnOLpsGqSizr0RRLDzBg3blyDA0hKx5P0bVC1XERE4i/pk0tpabBUchERiZ+kTy5quYiIxJ+Si/pcRETiTslFLRcRkbhL+uSiPhcRkfhL+uSilouISPw1KbmY2Xlm1j18/zMze87MOsVN6SUlkJoKXbsmOhIRkc6jqS2X/3L3EjP7JnAKMB14tJFtOoSaEZE1rJGISPw0NblEwuXpwKPu/gKQ3jYhtS+NiCwiEn9NTS6rzexx4HzgVTPLaMa2uzGzXmb2jJl9ZmZLzexIM+tjZrPNbFm47B3WNTN70MyWm9mi2MtxZjYprL/MzCa1JBaNiCwiEn9NTRDnA7OACe5eBPQBftiK4/4eeN3dDwDGAEuBW4E57j4CmBOuA5wKjAhfVxFejjOzPsDtwOHAeOD2moTUHGq5iIjEX4PJJWxN9AG6Am8Cm8L17cD8lhzQzHoAxwB/BHD3yjBhnUXQl0O4PDt8fxbwZw/8E+hlZgMI+n5mu/tmd98CzAYmNDcezUIpIhJ/jY2KvABwwIC9gS3h+17A18CwFhxzOFAI/MnMxoTHuAHo5+5rAdx9rZn1DesPBFbGbL8qLKuvfDdmdhVBq4e99957p89KSiA3twXfQkRE6tVgcnH3YQBm9hjworu/Gq6fCpzUimOOA65z9/fN7PfUXgKrS133cXkD5bsXuk8BpgDk5+fvVCdRl8XcnbLKCFvKKikqq2LztkqKyqsor6ymoirK9uoI26uiVITL7dVRqqNONOpUR51INFx3JxJ1oh7s0x2i7jjsKAuOB07M+5iz4LucNq/zLLbiu8Z3dyLSATR1PpfD3P3qmhV3f83M7mrhMVcBq9z9/XD9GYLkst7MBoStlgHAhpj6g2O2HwSsCcuP26X8zeYG05Yd+u5OYcl2Pl9fwr/Wl/KvdSX8a0MJa4rK2bKtispI4/OGpxh07ZJKRloKqSkppKUYqeGr5n2KGSkphgEpKWAYKQZYuCTIxGa2IyObBfV22CVVx/PO7DAUEUkiTU0uG83sZ8BfCf4QvRjY1JIDuvs6M1tpZvu7++fAicCn4WsScE+4fCHc5EXgWjObQdB5XxwmoFnA3TGd+CcDtzU3nni3XDaVbuf5j1fzj0/X8/m6EorLa2fW65OVzn79sjl2vzx6Z6XTu1s6vbt1oVe32vfdMtLompZCRphQuqQm/SAKIpJgM7/f/G2amlwmEtyZ9Xy4/nZY1lLXAX8zs3RgBXAZwc0FT5nZFQT9OeeFdV8FTgOWA2VhXdx9c9h6+jCsd6e7b25OENXVUFHR+g79SNR5d/lGZn74NbM/XU9VxDloYA9OGz2A/ftls1//7uzXrzu52RmtO5CISAfRpOQS/tK+IV4HdfcCIL+Oj06so64D19Szn6nA1JbG0dpxxVYXlfPUhyt5ev5K1hRX0LtbFy49cigXHDaY/frp/mYRSV5NSi5mth9wCzA0dht3P6FtwmofrRkR+cWFa7jlqYVURaN8c99cfnr6KE4a1ZeMtNT4Biki0gE19bLY08BjwBPUDgXT4bW05fLEOyv45StLGT+sDw+cP4ZBvbvFPzgRkQ6sqcml2t07xUCVsZqbXKJR5+5Xl/LEu19y2uj+PHD+WLp2UUtFRGRXTU0uL5nZDwg69LfXFDa3A31P05wpjrdXR/jh04t4ceEaJh81lP86YxSpKbq/VkSkLk1NLjWDQsaOJ+YET9t3WE1tuZRUVPH9vyzgvS828eMJB3D1scMxPbghIlKvpt4t1pJhXvZ4TenQX7+1gsl/+pBl60t44PwxnDNuUPsEJyLSgTX1brFL6yp39z/HN5z21VjLxd353vT5/HvTNqZOPoxj9strv+BERDqwJg//EvO+K8HzKB8BnSK51NfnMmfpBj5ZXcxvzj1YiUVEpBmaelnsuth1M+sJ/KVNImpHJSXBWFyZmbt/5u489MZyBvXO5OxD6hxsWURE6tHUlsuuyggm7+rQasYVq6tv/p1lG1m4soi7/2N0u4/vtb28lJIt69lWtJGyrZspL95EZUkxkcrtRCq3E63aTqSykmhlJV5VSbSqCqKRYATk6ggejYJH8UikZmhkwGuGRt5pWGTHa4ctrhkOOd7DIotI0mlqn8tL1P4KSgVGAk+1VVDtpb4Rkd2dh+YuY0DPrnzn0Pi2WspKi/h6yT/Z/NXnlK78kqrVq2H9RjIKt5K9pYKssihpuwyWnBm+mitqwQvALfwH3HUZfsZu7+u+G851k5yINEFTWy73x7yvBv7t7qvaIJ52Vd+IyO9/uZkPv9rCL749qtXDuUSjUZZ/NJcvZz+Pv/8xA5ZvIb0aehO8KtOguFcXynKy2DisP5t69iAlK4vU7t3p0r0H6dk9Se/Ri67ZPemSmUVaele6ZGTSJSOTtIzgfVqXDFJS00hJTSM1NY3UtHRSU1vaKBUR2UULHr1oap/LW2bWj9qO/WXNPtIeqL4pjh+au4zc7AwuHL/37h82wfbyUt6f+RBb336LnE9W0qskyt7A+r7prDxxFD0Ozaf3kAPot8+B5O61LykpGlZfRDqXpl4WOx/4DcFkXAY8ZGY/dPdn2jC2NldXy2XBv7fw/5Zv4qenjWzR0C4LXp3Otrv/m7yNVXTraqwf1Y+ybxzJyAkXMnKfg+MUuYjInq2p105+SjAb5QYAM8sD/pdgFskOq7QUcnN3Lnt47jJ6d+vCdw9vXqtl87p/895Pvs8+7/2b8t5pFN31Aw47+/ukdUmPY8QiIh1DU5NLSk1iCW0imNyrQ9u15fLJqmLe+LyQH56yP1kZTTs10WiUt564g6zHnmZIhbPi22M57uePkNW9TxtFLSKy52tqcnk9nFb4yXD9AoIZIju0XftcHn5jGT26pnHJkUOatP2Xi9/j89tuZsiyYlYNzaLnXXdz+mEnt1G0IiIdR1M79H9oZucA3yToc5ni7s83stkeL7bl8tm6rcxasp7rTxxBj65dGt122YI5bJt8LXkpsOr7p3PC9ffoDi0RkVCTfxu6+3PAc2aWS3BZrEOrroaKitrk8vDc5WSlp3L5N4Y2uu328lJW3nILWenG4KdmcKg66kVEdtJgv4mZHWFmb5rZc2Z2iJktBhYD681sQvuE2DZiR0T+orCUVz5ZyyVHDqVXt8Y74P/3v65gwNoKIj++mr2UWEREdtNYy+Vh4CdAT2AucKq7/9PMDiDof3m9jeNrM7EjIr+6aC3u8L2jG59ZYMHrf2Hoy4v44pjhnHH+9W0cpYhIx9TYHV9p7v4Pd38aWOfu/wRw98/aPrS2FTsicmHpdnp0TSM3O6PBbYo3raXi9nvZlJPGcb+Z3g5Rioh0TI21XGJHuSrf5bMOPbphbMtlU1ElOY0kFoB3/vNShm6N4I/+kuyeuY3WFxFJVo0llzFmtpXgDrHM8D3hetc2jayNxSaXzasqyclquK/l7Wm/Zp9/ruLLcw/ntOO+0w4Rioh0XA0mF3dv3aiNe7DYDv3N2yoZktOt3rprVnxCt9/9hVV7d+NbP3+snSIUEem4OvxT9i0V2+eyaVslOdl1t1wikWoW3XglaRFn3wceokt6h26wiYi0i6RPLlnZzpaySvrUc1lszn/fzJB/FbPpqrMYdtBR7RihiEjHlbDkYmapZvaxmb0crg8zs/fNbJmZzTSz9LA8I1xfHn4+NGYft4Xln5vZKc05fk1y8S5VRKJOn6zdO/QjkWq6Pz2Hf+/fi+OvubvF31VEJNkksuVyA7A0Zv1e4LfuPgLYAlwRll8BbHH3fYHfhvUws1HAhcCBwATgD2bW5D6i0lJISYGySCVAnR36n817hV4lUbqecYrmXBERaYaE/MY0s0HA6cAT4boBJ1A7hP904Ozw/VnhOuHnJ4b1zwJmuPt2d/8SWA6Mb2oMNeOKbSkLkktdl8X+/dqzRA0O/vZlzfuCIiJJLlF/jv8O+BG1z9HkAEXuXh2urwJqJq8fCKwECD8vDuvvKK9jm52Y2VVmNt/M5hcWFgK1IyJvKq0/uXSd9wmrh3WnT/+mjZIsIiKBdk8uZnYGsMHdF8QW11HVG/msoW12LnSf4u757p6fl5cH1LZcNm8LL4vtcrfYmi8WMWBNBdFvjGvo64iISB0SMUb8N4Azzew0ggcxexC0ZHqZWVrYOhkErAnrrwIGA6vMLI1gnLPNMeU1YrdpVG1y2Q7s3nJZ8sJ0BgH7njGx2V9QRCTZtXvLxd1vc/dB7j6UoEN+rrtfBLwBnBtWmwS8EL5/MVwn/Hyuu3tYfmF4N9kwYATwQVPjKC0Nh37ZVkl2RhoZaTvfC1D97jwKc7owfPTRLfuiIiJJbE+6BerHwM1mtpygT+WPYfkfgZyw/GbgVgB3XwI8BXxKMDrzNe4eaerBavpcNm/b/RmXkqINDPx8C1vH76e7xEREWiChUye6+5vAm+H7FdRxt5e7VwDn1bP9r4BfteTYsX0uuyaXha/8mZwIDDjlrJbsWkQk6SXtn+U1yWVT6e6DVhbNmc22rsbBJ9SZ00REpBFJm1xq+lx2bblUV1XSt2Al68YM1DhiIiItlNDLYolSXQ3l5ZCd7UFyibkNefHbz9G9zKk4/oQERigi0g24uoUAAA10SURBVLElZculZrj99KxqKiPRnS6LrX7971SnwJhvT05McCIinUBSJpeaQStTutU8nV87aGXW+0tZvW9PeuYMSERoIiKdQlInFzJ2HrTyqyXz6LehkpSjD09QZCIinUNSJpeay2LRLjuPK/b5S38D4IBvX5yQuEREOoukTC41LZeqlF0Grfx/H7KufwZ7H3BYgiITEekckjq5VFrtoJVbClcycPlWysaPSmBkIiKdQ1Inl/Lodrp2SaFbehqLXppOqsPg085JbHAiIp1AUieXbZFKcsI7xUrfeIOtWcaBR5/dwJYiItIUSZlcajr0SyqDp/Mrt5fRf9FaCg8ZQmpqUj5XKiISV0mZXEpKICUFiiuC5LLof2fSbbvT+8RvJTo0EZFOIWmTS81w+zlZ6Wx47w2iBmNOm9T4xiIi0qikTS7BRGHb6ZOVTnT1Oop6pJLdMyfRoYmIdApJmVxKSyG7VzUVVVH6ZKeTvn4LpbndEh2WiEinkZTJpaQEsvrUDv2SvamMqn69ExyViEjnkbTJJaNnkFx6pFXRc2uUlAH9ExyViEjnkbzJpXuQXFI2LycFyNx7SGKDEhHpRJI2uaRlB8mFDcsB6Dl0vwRGJCLSuSRlcikthZTM7QBE130FQL99DkpgRCIinUtSJpeSEiCjki6pRnTNKqpToN8QDVgpIhIvSZdc3KG8PJjLpU9WOqzbQFGvNNK6pDe+sYiINEnSJZdoNFhWp1bSJyuD9PVFbMvNSmxQIiKdTNIll0gkWFZaMPRLj03lVPfXk/kiIvGUdMmlpuVS7pXkdKmgxzYndS894yIiEk9JN758TculLFJJTvk6ADIHD01cQCIinVC7t1zMbLCZvWFmS81siZndEJb3MbPZZrYsXPYOy83MHjSz5Wa2yMzGxexrUlh/mZk1aUjjaBRIjVARqaZnydcA9B62f/y/qIhIEkvEZbFq4D/dfSRwBHCNmY0CbgXmuPsIYE64DnAqMCJ8XQU8CkEyAm4HDgfGA7fXJKSGRCKQ2i14gDKraBUA/fcZHa/vJiIiJCC5uPtad/8ofF8CLAUGAmcB08Nq04Ga+YbPAv7sgX8CvcxsAHAKMNvdN7v7FmA2MKGx40ejkJIZJJdum9dTmQZ5g9VyERGJp4R26JvZUOAQ4H2gn7uvhSABAX3DagOBlTGbrQrL6iuv6zhXmdl8M5tfXFy6o+XSbdNminp3ISUl6e5rEBFpUwn7rWpm2cCzwI3uvrWhqnWUeQPluxe6T3H3fHfPz8zMrr0strGEsrzsZkYuIiKNSUhyMbMuBInlb+7+XFi8PrzcRbjcEJavAgbHbD4IWNNAeYOiUUjNCpJLry3bifTPbcU3ERGRuiTibjED/ggsdfcHYj56Eai542sS8EJM+aXhXWNHAMXhZbNZwMlm1jvsyD85LGtQJAJde24n24vJLnfS9hoQp28mIiI1EvGcyzeAS4BPzKwgLPsJcA/wlJldAXwNnBd+9ipwGrAcKAMuA3D3zWZ2F/BhWO9Od9/c2MGjUcjsUcm+BHeKddt7eFy+lIiI1Gr35OLu71J3fwnAiXXUd+CaevY1FZjanONHIpCWVcngquABypzhBzRncxERaYKku00qEoGUbpX0Lw+6dPrvc3CCIxIR6XySLrlEo2AZleSUbqI8HXr30/TGIiLxlnTJJRKBaHolfYqLKO6ToWdcRETaQNL9Zo1EIZJaRe+iMsrzuic6HBGRTinpkkvUHTxKTlEl0QF5iQ5HRKRTSsLkEqV7ZBOZldBlr70SHY6ISKeUdMnFzRlQGQy1nz1Ez7iIiLSFpEsuluL0rwhGickZPirB0YiIdE5Jl1xI8R3PuAzYd0yCgxER6ZySLrlYSpR+24rY1tXomaNxxURE2kLSJRfM6b+thOKcjERHIiLSaSVdcrEUp19JBdvzeiY6FBGRTivpkgspUfK2VuN6xkVEpM0kXXJJS6kkvRq6DBqU6FBERDqtpEsu6VYBQI8h+yY4EhGRzivpkksXrwIgdx894yIi0laSNrn0H655XERE2kryJZdohOIsI7tnTqJDERHptJIuuaRFohT37proMEREOrWkSy5dolHK9YyLiEibSrrkkhYBBvRNdBgiIp1a0iUXc+i2996JDkNEpFNLuuQC0GvYiESHICLSqSVlcsnb56BEhyAi0qklXXJxYK999IyLiEhbSrrkEkmFjMzsRIchItKpJV1yqU61RIcgItLpdfjkYmYTzOxzM1tuZrc2Vr86JbU9whIRSWodOrmYWSrwCHAqMAqYaGYNjkgZSe3SHqGJiCS1tEQH0ErjgeXuvgLAzGYAZwGf1rdB15RyePiwYMU95hOvs36DvAXbiIgkgY6eXAYCK2PWVwGH71rJzK4CrgLYt28W9Dsw9tPYii0IQX04ItLZfdzsLTp6cqnrN/tuzQl3nwJMAcjPz3fOm9bGYYmIdCZTm71Fh+5zIWipDI5ZHwSsSVAsIiIS6ujJ5UNghJkNM7N04ELgxQTHJCKS9Dr0ZTF3rzaza4FZQCow1d2XJDgsEZGk16GTC4C7vwq8mug4RESkVke/LCYiInsgJRcREYk7JRcREYk7JRcREYk78yQbwsTMSoDPEx3HHiIX2JjoIPYAOg+1dC5q6VzU2t/duzdngw5/t1gLfO7u+YkOYk9gZvN1LnQeYulc1NK5qGVm85u7jS6LiYhI3Cm5iIhI3CVjcpmS6AD2IDoXAZ2HWjoXtXQuajX7XCRdh76IiLS9ZGy5iIhIG1NyERGRuEua5GJmE8zsczNbbma3Jjqe9mRmU81sg5ktjinrY2azzWxZuOydyBjbi5kNNrM3zGypmS0xsxvC8qQ7H2bW1cw+MLOF4bm4IywfZmbvh+diZjidRVIws1Qz+9jMXg7Xk/JcmNlXZvaJmRXU3Ibc3J+RpEguZpYKPAKcCowCJprZqMRG1a6mARN2KbsVmOPuI4A54XoyqAb+091HAkcA14T/F5LxfGwHTnD3McBYYIKZHQHcC/w2PBdbgCsSGGN7uwFYGrOezOfieHcfG/OsT7N+RpIiuQDjgeXuvsLdK4EZwFkJjqnduPvbwOZdis8CpofvpwNnt2tQCeLua939o/B9CcEvkoEk4fnwQGm42iV8OXAC8ExYnhTnAsDMBgGnA0+E60aSnot6NOtnJFmSy0BgZcz6qrAsmfVz97UQ/MIF+iY4nnZnZkOBQ4D3SdLzEV4GKgA2ALOBL4Aid68OqyTTz8rvgB8B0XA9h+Q9Fw78w8wWmNlVYVmzfkaSZfgXq6NM92AnMTPLBp4FbnT3rcEfqcnH3SPAWDPrBTwPjKyrWvtG1f7M7Axgg7svMLPjaorrqNrpz0XoG+6+xsz6ArPN7LPm7iBZWi6rgMEx64OANQmKZU+x3swGAITLDQmOp92YWReCxPI3d38uLE7a8wHg7kXAmwT9UL3MrOYPz2T5WfkGcKaZfUVw2fwEgpZMMp4L3H1NuNxA8EfHeJr5M5IsyeVDYER450c6cCHwYoJjSrQXgUnh+0nACwmMpd2E19H/CCx19wdiPkq682FmeWGLBTPLBE4i6IN6Azg3rJYU58Ldb3P3Qe4+lOD3w1x3v4gkPBdmlmVm3WveAycDi2nmz0jSPKFvZqcR/CWSCkx1918lOKR2Y2ZPAscRDCG+Hrgd+DvwFLA38DVwnrvv2unf6ZjZN4F3gE+ovbb+E4J+l6Q6H2Z2MEHHbCrBH5pPufudZjac4K/3PsDHwMXuvj1xkbav8LLYLe5+RjKei/A7Px+upgH/4+6/MrMcmvEzkjTJRURE2k+yXBYTEZF2pOQiIiJxp+QiIiJxp+QiIiJxp+QiIiJxp+QiIiJxp+Qi0ggzywmHHi8ws3Vmtjpm/b02ON5kMys0syfiuM8LwukmXo7XPkUakixji4m0mLtvIhiSHjP7BVDq7ve38WFnuvu18dqZu880s/XALfHap0hD1HIRaQUzKw2Xx5nZW2b2lJn9y8zuMbOLwsm4PjGzfcJ6eWb2rJl9GL6+0YRjHBjup8DMFpnZiLD84pjyx8N5i2omxvsonARsTlt+f5H6qOUiEj9jCEYV3gysAJ5w9/EWzHZ5HXAj8HuCyafeNbO9gVnUPRJxrKuB37v738Kx8VLNbCRwAcHotVVm9gfgIjN7Dfi/wDHu/qWZ9WmLLyrSGCUXkfj5sGa+CzP7AvhHWP4JcHz4/iRgVMwQ/z3MrHs4cVl95gE/DSezes7dl5nZicChwIfhvjIJRqk9Anjb3b8E6Ozjo8meS8lFJH5iBzSMxqxHqf1ZSwGOdPfypu7U3f/HzN4nmCVxlpl9j2CukenufltsXTM7k+SZc0T2YOpzEWlf/wB2dNSb2djGNghHqV3h7g8SDHt+MMEc5ueGkzlhZn3MbAhBK+dYMxtWUx7/ryDSOCUXkfZ1PZAfdsx/StCf0pgLgMXhdMQHAH9290+BnxFMRbuIYIriAe5eCFwFPGdmC4GZbfItRBqhIfdF9jBmNhnIj+etyOF+jyOcpySe+xWpi1ouInuecuDUeD9ECfwB2BKvfYo0RC0XERGJO7VcREQk7pRcREQk7pRcREQk7pRcREQk7v4/qvl7TQzXqRsAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "run_N1(m, mols, obs0)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "EOFTeZP9qXqQ" }, "source": [ "### Bivalent model (N = 2 and kx > 0)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": {}, "colab_type": "code", "id": "bCOfPIciqXqR" }, "outputs": [], "source": [ "# this is the bivalent model : N=2\n", "N = 2.00\n", "\n", "mols = [\"r\", \"rr\", \"rrr\", \"rrrr\",\n", " \"R\", \"rR\", \"rrR\", \"rrrR\",\n", " \"RR\", \"rRR\", \"rrRR\",\n", " \"Gr\", \"Grr\", \"Grrr\", \"Grrrr\",\n", " \"GR\", \"GrR\", \"GrrR\", \"GrrrR\",\n", " \"GRR\", \"GrRR\", \"GrrRR\"]" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "1eeHV_aHqXqZ", "outputId": "081187e2-24b4-4eb6-d53a-f7efc063c762" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n", "r + r > rr | 0.00020092425155716296\n", "rr > r + r | 1.0\n", "r + rr > rrr | 0.00020092425155716296\n", "rrr > r + rr | 1.0\n", "rr + r > rrr | 0.00020092425155716296\n", "rrr > rr + r | 1.0\n", "rr + rr > rrrr | 0.00020092425155716296\n", "rrrr > rr + rr | 1.0\n", "R + r > rR | 2.0092425155716294e-06\n", "rR > R + r | 1.0\n", "R + rr > rrR | 2.0092425155716294e-06\n", "rrR > R + rr | 1.0\n", "rR + r > rrR | 2.0092425155716294e-06\n", "rrR > rR + r | 1.0\n", "rR + rr > rrrR | 2.0092425155716294e-06\n", "rrrR > rR + rr | 1.0\n", "R + R > RR | 2.0092425155716296e-08\n", "RR > R + R | 1.0\n", "R + rR > rRR | 2.0092425155716296e-08\n", "rRR > R + rR | 1.0\n", "rR + R > rRR | 2.0092425155716296e-08\n", "rRR > rR + R | 1.0\n", "rR + rR > rrRR | 2.0092425155716296e-08\n", "rrRR > rR + rR | 1.0\n", "rr > rR | 0.01\n", "rR > rr | 1.0\n", "rrr > rrR | 0.01\n", "rrR > rrr | 1.0\n", "rrrr > rrrR | 0.01\n", "rrrR > rrrr | 1.0\n", "rR > RR | 0.01\n", "RR > rR | 1.0\n", "rrR > rRR | 0.01\n", "rRR > rrR | 1.0\n", "rrrR > rrRR | 0.01\n", "rrRR > rrrR | 1.0\n", "rr > Grr | 0.01\n", "Grr > rr | 1.0\n", "rrr > Grrr | 0.01\n", "Grrr > rrr | 1.0\n", "rrrr > Grrrr | 0.01\n", "Grrrr > rrrr | 1.0\n", "rR > GrR | 0.01\n", "GrR > rR | 1.0\n", "rrR > GrrR | 0.01\n", "GrrR > rrR | 1.0\n", "rrrR > GrrrR | 0.01\n", "GrrrR > rrrR | 1.0\n", "RR > GRR | 0.01\n", "GRR > RR | 1.0\n", "rRR > GrRR | 0.01\n", "GrRR > rRR | 1.0\n", "rrRR > GrrRR | 0.01\n", "GrrRR > rrRR | 1.0\n", "Gr + r > Grr | 0.00020092425155716296\n", "Grr > Gr + r | 1.0\n", "Gr + rr > Grrr | 0.00020092425155716296\n", "Grrr > Gr + rr | 1.0\n", "Grr + r > Grrr | 0.00020092425155716296\n", "Grrr > Grr + r | 1.0\n", "Grr + rr > Grrrr | 0.00020092425155716296\n", "Grrrr > Grr + rr | 1.0\n", "GR + r > GrR | 2.0092425155716294e-06\n", "GrR > GR + r | 1.0\n", "GR + rr > GrrR | 2.0092425155716294e-06\n", "GrrR > GR + rr | 1.0\n", "GrR + r > GrrR | 2.0092425155716294e-06\n", "GrrR > GrR + r | 1.0\n", "GrR + rr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrR + rr | 1.0\n", "R + Gr > GrR | 2.0092425155716294e-06\n", "GrR > R + Gr | 1.0\n", "R + Grr > GrrR | 2.0092425155716294e-06\n", "GrrR > R + Grr | 1.0\n", "rR + Gr > GrrR | 2.0092425155716294e-06\n", "GrrR > rR + Gr | 1.0\n", "rR + Grr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rR + Grr | 1.0\n", "GR + R > GRR | 2.0092425155716296e-08\n", "GRR > GR + R | 1.0\n", "GR + rR > GrRR | 2.0092425155716296e-08\n", "GrRR > GR + rR | 1.0\n", "GrR + R > GrRR | 2.0092425155716296e-08\n", "GrRR > GrR + R | 1.0\n", "GrR + rR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrR + rR | 1.0\n", "Grr > GrR | 0.01\n", "GrR > Grr | 1.0\n", "Grrr > GrrR | 0.01\n", "GrrR > Grrr | 1.0\n", "Grrrr > GrrrR | 0.01\n", "GrrrR > Grrrr | 1.0\n", "GrR > GRR | 0.01\n", "GRR > GrR | 1.0\n", "GrrR > GrRR | 0.01\n", "GrRR > GrrR | 1.0\n", "GrrrR > GrrRR | 0.01\n", "GrrRR > GrrrR | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", "\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", " # receptor dimerization\n", " r + r == rr | (kx0, dx0)\n", " r + rr == rrr | (kx0, dx0)\n", " rr + r == rrr | (kx0, dx0)\n", " rr + rr == rrrr | (kx0, dx0)\n", "\n", " R + r == rR | (kx1, dx1)\n", " R + rr == rrR | (kx1, dx1)\n", " rR + r == rrR | (kx1, dx1)\n", " rR + rr == rrrR | (kx1, dx1)\n", "\n", " R + R == RR | (kx2, dx2)\n", " R + rR == rRR | (kx2, dx2)\n", " rR + R == rRR | (kx2, dx2)\n", " rR + rR == rrRR | (kx2, dx2)\n", "\n", " rr == rR | (kl1*L, dl1)\n", " rrr == rrR | (kl1*L, dl1)\n", " rrrr == rrrR | (kl1*L, dl1)\n", "\n", " rR == RR | (kl2*L, dl2)\n", " rrR == rRR | (kl2*L, dl2)\n", " rrrR == rrRR | (kl2*L, dl2)\n", "\n", " # dimers coupled with G-proteins\n", " rr == Grr | (kg1*G, dg1)\n", " rrr == Grrr | (kg1*G, dg1)\n", " rrrr == Grrrr | (kg1*G, dg1)\n", "\n", " rR == GrR | (kb1*G, db1)\n", " rrR == GrrR | (kb1*G, db1)\n", " rrrR == GrrrR | (kb1*G, db1)\n", "\n", " RR == GRR | (kb2*G, db2)\n", " rRR == GrRR | (kb2*G, db2)\n", " rrRR == GrrRR | (kb2*G, db2)\n", "\n", " Gr + r == Grr | (ky0, dy0)\n", " Gr + rr == Grrr | (ky0, dy0)\n", " Grr + r == Grrr | (ky0, dy0)\n", " Grr + rr == Grrrr | (ky0, dy0)\n", "\n", " GR + r == GrR | (ky1, dy1)\n", " GR + rr == GrrR | (ky1, dy1)\n", " GrR + r == GrrR | (ky1, dy1)\n", " GrR + rr == GrrrR | (ky1, dy1)\n", "\n", " R + Gr == GrR | (ky2, dy2)\n", " R + Grr == GrrR | (ky2, dy2)\n", " rR + Gr == GrrR | (ky2, dy2)\n", " rR + Grr == GrrrR | (ky2, dy2)\n", "\n", " GR + R == GRR | (ky3, dy3)\n", " GR + rR == GrRR | (ky3, dy3)\n", " GrR + R == GrRR | (ky3, dy3)\n", " GrR + rR == GrrRR | (ky3, dy3)\n", "\n", " Grr == GrR | (ka1*L, da1)\n", " Grrr == GrrR | (ka1*L, da1)\n", " Grrrr == GrrrR | (ka1*L, da1)\n", "\n", " GrR == GRR | (ka2*L, da2)\n", " GrrR == GrRR | (ka2*L, da2)\n", " GrrrR == GrrRR | (ka2*L, da2)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 670 }, "colab_type": "code", "id": "GpBH69Ent6qc", "outputId": "c4f007e8-512f-47eb-8d73-5022ec2054d6" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "rr : 0\n", "rrr : 0\n", "rrrr : 0\n", "R : 0\n", "rR : 0\n", "rrR : 0\n", "rrrR : 0\n", "RR : 0\n", "rRR : 0\n", "rrRR : 0\n", "Gr : 0\n", "Grr : 0\n", "Grrr : 0\n", "Grrrr : 0\n", "GR : 0\n", "GrR : 0\n", "GrrR : 0\n", "GrrrR : 0\n", "GRR : 0\n", "GrRR : 0\n", "GrrRR : 0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "run_N2(m, mols, obs0)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "TTB02hgvqXqi" }, "source": [ "### Trivalent model (N = 3 and kx > 0)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": {}, "colab_type": "code", "id": "r1JxfELAqXqk" }, "outputs": [], "source": [ "# this is the trivalent model : N=3\n", "N = 3.00\n", "\n", "mols = [\"r\", \"rr\", \"rrr\", \"rrrr\", \"rrrrr\", \"rrrrrr\",\n", " \"R\", \"rR\", \"rrR\", \"rrrR\", \"rrrrR\", \"rrrrrR\",\n", " \"RR\", \"rRR\", \"rrRR\", \"rrrRR\", \"rrrrRR\",\n", " \"Gr\", \"Grr\", \"Grrr\", \"Grrrr\", \"Grrrrr\", \"Grrrrrr\",\n", " \"GR\", \"GrR\", \"GrrR\", \"GrrrR\", \"GrrrrR\", \"GrrrrrR\",\n", " \"GRR\", \"GrRR\", \"GrrRR\", \"GrrrRR\", \"GrrrrRR\"]" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "4G_xWl19qXqr", "outputId": "73e30046-9223-4912-d60a-31c7b7370eb1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n", "r + r > rr | 0.00020092425155716296\n", "rr > r + r | 1.0\n", "r + rr > rrr | 0.00020092425155716296\n", "rrr > r + rr | 1.0\n", "r + rrr > rrrr | 0.00020092425155716296\n", "rrrr > r + rrr | 1.0\n", "rr + r > rrr | 0.00020092425155716296\n", "rrr > rr + r | 1.0\n", "rr + rr > rrrr | 0.00020092425155716296\n", "rrrr > rr + rr | 1.0\n", "rr + rrr > rrrrr | 0.00020092425155716296\n", "rrrrr > rr + rrr | 1.0\n", "rrr + r > rrrr | 0.00020092425155716296\n", "rrrr > rrr + r | 1.0\n", "rrr + rr > rrrrr | 0.00020092425155716296\n", "rrrrr > rrr + rr | 1.0\n", "rrr + rrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrr + rrr | 1.0\n", "R + r > rR | 2.0092425155716294e-06\n", "rR > R + r | 1.0\n", "R + rr > rrR | 2.0092425155716294e-06\n", "rrR > R + rr | 1.0\n", "R + rrr > rrrR | 2.0092425155716294e-06\n", "rrrR > R + rrr | 1.0\n", "rR + r > rrR | 2.0092425155716294e-06\n", "rrR > rR + r | 1.0\n", "rR + rr > rrrR | 2.0092425155716294e-06\n", "rrrR > rR + rr | 1.0\n", "rR + rrr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rR + rrr | 1.0\n", "rrR + r > rrrR | 2.0092425155716294e-06\n", "rrrR > rrR + r | 1.0\n", "rrR + rr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rrR + rr | 1.0\n", "rrR + rrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrR + rrr | 1.0\n", "R + R > RR | 2.0092425155716296e-08\n", "RR > R + R | 1.0\n", "R + rR > rRR | 2.0092425155716296e-08\n", "rRR > R + rR | 1.0\n", "R + rrR > rrRR | 2.0092425155716296e-08\n", "rrRR > R + rrR | 1.0\n", "rR + R > rRR | 2.0092425155716296e-08\n", "rRR > rR + R | 1.0\n", "rR + rR > rrRR | 2.0092425155716296e-08\n", "rrRR > rR + rR | 1.0\n", "rR + rrR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rR + rrR | 1.0\n", "rrR + R > rrRR | 2.0092425155716296e-08\n", "rrRR > rrR + R | 1.0\n", "rrR + rR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rrR + rR | 1.0\n", "rrR + rrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrR + rrR | 1.0\n", "rr > rR | 0.01\n", "rR > rr | 1.0\n", "rrr > rrR | 0.01\n", "rrR > rrr | 1.0\n", "rrrr > rrrR | 0.01\n", "rrrR > rrrr | 1.0\n", "rrrrr > rrrrR | 0.01\n", "rrrrR > rrrrr | 1.0\n", "rrrrrr > rrrrrR | 0.01\n", "rrrrrR > rrrrrr | 1.0\n", "rR > RR | 0.01\n", "RR > rR | 1.0\n", "rrR > rRR | 0.01\n", "rRR > rrR | 1.0\n", "rrrR > rrRR | 0.01\n", "rrRR > rrrR | 1.0\n", "rrrrR > rrrRR | 0.01\n", "rrrRR > rrrrR | 1.0\n", "rrrrrR > rrrrRR | 0.01\n", "rrrrRR > rrrrrR | 1.0\n", "rr > Grr | 0.01\n", "Grr > rr | 1.0\n", "rrr > Grrr | 0.01\n", "Grrr > rrr | 1.0\n", "rrrr > Grrrr | 0.01\n", "Grrrr > rrrr | 1.0\n", "rrrrr > Grrrrr | 0.01\n", "Grrrrr > rrrrr | 1.0\n", "rrrrrr > Grrrrrr | 0.01\n", "Grrrrrr > rrrrrr | 1.0\n", "rR > GrR | 0.01\n", "GrR > rR | 1.0\n", "rrR > GrrR | 0.01\n", "GrrR > rrR | 1.0\n", "rrrR > GrrrR | 0.01\n", "GrrrR > rrrR | 1.0\n", "rrrrR > GrrrrR | 0.01\n", "GrrrrR > rrrrR | 1.0\n", "rrrrrR > GrrrrrR | 0.01\n", "GrrrrrR > rrrrrR | 1.0\n", "RR > GRR | 0.01\n", "GRR > RR | 1.0\n", "rRR > GrRR | 0.01\n", "GrRR > rRR | 1.0\n", "rrRR > GrrRR | 0.01\n", "GrrRR > rrRR | 1.0\n", "rrrRR > GrrrRR | 0.01\n", "GrrrRR > rrrRR | 1.0\n", "rrrrRR > GrrrrRR | 0.01\n", "GrrrrRR > rrrrRR | 1.0\n", "Gr + r > Grr | 0.00020092425155716296\n", "Grr > Gr + r | 1.0\n", "Gr + rr > Grrr | 0.00020092425155716296\n", "Grrr > Gr + rr | 1.0\n", "Gr + rrr > Grrrr | 0.00020092425155716296\n", "Grrrr > Gr + rrr | 1.0\n", "Grr + r > Grrr | 0.00020092425155716296\n", "Grrr > Grr + r | 1.0\n", "Grr + rr > Grrrr | 0.00020092425155716296\n", "Grrrr > Grr + rr | 1.0\n", "Grr + rrr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grr + rrr | 1.0\n", "Grrr + r > Grrrr | 0.00020092425155716296\n", "Grrrr > Grrr + r | 1.0\n", "Grrr + rr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grrr + rr | 1.0\n", "Grrr + rrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrr + rrr | 1.0\n", "GR + r > GrR | 2.0092425155716294e-06\n", "GrR > GR + r | 1.0\n", "GR + rr > GrrR | 2.0092425155716294e-06\n", "GrrR > GR + rr | 1.0\n", "GR + rrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GR + rrr | 1.0\n", "GrR + r > GrrR | 2.0092425155716294e-06\n", "GrrR > GrR + r | 1.0\n", "GrR + rr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrR + rr | 1.0\n", "GrR + rrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrR + rrr | 1.0\n", "GrrR + r > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrrR + r | 1.0\n", "GrrR + rr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrrR + rr | 1.0\n", "GrrR + rrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrR + rrr | 1.0\n", "R + Gr > GrR | 2.0092425155716294e-06\n", "GrR > R + Gr | 1.0\n", "R + Grr > GrrR | 2.0092425155716294e-06\n", "GrrR > R + Grr | 1.0\n", "R + Grrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > R + Grrr | 1.0\n", "rR + Gr > GrrR | 2.0092425155716294e-06\n", "GrrR > rR + Gr | 1.0\n", "rR + Grr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rR + Grr | 1.0\n", "rR + Grrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rR + Grrr | 1.0\n", "rrR + Gr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rrR + Gr | 1.0\n", "rrR + Grr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rrR + Grr | 1.0\n", "rrR + Grrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrR + Grrr | 1.0\n", "GR + R > GRR | 2.0092425155716296e-08\n", "GRR > GR + R | 1.0\n", "GR + rR > GrRR | 2.0092425155716296e-08\n", "GrRR > GR + rR | 1.0\n", "GR + rrR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GR + rrR | 1.0\n", "GrR + R > GrRR | 2.0092425155716296e-08\n", "GrRR > GrR + R | 1.0\n", "GrR + rR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrR + rR | 1.0\n", "GrR + rrR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrR + rrR | 1.0\n", "GrrR + R > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrrR + R | 1.0\n", "GrrR + rR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrrR + rR | 1.0\n", "GrrR + rrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrR + rrR | 1.0\n", "Grr > GrR | 0.01\n", "GrR > Grr | 1.0\n", "Grrr > GrrR | 0.01\n", "GrrR > Grrr | 1.0\n", "Grrrr > GrrrR | 0.01\n", "GrrrR > Grrrr | 1.0\n", "Grrrrr > GrrrrR | 0.01\n", "GrrrrR > Grrrrr | 1.0\n", "Grrrrrr > GrrrrrR | 0.01\n", "GrrrrrR > Grrrrrr | 1.0\n", "GrR > GRR | 0.01\n", "GRR > GrR | 1.0\n", "GrrR > GrRR | 0.01\n", "GrRR > GrrR | 1.0\n", "GrrrR > GrrRR | 0.01\n", "GrrRR > GrrrR | 1.0\n", "GrrrrR > GrrrRR | 0.01\n", "GrrrRR > GrrrrR | 1.0\n", "GrrrrrR > GrrrrRR | 0.01\n", "GrrrrRR > GrrrrrR | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", "\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", " # receptor dimerization\n", " r + r == rr | (kx0, dx0)\n", " r + rr == rrr | (kx0, dx0)\n", " r + rrr == rrrr | (kx0, dx0)\n", " rr + r == rrr | (kx0, dx0)\n", " rr + rr == rrrr | (kx0, dx0)\n", " rr + rrr == rrrrr | (kx0, dx0)\n", " rrr + r == rrrr | (kx0, dx0)\n", " rrr + rr == rrrrr | (kx0, dx0)\n", " rrr + rrr == rrrrrr | (kx0, dx0)\n", "\n", " R + r == rR | (kx1, dx1)\n", " R + rr == rrR | (kx1, dx1)\n", " R + rrr == rrrR | (kx1, dx1)\n", " rR + r == rrR | (kx1, dx1)\n", " rR + rr == rrrR | (kx1, dx1)\n", " rR + rrr == rrrrR | (kx1, dx1)\n", " rrR + r == rrrR | (kx1, dx1)\n", " rrR + rr == rrrrR | (kx1, dx1)\n", " rrR + rrr == rrrrrR | (kx1, dx1)\n", "\n", " R + R == RR | (kx2, dx2)\n", " R + rR == rRR | (kx2, dx2)\n", " R + rrR == rrRR | (kx2, dx2)\n", " rR + R == rRR | (kx2, dx2)\n", " rR + rR == rrRR | (kx2, dx2)\n", " rR + rrR == rrrRR | (kx2, dx2)\n", " rrR + R == rrRR | (kx2, dx2)\n", " rrR + rR == rrrRR | (kx2, dx2)\n", " rrR + rrR == rrrrRR | (kx2, dx2)\n", "\n", " rr == rR | (kl1*L, dl1)\n", " rrr == rrR | (kl1*L, dl1)\n", " rrrr == rrrR | (kl1*L, dl1)\n", " rrrrr == rrrrR | (kl1*L, dl1)\n", " rrrrrr == rrrrrR | (kl1*L, dl1)\n", "\n", " rR == RR | (kl2*L, dl2)\n", " rrR == rRR | (kl2*L, dl2)\n", " rrrR == rrRR | (kl2*L, dl2)\n", " rrrrR == rrrRR | (kl2*L, dl2)\n", " rrrrrR == rrrrRR | (kl2*L, dl2)\n", "\n", " # dimers coupled with G-proteins\n", " rr == Grr | (kg1*G, dg1)\n", " rrr == Grrr | (kg1*G, dg1)\n", " rrrr == Grrrr | (kg1*G, dg1)\n", " rrrrr == Grrrrr | (kg1*G, dg1)\n", " rrrrrr == Grrrrrr | (kg1*G, dg1)\n", "\n", " rR == GrR | (kb1*G, db1)\n", " rrR == GrrR | (kb1*G, db1)\n", " rrrR == GrrrR | (kb1*G, db1)\n", " rrrrR == GrrrrR | (kb1*G, db1)\n", " rrrrrR == GrrrrrR | (kb1*G, db1)\n", "\n", " RR == GRR | (kb2*G, db2)\n", " rRR == GrRR | (kb2*G, db2)\n", " rrRR == GrrRR | (kb2*G, db2)\n", " rrrRR == GrrrRR | (kb2*G, db2)\n", " rrrrRR == GrrrrRR | (kb2*G, db2)\n", "\n", " Gr + r == Grr | (ky0, dy0)\n", " Gr + rr == Grrr | (ky0, dy0)\n", " Gr + rrr == Grrrr | (ky0, dy0)\n", " Grr + r == Grrr | (ky0, dy0)\n", " Grr + rr == Grrrr | (ky0, dy0)\n", " Grr + rrr == Grrrrr | (ky0, dy0)\n", " Grrr + r == Grrrr | (ky0, dy0)\n", " Grrr + rr == Grrrrr | (ky0, dy0)\n", " Grrr + rrr == Grrrrrr | (ky0, dy0)\n", "\n", " GR + r == GrR | (ky1, dy1)\n", " GR + rr == GrrR | (ky1, dy1)\n", " GR + rrr == GrrrR | (ky1, dy1)\n", " GrR + r == GrrR | (ky1, dy1)\n", " GrR + rr == GrrrR | (ky1, dy1)\n", " GrR + rrr == GrrrrR | (ky1, dy1)\n", " GrrR + r == GrrrR | (ky1, dy1)\n", " GrrR + rr == GrrrrR | (ky1, dy1)\n", " GrrR + rrr == GrrrrrR | (ky1, dy1)\n", "\n", " R + Gr == GrR | (ky2, dy2)\n", " R + Grr == GrrR | (ky2, dy2)\n", " R + Grrr == GrrrR | (ky2, dy2)\n", " rR + Gr == GrrR | (ky2, dy2)\n", " rR + Grr == GrrrR | (ky2, dy2)\n", " rR + Grrr == GrrrrR | (ky2, dy2)\n", " rrR + Gr == GrrrR | (ky2, dy2)\n", " rrR + Grr == GrrrrR | (ky2, dy2)\n", " rrR + Grrr == GrrrrrR | (ky2, dy2)\n", "\n", " GR + R == GRR | (ky3, dy3)\n", " GR + rR == GrRR | (ky3, dy3)\n", " GR + rrR == GrrRR | (ky3, dy3)\n", " GrR + R == GrRR | (ky3, dy3)\n", " GrR + rR == GrrRR | (ky3, dy3)\n", " GrR + rrR == GrrrRR | (ky3, dy3)\n", " GrrR + R == GrrRR | (ky3, dy3)\n", " GrrR + rR == GrrrRR | (ky3, dy3)\n", " GrrR + rrR == GrrrrRR | (ky3, dy3)\n", "\n", " Grr == GrR | (ka1*L, da1)\n", " Grrr == GrrR | (ka1*L, da1)\n", " Grrrr == GrrrR | (ka1*L, da1)\n", " Grrrrr == GrrrrR | (ka1*L, da1)\n", " Grrrrrr == GrrrrrR | (ka1*L, da1)\n", "\n", " GrR == GRR | (ka2*L, da2)\n", " GrrR == GrRR | (ka2*L, da2)\n", " GrrrR == GrrRR | (ka2*L, da2)\n", " GrrrrR == GrrrRR | (ka2*L, da2)\n", " GrrrrrR == GrrrrRR | (ka2*L, da2)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 874 }, "colab_type": "code", "id": "UQgLJ_ixvFHr", "outputId": "39104c8c-b589-485f-bad2-8f5f9b947baa" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "rr : 0\n", "rrr : 0\n", "rrrr : 0\n", "rrrrr : 0\n", "rrrrrr : 0\n", "R : 0\n", "rR : 0\n", "rrR : 0\n", "rrrR : 0\n", "rrrrR : 0\n", "rrrrrR : 0\n", "RR : 0\n", "rRR : 0\n", "rrRR : 0\n", "rrrRR : 0\n", "rrrrRR : 0\n", "Gr : 0\n", "Grr : 0\n", "Grrr : 0\n", "Grrrr : 0\n", "Grrrrr : 0\n", "Grrrrrr : 0\n", "GR : 0\n", "GrR : 0\n", "GrrR : 0\n", "GrrrR : 0\n", "GrrrrR : 0\n", "GrrrrrR : 0\n", "GRR : 0\n", "GrRR : 0\n", "GrrRR : 0\n", "GrrrRR : 0\n", "GrrrrRR : 0\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEGCAYAAACkQqisAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3deZwU1bn/8c8zK8MyDDADoqCIwQWioI5EY9wN4hL1JjFKXEBN+HmjJsabRZPcGOMvidsvMUZj5CLB5EbBiLtRwkXReEUFBBVQAy5REGFYZoDpWXq6n98fVQ0NDLPRPT3T/X2/Xv2qqtNV1U8XzDxzzqk6x9wdERGRjsjLdAAiItJ9KYmIiEiHKYmIiEiHKYmIiEiHKYmIiEiHFWQ6gHQoLy/3YcOGZToMEZFuZdGiRevdvaI9x2RlEhk2bBgLFy7MdBgiIt2Kmf2rvceoOUtERDpMSURERDpMSURERDosK/tERKRraWxs5L333iMSiWQ6FAF69uzJAQccQFFR0R6fS0lERNLuvffeo6ysjIMOOoi8PDWAZFI8Hmft2rWsWLGCkSNHYmZ7dD79a4pI2kUiEQYNGqQE0gXk5eUxaNAg6urqmDNnDrFYbM/Ol6K4RERapATSdeTl5WFmvPXWWyxfvnyPzqXmrC7MHerqYOtWqK0N1hsbt78aGravNzVBLLbrMhaDeLz5l/vuX4nPTyx3Ltt5vbnt1sr35LpI93LOOZmOQJrz1lvFfPDBBvr37/g5lEQ6USwGH34IK1bA2rVQVQXr1u243LgxSBiJxKFfmM3bw2Zc6WRdIYnk5+dz6KGH4u7k5+dz11138fnPfz6tn5l48Lm8vLzVfadPn864cePYe++9U7JfWyxebGzY4HzyScfPoSSSBu6wbBm88Qa888721z//GdQakhUXw8CBUFERvD7zGejTB3r1gt69d1yWlEBRUXBMUdGOr4KC4JWfv32Z/MrL2/FlFiwhWG/ulXgveZ/ksp3Xm9sWAVi0KNMRQElJCUuWLAFg9uzZXH/99bzwwgsZjmq76dOn89nPfrZNSaQt+7XF5MkwciScdFKw3ZGfXyWRFIlEYO5cePrp4LVqVVCenw8HHAAHHwxnnBEsDzwQBg8Okkbv3vrFK9LZNm/eTL9+/QBwd37wgx/wzDPPYGb85Cc/4fzzz2fevHncfvvtPPXUUwBcddVVVFZWMmnSJIYNG8bEiRN58skniUaj/PWvf+Xggw9mw4YNTJgwgaqqKsaOHUtzM8fGYjEuv/xyFi5ciJlx2WWXMXToUBYuXMiFF15ISUkJ8+fP57bbbuPJJ5+krq6Oz3/+89x7773MmjVrl/2WL1/Otddey9atWykvL2f69OkMHjyYO++8kz/84Q8UFBQwcuRIZsyYkZZrqSSyB9atg4cfhqeeguefh/r6ICmMGwc33gjHHBMkkBTcii2SNa65BsIKQcqMGQN33NHyPnV1dYwZM4b6+nrWrFnDc889B8AjjzzCkiVLeOONN1i/fj1HHXUUxx9/fKufWV5ezuuvv87vf/97br/9dqZOncqNN97IF77wBX7605/y9NNPM2XKlF2OW7JkCatXr2bp0qUAVFdXU1ZWxl133cXtt99OZWUlECStn/70pwBcfPHFPPXUU3z1q1/dYb9oNMrVV1/N448/TkVFBTNnzuTHP/4x06ZN4+abb+aDDz6guLiY6urq9lzOdlES6YD6+uA/7C9/CVu2BE1Q/+f/wFlnwXHHBc1NItK1JDdnzZ8/n0suuYSlS5fy0ksvMWHCBPLz8xk0aBAnnHACCxYsoLS0tMXzffnLXwbgyCOP5JFHHgHgxRdf3LZ+5plnbqvtJBs+fDjvv/8+V199NWeeeSbjxo1r9vzPP/88t956K5FIhI0bNzJq1Ci+9KUv7bDPu+++y9KlS/niF78IBLWcwYMHA3DYYYdx4YUXcu6553Luuee29TK1m5JIO7jDX/8KP/xh0EF+9tnwi1/AZz+b6chEuo/Wagyd4ZhjjmH9+vVUVVU12+QEUFBQQDwe37ZdX1+/w/vF4V+L+fn5NDU1bStv7eG9fv368cYbbzB79mzuvvtuHnroIaZNm7bDPvX19XzrW99i4cKFDB06lJ/97Ge7fD4ETXGjRo1i/vz5u7z39NNP8+KLL/LEE09w0003sWzZMgoKUv8rXzdut9GCBUEt4/zzobQU/ud/4PHHlUBEuqN33nmHWCzGgAEDOP7445k5cyaxWIyqqipefPFFxo4dy3777cfy5ctpaGigpqaGuXPntnre448/nr/85S8APPPMM2zatGmXfdavX088HucrX/kKN910E6+//joAffr0YcuWLcD2hFVeXs7WrVt5+OGHtx2fvN9BBx1EVVXVtiQSjUZZtmwZ8Xicjz/+mJNOOolbb72V6upqtm7dugdXbPdUE2lFdTV8+9vw5z8Hd1FNmQKXXRZ0mItI95HoE4HgL/j777+f/Px8/u3f/o358+czevRozIxbb72VvfbaC4Cvfe1rHHbYYYwYMYLDDz+81c+44YYbmDBhAkcccQQnnHAC++677y77rF69mksvvXRbLedXv/oVAJMmTeKKK67Y1mH+zW9+k0MPPZRhw4Zx1FFHbTt+5/0efvhhvv3tb1NTU0NTUxPXXHMNBx54IBdddBE1NTW4O9/97ncpKyvb42vYHNtdVa47q6ys9FRMStXQAKedBi+/DNdeCz/6UVALEZH2WbRoEUceeWSmw5AkixYt4pVXXmHkyJGcFN7ja2aL3L2yPedRTWQ34nGYNAleeAEeeAAmTMh0RCIiXY/6RHbjuutgxgy4+WYlEBGR3VESacbdd8Ntt8G//zv84AeZjkZEpOtSEtnJ448HHelnnw2/+52eJhcRaUlak4iZfWhmb5nZEjNbGJb1N7M5ZrYiXPYLy83M7jSzlWb2ppkdkXSeieH+K8xsYrrifeWVoOmqshIefFB3YImItKYzaiInufuYpB7/64C57j4CmBtuA5wOjAhfk4F7IEg6wA3A54CxwA2JxJNKK1fCl74UjGn15JPQs2eqP0FEJPtkojnrHOD+cP1+4Nyk8j954BWgzMwGA6cBc9x9o7tvAuYA41MZUGNjMDiiOzz7bPA8iIhkDzPj4osv3rbd1NRERUUFZ511Vgajyg7pTiIO/N3MFpnZ5LBskLuvAQiXiV/Z+wAfJx27KizbXfkOzGyymS00s4VVVVXtCvLJJ4M5Pu67D0aMaNehItIN9OrVi6VLl1JXVwfAnDlz2GefXX6NSAekO4kc6+5HEDRVXWlmLQ2N2VwXtrdQvmOB+xR3r3T3yoqKinYFOXUqDBkSDKAoItnp9NNP5+mnnwbgwQcfZILu3U+JtD5s6O6fhMt1ZvYoQZ/GWjMb7O5rwuaqdeHuq4ChSYcPAT4Jy0/cqXxeqmL86COYPRv+8z/VkS7SGW58chnLP9mc0nOO3LuUG740qsV9LrjgAn7+859z1lln8eabb3LZZZfxj3/8I6Vx5KK01UTMrJeZ9UmsA+OApcATQOIOq4nA4+H6E8Al4V1aRwM1YXPXbGCcmfULO9THhWUp8cc/BstLL03VGUWkKzrssMP48MMPefDBBznjjDMyHU7WSGdNZBDwaDgscgHwgLs/a2YLgIfM7HLgI+C8cP+/AWcAK4EIcCmAu280s5uABeF+P3f3jakIMBaDadPg1FNh2LBUnFFEWtNajSGdzj77bL73ve8xb948NmzYkLE4sknakoi7vw+MbqZ8A3BKM+UOXLmbc00DpjX33p6YOzdozrrttlSfWUS6ossuu4y+ffty6KGHMm/evEyHkxVy+on1qVNhwAA455xMRyIinWHIkCF85zvfyXQYWSVnR/GtqoLHHoOrrtJ0tiLZrrkJmU488UROPPHEzg8my+RsTeTPf4ZoFC6/PNORiIh0XzmZRNyDpqxjjoFRmevjExHp9nKyOWv+fHj77eAJdRER6bicrIncdx/07g1f+1qmIxER6d5yLols3hzMWHjBBUEiERGRjsu5JDJzJkQi8I1vZDoSEZHuL+eSyNSp8NnPwtixmY5ERDpLfn4+Y8aMYdSoUYwePZpf//rXxOPxTIeVFXKqY/3NN+G11+COOzTtrUguKSkpYcmSJQCsW7eOr3/969TU1HDjjTdmOLLuL6dqItOmQVERXHRRpiMRkUwZOHAgU6ZM4a677iIYbUn2RE7VRJYsCZqxBgzIdCQiOeyZ6+DTt1J7zr0OhdNvbvPuw4cPJx6Ps27dOgYNGpTaWHJMTtVEIhHo0yfTUYhIV6BaSGrkVE0kEoGePTMdhUiOa0eNIV3ef/998vPzGThwYOs7S4tyqiZSW6skIpLrqqqquOKKK7jqqqsw3WGzx3KuJtKrV6ajEJHOVldXx5gxY4hGoxQUFHDxxRdz7bXXZjqsrJBTSUQ1EZHcFIvFMh1C1sqZ5ix31URERFItZ5JIQ0OQSFQTERFJnZxJIrW1wVJJREQkdXImiUQiwVLNWSIiqZMzSUQ1ERGR1MuZJKKaiIhI6uVcElFNRCQ3rV27lq9//esMHz6cI488kmOOOYZHH310t/tPnz4dM2Pu3Lnbyh599FHMjIcffrgzQu4WciaJqDlLJHe5O+eeey7HH38877//PosWLWLGjBmsWrWqxeMOPfRQHnzwwW3bM2bMYPTo0ekOt1vJmSSi5iyR3PXcc89RVFTEFVdcsa1sv/324+qrr27xuOOOO47XXnuNaDTK1q1bWblyJWPGjEl3uN1KzjyxrpqISNdwy2u38M7Gd1J6zoP7H8wPx/5wt+8vW7aMI444Yrfvz5o1i8svv5zx48czY8aMbeVmxqmnnsrs2bOpqanh7LPP5oMPPkhp7N1d2msiZpZvZovN7Klwe38ze9XMVpjZTDMrCsuLw+2V4fvDks5xfVj+rpmd1pE4VBMRkYQrr7yS0aNHc9RRRwHwxz/+kZqaGmbOnMn69et32PeCCy5gxowZzJgxgwkTJmQi3C6tM2oi3wHeBkrD7VuA37j7DDP7A3A5cE+43OTunzGzC8L9zjezkcAFwChgb+B/zOxAd2/XYDjqWBfpGlqqMaTLqFGjmDVr1rbtu+++m/Xr11NZWQnAxIkTeemllxg/fjzl5eU7HDt27FiWLl1KSUkJBx54YKfG3R2ktSZiZkOAM4Gp4bYBJwOJWxvuB84N188JtwnfPyXc/xxghrs3uPsHwEpgbHtjUXOWSO46+eSTqa+v55577tlWFkn8ZQmcd955VFdX79CUlexXv/oVv/zlL9MeZ3eU7prIHcAPgMR8ggOAandvCrdXAfuE6/sAHwO4e5OZ1YT77wO8knTO5GO2MbPJwGSAfffdd5dAIhEoKAjmWBeR3GJmPPbYY3z3u9/l1ltvpaKigl69enHLLbe06fjTTz89zRF2X2lLImZ2FrDO3ReZ2YmJ4mZ29Vbea+mY7QXuU4ApAJWVlbu8r2HgRXLb4MGDd1vTaM6kSZOYNGnSLuXTp09PXVBZIJ01kWOBs83sDKAHQZ/IHUCZmRWEtZEhwCfh/quAocAqMysA+gIbk8oTko9pMw0DLyKSemnrE3H36919iLsPI+gYf87dLwSeB74a7jYReDxcfyLcJnz/OXf3sPyC8O6t/YERwGvtjUfzq4uIpF4mnhP5ITDDzP4vsBi4Lyy/D/izma0kqIFcAODuy8zsIWA50ARc2d47s0DNWSIi6dApScTd5wHzwvX3aebuKnevB87bzfG/AH6xJzGoOUtEJPVyZtgT1URERFIvZ5KIaiIiIqmXU0lENRGR3NWRoeArKio4/PDDGTFiBKeddhovv/xyJ0bcPeRMElFzlkju6uhQ8Oeffz6LFy9mxYoVXHfddXz5y1/m7bff7qSou4ecSSJqzhLJXR0dCj7ZSSedxOTJk5kyZUo6Quy2cmooeNVERDLv01/+koa3UzsUfPEhB7PXj3602/c7OhT8zo444gjuvffePYo12+RETSQWg4YG1UREJNCeoeCTBc8/S7KcqInU1QVL1UREMq+lGkO67MlQ8MkWL17MIYcckvZ4u5OcqIloGHiR3LanQ8EDvPDCC0yZMoVvfvObaY21u8mJmohmNRTJbR0dCn7mzJm89NJLRCIR9t9/f2bNmqWayE5yIomoJiIiqRoKXnaUE81ZqomIiKRHTiUR1URERFIrJ5KImrNEMi8ej2c6BAml8t8iJ5KImrNEMqtnz56sWbNGiaQLiMfjfPrpp0Sj0ZScTx3rIpJ2BxxwAAsWLODTTz/NdCgCRKNRPvroI+LxOIWFhXt0rpxIIqqJiGRWUVERNTU1LFiwgNLSUsws0yHlvKamJpqamhg6dOgenSenkohqIiKZ88UvfpHi4mJWr16tZq0uoFevXhx33HHst99+e3SenEgiieaskpLMxiGSywoLCznllFMyHYakWM50rPfoAfn5mY5ERCS75EQS0TDwIiLpkRNJRBNSiYikR84kEdVERERSLyeSiJqzRETSIyeSiJqzRETSIyeSiGoiIiLp0aYkYmbnmVmfcP0nZvaIme1+1vsuRjUREZH0aGtN5D/dfYuZfQE4DbgfuKeVY7oMdayLiKRHW5NILFyeCdzj7o8DRS0dYGY9zOw1M3vDzJaZ2Y1h+f5m9qqZrTCzmWZWFJYXh9srw/eHJZ3r+rD8XTM7rb1fUs1ZIiLp0dYkstrM7gW+BvzNzIrbcGwDcLK7jwbGAOPN7GjgFuA37j4C2ARcHu5/ObDJ3T8D/CbcDzMbCVwAjALGA783s3Y9e67mLBGR9Gjr2FlfI/gFfru7V5vZYOD7LR3g7g5sDTcLw5cDJwNfD8vvB35G0DR2TrgO8DBwlwVDfZ4DzHD3BuADM1sJjAXmtyVw965bE4nHnYamOPXRGHXRGPXRGA1NcaKxONGY0xSL0xR3orE4TTGnKe7EPXjF4oklxN1xd+IefN+4Ow64O+7hkuC9RHmyxGaw1/bt5rTwVovHiUh2ajGJmFn/pM15SWUNwMLWTh7WGBYBnwHuBt4Dqt29KdxlFbBPuL4P8DGAuzeZWQ0wICx/Jem0ycckf9ZkYDLAvvvuu608GoVYrHNqIlvqo6zaVMfHGyOs2lTHxtpGqusaqalrojrSyOa6KNV1UTbXRYk0BglDRKQ7a60msojgj08D9iVofjKgDPgI2L+lg909BowxszLgUeCQ5nYLl81NMOAtlO/8WVOAKQCVlZXb3k/HMPB1jTEWf7yJhR9u4u01m4PEsSlCdWTHmcLy84y+JYXbXmU9ixhW3ovSHoX0LMqnR2HwKinM27ZeXJBHYX4eBfkWLPOMgvw8CvON/LzglWfBKz/PyDfDLPgsM8gzwwALy7etQ7gdFCbeS0jM72Dbtnf//a3Zf5LWjxORrq3klvYf02IScff9AczsD8AT7v63cPt04NS2fkjYBDYPOBooM7OCsDYyBPgk3G0VMBRYZWYFQF9gY1J5QvIxrUrFrIbVkUYWfLiJhR9u5LUPN7J0dQ3RmGMGwwb0Ymj/nhw2pC9D+/dkSL8ShvYLlv17FWnyHRHJam3tEznK3a9IbLj7M2Z2U0sHmFkFEA0TSAlB0rkFeB74KjADmAg8Hh7yRLg9P3z/OXd3M3sCeMDMfg3sDYwAXmvrF+zorIbuzsvvbeCP//sBc99ZhzsU5edx2JC+fOO44Rw1rB9H7tufvj33bGpJEZHurK1JZL2Z/QT4b4KmpIuADa0cMxi4P+wXyQMecvenzGw5MMPM/i+wGLgv3P8+4M9hx/lGgjuycPdlZvYQsBxoAq4Mm8napL01kbrGGI8uXs30lz/gn2u3MqBXEf9+wgGccGAFo4eW0aNQk5KIiCS0NYlMAG4g6NcAeDEs2y13fxM4vJny9wnurtq5vB44bzfn+gXwizbGuoO21kRWV9fxp5c/ZMaCj6mpizJq71JuP280Zx02WIlDRGQ32pRE3H0j8J00x5IWrXWsb21o4nfPrWDaSx8Qdzht1CAuPXZ/Kvfrp/4MEZFWtCmJmNmBwPeAYcnHuPvJ6QkrdXbXnBWPO48tWc2vnnmHqi0NnHfkEK754oHsU6aJ2EVE2qqtzVl/Bf4ATGX7ECjdQnPNWW+uquZnTyzj9Y+qGT20jP+6pJIxQ8syE6CISDfW1iTS5O7dZsDFZMk1kY21jdz67DvMXPgxA3oVcdtXD+MrRwwhL0/NViIiHdHWJPKkmX2LoGO9IVEY9pV0ack1kf98fCmzl37K5cfuz7dPHUFpD92eKyKyJ9qaRCaGy+TxshwYntpwUi+5Y/2jDRGOG1HOT84amdmgRESyRFvvzmpxeJOurLY2GIqjuBiq6xo5oELD+YqIpEpb7866pLlyd/9TasNJvcQw8GZQE4lS1rPFaVBERKQd2jzsSdJ6D+AU4HWgyyeRxDDwsbizub6J0hL1g4iIpEpbm7OuTt42s77An9MSUYolaiJb6oMRdsuUREREUqatMxvuLEIwEGKXl5hfvaYuSCJ9lURERFKmrX0iT7J9Do98gnlBHkpXUKmUaM5KzPVRplF3RURSpq19IrcnrTcB/3L3VWmIJ+USzVmqiYiIpF5b+0ReMLNBbO9gX5G+kFKrthYGDYLqLpBEmqKNbFr3EdWf/ou6LZto2FJN49bNNG7dQqx2K021W4nX1eHRKDQ24k1NEG2Cxig0NWFNMSzuEA+XsTgWdyweh7hj4UTqFky0jjnBejj5efA+QLhvyLZPst4s283k6dbWOdU197pI1mprc9bXgNsI5lk34Hdm9n13fziNsaXELjWRNDZnba1ZzwdL/kHV8kXUrfgnvn4jBZu2Urylnp5bGuld69s6oQrDV3Oa8iCWD035RlOBEcs34tteebgZnm94XviycJlvuOVBuJ00Py5OYh22z4+7fbgXb21e3OTyHdbbdm1cIyKLdH0vt/+QtjZn/ZhgdsN1sG3Wwv8BukUS6dkTaiKNQOpqInWRzSx+8o9sevV/yftwNaWra+hfE6OAYDauxnyoKSugvk8xdXv1pfbgUjb0L6OwvILi8gqK+/SjuHdfivuUUdKnjJ6l/elZOoAePUspKNSzLCKSAX9u/x97bU0ieYkEEtpAx+/s6lSJjvWauiglhfkUF3R8gqnI1mpef3wq1bOfZe8lq+nXCL3yYcPAHmw6aC82Dx9G6cGj2Puzn2PEQZVKBiKS9dqaRJ41s9nAg+H2+cDf0hNSaiU3Z3WkFhJtrOeVmXey+dln2fvNNQyIQlFP45OjhzPwzHMYM/4iiorbOPeuiEiWaWvH+vfN7MvAFwhawae4+6OtHJZx8fj25qw1kfYnkX8tf5V/XnslQz6spaiXsfoLn2HQmf/G4eO+TmFRjzRFLSLSfbS1JoK7PwI8YmblBM1ZXV59fbDcVhNpY6d6PB5n3r0/peyeWfQ349P/uIDjJl2v5ikRkZ202K9hZkeb2Twze8TMDjezpcBSYK2Zje+cEDsueRj4tjZnbfz0Xzxz4ckM/u0sqvYtZa9ZD3DSN29QAhERaUZrNZG7gB8BfYHngNPd/RUzO5igf+TZNMe3R5JnNaxZG+XQVpLIa0/8F7Gb7mDf2jj/uuh4Tv3h75Q8RERa0FoSKXD3vwOY2c/d/RUAd3/HusF9/8mzGla30CcSj8d55vsTGP70m6wdWETZnb9k/DFndmKkIiLdU2tJJJ60XrfTe13+OeRETaSoR5y6aGy342YtfHIqw59+k/eO25+Tf/MAPXuXdWKUIiLdV2tJZLSZbSa4I6skXCfc7vK3JyVqIhTtfsiTeDxOzd33Eu2bzxfvfIjikt6dGKGISPfWYhJx944/mdcFJJJIvCB4Wr25Calee+wPDPkowupvna0EIiLSTm2+xbc7SjRnNeUlhoHfsZM8Ho+z9fdTaeqXz/HfvKGzwxMR6fbSNnSJmQ01s+fN7G0zW2Zm3wnL+5vZHDNbES77heVmZnea2Uoze9PMjkg618Rw/xVmNrGtMSRqIlFrvjnr1Vl3s8+qOhouOpuiEj11LiLSXukc/6oJ+A93PwQ4GrjSzEYC1wFz3X0EMDfcBjidYLbEEcBk4B4Ikg5wA/A5YCxwQyLxtCZRE2lk16lx4/E4kT9MY33/Ao77xk/25HuKiOSstCURd1/j7q+H61uAt4F9gHOA+8Pd7gfODdfPAf7kgVeAMjMbDJwGzHH3je6+CZgDtOlBx0RNpD6+a01k/kO/Ze/V9UQvOVdjX4mIdFCnjMRrZsOAw4FXgUHuvgaCRAMMDHfbB/g46bBVYdnuynf+jMlmttDMFlZVVQHbk0hdLEgiiY71WKyJhnv/RNWAAo677Mcp+IYiIrkp7UnEzHoDs4Br3H1zS7s2U+YtlO9Y4D7F3SvdvbKiogIImrMKC2FLQ5Q+PQrIzwtONX/GHQxeU0980lc0kKKIyB5IaxIxs0KCBPKXcABHCMbdGhy+PxhIzFOyChiadPgQ4JMWylvV3DDwsVgT0f/6b9ZVFHLsxOtaOYOIiLQknXdnGXAf8La7/zrprSeAxB1WE4HHk8ovCe/SOhqoCZu7ZgPjzKxf2KE+LixrVfKEVImn1f/3L/+PvT5twCedp1qIiMgeSudzIscCFwNvmdmSsOxHwM3AQ2Z2OfARcF743t+AM4CVQAS4FMDdN5rZTcCCcL+fu/vGtgSQqIlURxrpW1JIU7SR+NQHWDuwiC9c8sNUfEcRkZyWtiTi7i/RfH8GwCnN7O/Albs51zRgWntj2Da/el2UwX1LePm/b2fQukaqrrtEo/OKiKRAt5gnvaOSm7NKSwqJPPYkVQMKOfbi72c6NBGRrJDVSSQSgZ69fFufSMnGWrbsN4D8/Kwe7UVEpNNkdRKprYUevWJEY07fkkJ6b47i5W162F1ERNogq5NIJALFfYIHDXv5Fno2QEFFeYajEhHJHlmfRAp6BkmkaMsqAIoHDc5kSCIiWSWrk0htLeSXBEmkoCYYOaX34KEtHSIiIu2Q1UkkEoG8HkESydu0BoB+Qw7IZEgiIlkla5NIUxM0NgJFwayGtikYXaV86IEZjEpEJLtkbRLZeX71vI3raSiA0v7qExERSZWsTyKx/Cj5eUbehmq2lBaQl5e1X1lEpNNl7W/U5ISD+CAAAAv5SURBVPnV+5YUUrhxM3V9NeCiiEgqZW0SSZ5fvaykkJLqeqL9+2Q2KBGRLJO1SSRRE2nwYNys3lv0tLqISKplbRJJnl99QP5WShqhYGBFZoMSEckyWZtEEjWRSFOU/o3BMyLFA3VnlohIKmVtEknURGqjUcrqPwWgz977ZjAiEZHsk+VJxKltjNI7UgVA2ZDhGY1JRCTbZG0Sqa2FvOImHCjZsh6AgUMPymxQIiJZJmuTSPK4WT23bKKhEHqXDcxwVCIi2SVrk0htLeSVBONmldRsZrOeVhcRSbms/a0aiUCP0rAmUlNLXVlJhiMSEck+WZ1ESvqGSWRzPU16Wl1EJOWyNonU1oZT43qcvlua9LS6iEgaFGQ6gHSJRKCoV5TC+GaKo1BQrqfVRURSLatrIgU9owyOBU+r99hr7wxHJCKSfbI2iUQikFcSZR82AFC6934ZjkhEJPtkdxIpbqQiuhHQ0+oiIumQtiRiZtPMbJ2ZLU0q629mc8xsRbjsF5abmd1pZivN7E0zOyLpmInh/ivMbGJbP7+2FrwoSnlDNQAVmltdRCTl0lkTmQ6M36nsOmCuu48A5obbAKcDI8LXZOAeCJIOcAPwOWAscEMi8bQmEgEvjFIWqaGuCProaXURkZRLWxJx9xeBjTsVnwPcH67fD5ybVP4nD7wClJnZYOA0YI67b3T3TcAcdk1MzaqtDeZXL63dytbSwj39OiIi0ozO7hMZ5O5rAMJlonqwD/Bx0n6rwrLdlbcqEoEmi1K6tU5Pq4uIpElX6Vi3Zsq8hfJdT2A22cwWmtnCqqoqIvVxmixG6ZYGza0uIpImnZ1E1obNVITLdWH5KmBo0n5DgE9aKN+Fu09x90p3rywvr4Ci4Gn1sq0xrLx/yr+IiIh0fhJ5AkjcYTUReDyp/JLwLq2jgZqwuWs2MM7M+oUd6uPCshbFYsEw8L1jmyhqgoIKPa0uIpIOaRv2xMweBE4Eys1sFcFdVjcDD5nZ5cBHwHnh7n8DzgBWAhHgUgB332hmNwELwv1+7u47d9bvIh4Pkkh5NJgWt2SvNnWjiIhIO6Utibj7hN28dUoz+zpw5W7OMw2Y1p7Pjschv0cj/aNBa1lvza0uIpIWXaVjPaUSNZEBjcGQJ/2HHJDhiEREslNWJ5Hy+uBp9fIhelpdRCQdsjeJlETpX7+ZSDH07jsg0yGJiGSl7E0iPaIMqI/oaXURkTTK6iTSP1JPXVnPTIcjIpK1sjqJ9KttpGmAnlYXEUmXrEwisRjkFTfQb2scG6Cn1UVE0iUrk0g8Dv16fEJhDAoGagh4EZF0ydokUlEQDP5bMlhzq4uIpEv2JhFbA0Dp4GGZDUZEJItlbRIpj1YB0E9Pq4uIpE1WJpGYxxlQXwNobnURkXTKziQSd/rXb6a2h9Gzd1mmwxERyVpZmUTi7vSvi7C5T9oGKRYREbI5iehpdRGRtMvOJILTvzaqudVFRNIsK5OIu9OvNk6e5lYXEUmrrEwiedZIQRyK99or06GIiGS1rEwi+dYAQE/NrS4iklZZmUQKrBGA0r2HZTYQEZEsl51JhCgA/YfqaXURkXTKziTiTQCUDxmR4UhERLJbliaRGFt6GCU9SzMdiohIVsvKJJLvcap762l1EZF0y8okUhCPU9O7JNNhiIhkvSxNIk5t796ZDkNEJOtlZRLJj0NDqUbvFRFJt6xMIuYQL9Pc6iIi6dZtkoiZjTezd81spZld19r+BRWaW11EJN26RRIxs3zgbuB0YCQwwcxGtnRM6eD9OyM0EZGc1l3ugx0LrHT39wHMbAZwDrB8dwccterXcNdvgw33pHeS1ncoFxGR9uouSWQf4OOk7VXA55J3MLPJwGSAA0p7UD7kYOhZCGaJPZJ3Tj4yHfGKiHRDi9t9RHdJIs39pt+hGuHuU4ApAJWVlV466YHOiEtEJItMa/cR3aJPhKDmMTRpewjwSYZiERGRUHdJIguAEWa2v5kVARcAT2Q4JhGRnNctmrPcvcnMrgJmA/nANHdfluGwRERyXrdIIgDu/jfgb5mOQ0REtusuzVkiItIFKYmIiEiHKYmIiEiHKYmIiEiHmWfh0B9mtgV4N9NxdBHlwPpMB9FF6Fpsp2uxna7Fdge5e5/2HNBt7s5qp3fdvTLTQXQFZrZQ1yKga7GdrsV2uhbbmdnC9h6j5iwREekwJREREemwbE0iUzIdQBeia7GdrsV2uhbb6Vps1+5rkZUd6yIi0jmytSYiIiKdQElEREQ6LOuSiJmNN7N3zWylmV2X6Xg6k5lNM7N1ZrY0qay/mc0xsxXhsl8mY+wsZjbUzJ43s7fNbJmZfScsz7nrYWY9zOw1M3sjvBY3huX7m9mr4bWYGU6zkPXMLN/MFpvZU+F2Tl4HADP70MzeMrMlidt72/szklVJxMzygbuB04GRwAQzG5nZqDrVdGD8TmXXAXPdfQQwN9zOBU3Af7j7IcDRwJXh/4VcvB4NwMnuPhoYA4w3s6OBW4DfhNdiE3B5BmPsTN8B3k7aztXrkHCSu49JelamXT8jWZVEgLHASnd/390bgRnAORmOqdO4+4vAxp2KzwHuD9fvB87t1KAyxN3XuPvr4foWgl8a+5CD18MDW8PNwvDlwMnAw2F5TlwLMxsCnAlMDbeNHLwOrWjXz0i2JZF9gI+TtleFZblskLuvgeAXKzAww/F0OjMbBhwOvEqOXo+wCWcJsA6YA7wHVLt7U7hLrvys3AH8AIiH2wPIzeuQ4MDfzWyRmU0Oy9r1M5Jtw55YM2W6hzmHmVlvYBZwjbtvDv7wzD3uHgPGmFkZ8ChwSHO7dW5UncvMzgLWufsiMzsxUdzMrll9HXZyrLt/YmYDgTlm9k57T5BtNZFVwNCk7SHAJxmKpatYa2aDAcLlugzH02nMrJAggfzF3R8Ji3P2egC4ezUwj6CfqMzMEn9I5sLPyrHA2Wb2IUFT98kENZNcuw7buPsn4XIdwR8XY2nnz0i2JZEFwIjwbosi4ALgiQzHlGlPABPD9YnA4xmMpdOEbd33AW+7+6+T3sq562FmFWENBDMrAU4l6CN6HvhquFvWXwt3v97dh7j7MILfDc+5+4Xk2HVIMLNeZtYnsQ6MA5bSzp+RrHti3czOIPjrIh+Y5u6/yHBIncbMHgROJBjaei1wA/AY8BCwL/ARcJ6779z5nnXM7AvAP4C32N7+/SOCfpGcuh5mdhhBB2k+wR+OD7n7z81sOMFf5P2BxcBF7t6QuUg7T9ic9T13PytXr0P4vR8NNwuAB9z9F2Y2gHb8jGRdEhERkc6Tbc1ZIiLSiZRERESkw5RERESkw5RERESkw5RERESkw5RERESkw5RERAAzGxAOh73EzD41s9VJ2y+n4fMmmVmVmU1N4TnPD6dAeCpV5xRpTbaNnSXSIe6+gWCYdMzsZ8BWd789zR87092vStXJ3H2mma0Fvpeqc4q0RjURkVaY2dZweaKZvWBmD5nZP83sZjO7MJzw6S0zOyDcr8LMZpnZgvB1bBs+Y1R4niVm9qaZjQjLL0oqvzecMycx+drr4URTc9P5/UVaopqISPuMJhgBdyPwPjDV3cdaMHPi1cA1wG8JJjl6ycz2BWbT/Ki5ya4AfuvufwnHfcs3s0OA8wlGWo2a2e+BC83sGeC/gOPd/QMz65+OLyrSFkoiIu2zIDHXgpm9B/w9LH8LOClcPxUYmTTsfKmZ9Qknx9qd+cCPw0mTHnH3FWZ2CnAksCA8VwnBiKpHAy+6+wcA2T72l3RtSiIi7ZM8MF88aTvO9p+nPOAYd69r60nd/QEze5Vg1r3ZZvYNgrku7nf365P3NbOzya05L6QLU5+ISOr9HdjWYW5mY1o7IBxR9X13v5NgKO7DCOa3/mo4YRBm1t/M9iOotZxgZvsnylP/FUTaRklEJPW+DVSGHeTLCfo7WnM+sDScwvZg4E/uvhz4CcH0pW8STGs72N2rgMnAI2b2BjAzLd9CpA00FLxIBpjZJKAylbf4huc9kXCejFSeV2R3VBMRyYw64PRUP2wI/B7YlKpzirRGNREREekw1URERKTDlERERKTDlERERKTDlERERKTD/j8BK2QfeR3KWwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "run_N3(m, mols, obs0)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "QafM0o29qXqz" }, "source": [ "### Tetravalent model (N = 4 and kx > 0)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": {}, "colab_type": "code", "id": "ZA4v6MQZqXqz" }, "outputs": [], "source": [ "# this is the tetravalent model : N=4\n", "N = 4.00\n", "\n", "mols = [\"r\", \"rr\", \"rrr\", \"rrrr\", \"rrrrr\", \"rrrrrr\", \"rrrrrrr\", \"rrrrrrrr\",\n", " \"R\", \"rR\", \"rrR\", \"rrrR\", \"rrrrR\", \"rrrrrR\", \"rrrrrrR\", \"rrrrrrrR\",\n", " \"RR\", \"rRR\", \"rrRR\", \"rrrRR\", \"rrrrRR\", \"rrrrrRR\", \"rrrrrrRR\",\n", " \"Gr\", \"Grr\", \"Grrr\", \"Grrrr\", \"Grrrrr\", \"Grrrrrr\", \"Grrrrrrr\", \"Grrrrrrrr\",\n", " \"GR\", \"GrR\", \"GrrR\", \"GrrrR\", \"GrrrrR\", \"GrrrrrR\", \"GrrrrrrR\", \"GrrrrrrrR\",\n", " \"GRR\", \"GrRR\", \"GrrRR\", \"GrrrRR\", \"GrrrrRR\", \"GrrrrrRR\", \"GrrrrrrRR\"]" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "MnLKO6C4qXq8", "outputId": "f71f5615-e5a7-4bec-b486-7073d2eba8e8" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n", "r + r > rr | 0.00020092425155716296\n", "rr > r + r | 1.0\n", "r + rr > rrr | 0.00020092425155716296\n", "rrr > r + rr | 1.0\n", "r + rrr > rrrr | 0.00020092425155716296\n", "rrrr > r + rrr | 1.0\n", "r + rrrr > rrrrr | 0.00020092425155716296\n", "rrrrr > r + rrrr | 1.0\n", "rr + r > rrr | 0.00020092425155716296\n", "rrr > rr + r | 1.0\n", "rr + rr > rrrr | 0.00020092425155716296\n", "rrrr > rr + rr | 1.0\n", "rr + rrr > rrrrr | 0.00020092425155716296\n", "rrrrr > rr + rrr | 1.0\n", "rr + rrrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rr + rrrr | 1.0\n", "rrr + r > rrrr | 0.00020092425155716296\n", "rrrr > rrr + r | 1.0\n", "rrr + rr > rrrrr | 0.00020092425155716296\n", "rrrrr > rrr + rr | 1.0\n", "rrr + rrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrr + rrr | 1.0\n", "rrr + rrrr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rrr + rrrr | 1.0\n", "rrrr + r > rrrrr | 0.00020092425155716296\n", "rrrrr > rrrr + r | 1.0\n", "rrrr + rr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrrr + rr | 1.0\n", "rrrr + rrr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rrrr + rrr | 1.0\n", "rrrr + rrrr > rrrrrrrr | 0.00020092425155716296\n", "rrrrrrrr > rrrr + rrrr | 1.0\n", "R + r > rR | 2.0092425155716294e-06\n", "rR > R + r | 1.0\n", "R + rr > rrR | 2.0092425155716294e-06\n", "rrR > R + rr | 1.0\n", "R + rrr > rrrR | 2.0092425155716294e-06\n", "rrrR > R + rrr | 1.0\n", "R + rrrr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > R + rrrr | 1.0\n", "rR + r > rrR | 2.0092425155716294e-06\n", "rrR > rR + r | 1.0\n", "rR + rr > rrrR | 2.0092425155716294e-06\n", "rrrR > rR + rr | 1.0\n", "rR + rrr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rR + rrr | 1.0\n", "rR + rrrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rR + rrrr | 1.0\n", "rrR + r > rrrR | 2.0092425155716294e-06\n", "rrrR > rrR + r | 1.0\n", "rrR + rr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rrR + rr | 1.0\n", "rrR + rrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrR + rrr | 1.0\n", "rrR + rrrr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rrR + rrrr | 1.0\n", "rrrR + r > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rrrR + r | 1.0\n", "rrrR + rr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrrR + rr | 1.0\n", "rrrR + rrr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rrrR + rrr | 1.0\n", "rrrR + rrrr > rrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrR > rrrR + rrrr | 1.0\n", "R + R > RR | 2.0092425155716296e-08\n", "RR > R + R | 1.0\n", "R + rR > rRR | 2.0092425155716296e-08\n", "rRR > R + rR | 1.0\n", "R + rrR > rrRR | 2.0092425155716296e-08\n", "rrRR > R + rrR | 1.0\n", "R + rrrR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > R + rrrR | 1.0\n", "rR + R > rRR | 2.0092425155716296e-08\n", "rRR > rR + R | 1.0\n", "rR + rR > rrRR | 2.0092425155716296e-08\n", "rrRR > rR + rR | 1.0\n", "rR + rrR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rR + rrR | 1.0\n", "rR + rrrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rR + rrrR | 1.0\n", "rrR + R > rrRR | 2.0092425155716296e-08\n", "rrRR > rrR + R | 1.0\n", "rrR + rR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rrR + rR | 1.0\n", "rrR + rrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrR + rrR | 1.0\n", "rrR + rrrR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rrR + rrrR | 1.0\n", "rrrR + R > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rrrR + R | 1.0\n", "rrrR + rR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrrR + rR | 1.0\n", "rrrR + rrR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rrrR + rrR | 1.0\n", "rrrR + rrrR > rrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrRR > rrrR + rrrR | 1.0\n", "rr > rR | 0.01\n", "rR > rr | 1.0\n", "rrr > rrR | 0.01\n", "rrR > rrr | 1.0\n", "rrrr > rrrR | 0.01\n", "rrrR > rrrr | 1.0\n", "rrrrr > rrrrR | 0.01\n", "rrrrR > rrrrr | 1.0\n", "rrrrrr > rrrrrR | 0.01\n", "rrrrrR > rrrrrr | 1.0\n", "rrrrrrr > rrrrrrR | 0.01\n", "rrrrrrR > rrrrrrr | 1.0\n", "rrrrrrrr > rrrrrrrR | 0.01\n", "rrrrrrrR > rrrrrrrr | 1.0\n", "rR > RR | 0.01\n", "RR > rR | 1.0\n", "rrR > rRR | 0.01\n", "rRR > rrR | 1.0\n", "rrrR > rrRR | 0.01\n", "rrRR > rrrR | 1.0\n", "rrrrR > rrrRR | 0.01\n", "rrrRR > rrrrR | 1.0\n", "rrrrrR > rrrrRR | 0.01\n", "rrrrRR > rrrrrR | 1.0\n", "rrrrrrR > rrrrrRR | 0.01\n", "rrrrrRR > rrrrrrR | 1.0\n", "rrrrrrrR > rrrrrrRR | 0.01\n", "rrrrrrRR > rrrrrrrR | 1.0\n", "rr > Grr | 0.01\n", "Grr > rr | 1.0\n", "rrr > Grrr | 0.01\n", "Grrr > rrr | 1.0\n", "rrrr > Grrrr | 0.01\n", "Grrrr > rrrr | 1.0\n", "rrrrr > Grrrrr | 0.01\n", "Grrrrr > rrrrr | 1.0\n", "rrrrrr > Grrrrrr | 0.01\n", "Grrrrrr > rrrrrr | 1.0\n", "rrrrrrr > Grrrrrrr | 0.01\n", "Grrrrrrr > rrrrrrr | 1.0\n", "rrrrrrrr > Grrrrrrrr | 0.01\n", "Grrrrrrrr > rrrrrrrr | 1.0\n", "rR > GrR | 0.01\n", "GrR > rR | 1.0\n", "rrR > GrrR | 0.01\n", "GrrR > rrR | 1.0\n", "rrrR > GrrrR | 0.01\n", "GrrrR > rrrR | 1.0\n", "rrrrR > GrrrrR | 0.01\n", "GrrrrR > rrrrR | 1.0\n", "rrrrrR > GrrrrrR | 0.01\n", "GrrrrrR > rrrrrR | 1.0\n", "rrrrrrR > GrrrrrrR | 0.01\n", "GrrrrrrR > rrrrrrR | 1.0\n", "rrrrrrrR > GrrrrrrrR | 0.01\n", "GrrrrrrrR > rrrrrrrR | 1.0\n", "RR > GRR | 0.01\n", "GRR > RR | 1.0\n", "rRR > GrRR | 0.01\n", "GrRR > rRR | 1.0\n", "rrRR > GrrRR | 0.01\n", "GrrRR > rrRR | 1.0\n", "rrrRR > GrrrRR | 0.01\n", "GrrrRR > rrrRR | 1.0\n", "rrrrRR > GrrrrRR | 0.01\n", "GrrrrRR > rrrrRR | 1.0\n", "rrrrrRR > GrrrrrRR | 0.01\n", "GrrrrrRR > rrrrrRR | 1.0\n", "rrrrrrRR > GrrrrrrRR | 0.01\n", "GrrrrrrRR > rrrrrrRR | 1.0\n", "Gr + r > Grr | 0.00020092425155716296\n", "Grr > Gr + r | 1.0\n", "Gr + rr > Grrr | 0.00020092425155716296\n", "Grrr > Gr + rr | 1.0\n", "Gr + rrr > Grrrr | 0.00020092425155716296\n", "Grrrr > Gr + rrr | 1.0\n", "Gr + rrrr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Gr + rrrr | 1.0\n", "Grr + r > Grrr | 0.00020092425155716296\n", "Grrr > Grr + r | 1.0\n", "Grr + rr > Grrrr | 0.00020092425155716296\n", "Grrrr > Grr + rr | 1.0\n", "Grr + rrr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grr + rrr | 1.0\n", "Grr + rrrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grr + rrrr | 1.0\n", "Grrr + r > Grrrr | 0.00020092425155716296\n", "Grrrr > Grrr + r | 1.0\n", "Grrr + rr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grrr + rr | 1.0\n", "Grrr + rrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrr + rrr | 1.0\n", "Grrr + rrrr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grrr + rrrr | 1.0\n", "Grrrr + r > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grrrr + r | 1.0\n", "Grrrr + rr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrrr + rr | 1.0\n", "Grrrr + rrr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grrrr + rrr | 1.0\n", "Grrrr + rrrr > Grrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrr > Grrrr + rrrr | 1.0\n", "GR + r > GrR | 2.0092425155716294e-06\n", "GrR > GR + r | 1.0\n", "GR + rr > GrrR | 2.0092425155716294e-06\n", "GrrR > GR + rr | 1.0\n", "GR + rrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GR + rrr | 1.0\n", "GR + rrrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GR + rrrr | 1.0\n", "GrR + r > GrrR | 2.0092425155716294e-06\n", "GrrR > GrR + r | 1.0\n", "GrR + rr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrR + rr | 1.0\n", "GrR + rrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrR + rrr | 1.0\n", "GrR + rrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrR + rrrr | 1.0\n", "GrrR + r > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrrR + r | 1.0\n", "GrrR + rr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrrR + rr | 1.0\n", "GrrR + rrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrR + rrr | 1.0\n", "GrrR + rrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrrR + rrrr | 1.0\n", "GrrrR + r > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrrrR + r | 1.0\n", "GrrrR + rr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrrR + rr | 1.0\n", "GrrrR + rrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrrrR + rrr | 1.0\n", "GrrrR + rrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > GrrrR + rrrr | 1.0\n", "R + Gr > GrR | 2.0092425155716294e-06\n", "GrR > R + Gr | 1.0\n", "R + Grr > GrrR | 2.0092425155716294e-06\n", "GrrR > R + Grr | 1.0\n", "R + Grrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > R + Grrr | 1.0\n", "R + Grrrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > R + Grrrr | 1.0\n", "rR + Gr > GrrR | 2.0092425155716294e-06\n", "GrrR > rR + Gr | 1.0\n", "rR + Grr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rR + Grr | 1.0\n", "rR + Grrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rR + Grrr | 1.0\n", "rR + Grrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rR + Grrrr | 1.0\n", "rrR + Gr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rrR + Gr | 1.0\n", "rrR + Grr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rrR + Grr | 1.0\n", "rrR + Grrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrR + Grrr | 1.0\n", "rrR + Grrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rrR + Grrrr | 1.0\n", "rrrR + Gr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rrrR + Gr | 1.0\n", "rrrR + Grr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrrR + Grr | 1.0\n", "rrrR + Grrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rrrR + Grrr | 1.0\n", "rrrR + Grrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > rrrR + Grrrr | 1.0\n", "GR + R > GRR | 2.0092425155716296e-08\n", "GRR > GR + R | 1.0\n", "GR + rR > GrRR | 2.0092425155716296e-08\n", "GrRR > GR + rR | 1.0\n", "GR + rrR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GR + rrR | 1.0\n", "GR + rrrR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GR + rrrR | 1.0\n", "GrR + R > GrRR | 2.0092425155716296e-08\n", "GrRR > GrR + R | 1.0\n", "GrR + rR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrR + rR | 1.0\n", "GrR + rrR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrR + rrR | 1.0\n", "GrR + rrrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrR + rrrR | 1.0\n", "GrrR + R > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrrR + R | 1.0\n", "GrrR + rR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrrR + rR | 1.0\n", "GrrR + rrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrR + rrR | 1.0\n", "GrrR + rrrR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrrR + rrrR | 1.0\n", "GrrrR + R > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrrrR + R | 1.0\n", "GrrrR + rR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrrR + rR | 1.0\n", "GrrrR + rrR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrrrR + rrR | 1.0\n", "GrrrR + rrrR > GrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrRR > GrrrR + rrrR | 1.0\n", "Grr > GrR | 0.01\n", "GrR > Grr | 1.0\n", "Grrr > GrrR | 0.01\n", "GrrR > Grrr | 1.0\n", "Grrrr > GrrrR | 0.01\n", "GrrrR > Grrrr | 1.0\n", "Grrrrr > GrrrrR | 0.01\n", "GrrrrR > Grrrrr | 1.0\n", "Grrrrrr > GrrrrrR | 0.01\n", "GrrrrrR > Grrrrrr | 1.0\n", "Grrrrrrr > GrrrrrrR | 0.01\n", "GrrrrrrR > Grrrrrrr | 1.0\n", "Grrrrrrrr > GrrrrrrrR | 0.01\n", "GrrrrrrrR > Grrrrrrrr | 1.0\n", "GrR > GRR | 0.01\n", "GRR > GrR | 1.0\n", "GrrR > GrRR | 0.01\n", "GrRR > GrrR | 1.0\n", "GrrrR > GrrRR | 0.01\n", "GrrRR > GrrrR | 1.0\n", "GrrrrR > GrrrRR | 0.01\n", "GrrrRR > GrrrrR | 1.0\n", "GrrrrrR > GrrrrRR | 0.01\n", "GrrrrRR > GrrrrrR | 1.0\n", "GrrrrrrR > GrrrrrRR | 0.01\n", "GrrrrrRR > GrrrrrrR | 1.0\n", "GrrrrrrrR > GrrrrrrRR | 0.01\n", "GrrrrrrRR > GrrrrrrrR | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", "\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", " # receptor dimerization\n", " r + r == rr | (kx0, dx0)\n", " r + rr == rrr | (kx0, dx0)\n", " r + rrr == rrrr | (kx0, dx0)\n", " r + rrrr == rrrrr | (kx0, dx0)\n", " rr + r == rrr | (kx0, dx0)\n", " rr + rr == rrrr | (kx0, dx0)\n", " rr + rrr == rrrrr | (kx0, dx0)\n", " rr + rrrr == rrrrrr | (kx0, dx0)\n", " rrr + r == rrrr | (kx0, dx0)\n", " rrr + rr == rrrrr | (kx0, dx0)\n", " rrr + rrr == rrrrrr | (kx0, dx0)\n", " rrr + rrrr == rrrrrrr | (kx0, dx0)\n", " rrrr + r == rrrrr | (kx0, dx0)\n", " rrrr + rr == rrrrrr | (kx0, dx0)\n", " rrrr + rrr == rrrrrrr | (kx0, dx0)\n", " rrrr + rrrr == rrrrrrrr | (kx0, dx0)\n", "\n", " R + r == rR | (kx1, dx1)\n", " R + rr == rrR | (kx1, dx1)\n", " R + rrr == rrrR | (kx1, dx1)\n", " R + rrrr == rrrrR | (kx1, dx1)\n", " rR + r == rrR | (kx1, dx1)\n", " rR + rr == rrrR | (kx1, dx1)\n", " rR + rrr == rrrrR | (kx1, dx1)\n", " rR + rrrr == rrrrrR | (kx1, dx1)\n", " rrR + r == rrrR | (kx1, dx1)\n", " rrR + rr == rrrrR | (kx1, dx1)\n", " rrR + rrr == rrrrrR | (kx1, dx1)\n", " rrR + rrrr == rrrrrrR | (kx1, dx1)\n", " rrrR + r == rrrrR | (kx1, dx1)\n", " rrrR + rr == rrrrrR | (kx1, dx1)\n", " rrrR + rrr == rrrrrrR | (kx1, dx1)\n", " rrrR + rrrr == rrrrrrrR | (kx1, dx1)\n", "\n", " R + R == RR | (kx2, dx2)\n", " R + rR == rRR | (kx2, dx2)\n", " R + rrR == rrRR | (kx2, dx2)\n", " R + rrrR == rrrRR | (kx2, dx2)\n", " rR + R == rRR | (kx2, dx2)\n", " rR + rR == rrRR | (kx2, dx2)\n", " rR + rrR == rrrRR | (kx2, dx2)\n", " rR + rrrR == rrrrRR | (kx2, dx2)\n", " rrR + R == rrRR | (kx2, dx2)\n", " rrR + rR == rrrRR | (kx2, dx2)\n", " rrR + rrR == rrrrRR | (kx2, dx2)\n", " rrR + rrrR == rrrrrRR | (kx2, dx2)\n", " rrrR + R == rrrRR | (kx2, dx2)\n", " rrrR + rR == rrrrRR | (kx2, dx2)\n", " rrrR + rrR == rrrrrRR | (kx2, dx2)\n", " rrrR + rrrR == rrrrrrRR | (kx2, dx2)\n", "\n", " rr == rR | (kl1*L, dl1)\n", " rrr == rrR | (kl1*L, dl1)\n", " rrrr == rrrR | (kl1*L, dl1)\n", " rrrrr == rrrrR | (kl1*L, dl1)\n", " rrrrrr == rrrrrR | (kl1*L, dl1)\n", " rrrrrrr == rrrrrrR | (kl1*L, dl1)\n", " rrrrrrrr == rrrrrrrR | (kl1*L, dl1)\n", "\n", " rR == RR | (kl2*L, dl2)\n", " rrR == rRR | (kl2*L, dl2)\n", " rrrR == rrRR | (kl2*L, dl2)\n", " rrrrR == rrrRR | (kl2*L, dl2)\n", " rrrrrR == rrrrRR | (kl2*L, dl2)\n", " rrrrrrR == rrrrrRR | (kl2*L, dl2)\n", " rrrrrrrR == rrrrrrRR | (kl2*L, dl2)\n", "\n", " # dimers coupled with G-proteins\n", " rr == Grr | (kg1*G, dg1)\n", " rrr == Grrr | (kg1*G, dg1)\n", " rrrr == Grrrr | (kg1*G, dg1)\n", " rrrrr == Grrrrr | (kg1*G, dg1)\n", " rrrrrr == Grrrrrr | (kg1*G, dg1)\n", " rrrrrrr == Grrrrrrr | (kg1*G, dg1)\n", " rrrrrrrr == Grrrrrrrr | (kg1*G, dg1)\n", "\n", " rR == GrR | (kb1*G, db1)\n", " rrR == GrrR | (kb1*G, db1)\n", " rrrR == GrrrR | (kb1*G, db1)\n", " rrrrR == GrrrrR | (kb1*G, db1)\n", " rrrrrR == GrrrrrR | (kb1*G, db1)\n", " rrrrrrR == GrrrrrrR | (kb1*G, db1)\n", " rrrrrrrR == GrrrrrrrR | (kb1*G, db1)\n", "\n", " RR == GRR | (kb2*G, db2)\n", " rRR == GrRR | (kb2*G, db2)\n", " rrRR == GrrRR | (kb2*G, db2)\n", " rrrRR == GrrrRR | (kb2*G, db2)\n", " rrrrRR == GrrrrRR | (kb2*G, db2)\n", " rrrrrRR == GrrrrrRR | (kb2*G, db2)\n", " rrrrrrRR == GrrrrrrRR | (kb2*G, db2)\n", "\n", " Gr + r == Grr | (ky0, dy0)\n", " Gr + rr == Grrr | (ky0, dy0)\n", " Gr + rrr == Grrrr | (ky0, dy0)\n", " Gr + rrrr == Grrrrr | (ky0, dy0)\n", " Grr + r == Grrr | (ky0, dy0)\n", " Grr + rr == Grrrr | (ky0, dy0)\n", " Grr + rrr == Grrrrr | (ky0, dy0)\n", " Grr + rrrr == Grrrrrr | (ky0, dy0)\n", " Grrr + r == Grrrr | (ky0, dy0)\n", " Grrr + rr == Grrrrr | (ky0, dy0)\n", " Grrr + rrr == Grrrrrr | (ky0, dy0)\n", " Grrr + rrrr == Grrrrrrr | (ky0, dy0)\n", " Grrrr + r == Grrrrr | (ky0, dy0)\n", " Grrrr + rr == Grrrrrr | (ky0, dy0)\n", " Grrrr + rrr == Grrrrrrr | (ky0, dy0)\n", " Grrrr + rrrr == Grrrrrrrr | (ky0, dy0)\n", "\n", " GR + r == GrR | (ky1, dy1)\n", " GR + rr == GrrR | (ky1, dy1)\n", " GR + rrr == GrrrR | (ky1, dy1)\n", " GR + rrrr == GrrrrR | (ky1, dy1)\n", " GrR + r == GrrR | (ky1, dy1)\n", " GrR + rr == GrrrR | (ky1, dy1)\n", " GrR + rrr == GrrrrR | (ky1, dy1)\n", " GrR + rrrr == GrrrrrR | (ky1, dy1)\n", " GrrR + r == GrrrR | (ky1, dy1)\n", " GrrR + rr == GrrrrR | (ky1, dy1)\n", " GrrR + rrr == GrrrrrR | (ky1, dy1)\n", " GrrR + rrrr == GrrrrrrR | (ky1, dy1)\n", " GrrrR + r == GrrrrR | (ky1, dy1)\n", " GrrrR + rr == GrrrrrR | (ky1, dy1)\n", " GrrrR + rrr == GrrrrrrR | (ky1, dy1)\n", " GrrrR + rrrr == GrrrrrrrR | (ky1, dy1)\n", "\n", "\n", " R + Gr == GrR | (ky2, dy2)\n", " R + Grr == GrrR | (ky2, dy2)\n", " R + Grrr == GrrrR | (ky2, dy2)\n", " R + Grrrr == GrrrrR | (ky2, dy2)\n", " rR + Gr == GrrR | (ky2, dy2)\n", " rR + Grr == GrrrR | (ky2, dy2)\n", " rR + Grrr == GrrrrR | (ky2, dy2)\n", " rR + Grrrr == GrrrrrR | (ky2, dy2)\n", " rrR + Gr == GrrrR | (ky2, dy2)\n", " rrR + Grr == GrrrrR | (ky2, dy2)\n", " rrR + Grrr == GrrrrrR | (ky2, dy2)\n", " rrR + Grrrr == GrrrrrrR | (ky2, dy2)\n", " rrrR + Gr == GrrrrR | (ky2, dy2)\n", " rrrR + Grr == GrrrrrR | (ky2, dy2)\n", " rrrR + Grrr == GrrrrrrR | (ky2, dy2)\n", " rrrR + Grrrr == GrrrrrrrR | (ky2, dy2)\n", "\n", " GR + R == GRR | (ky3, dy3)\n", " GR + rR == GrRR | (ky3, dy3)\n", " GR + rrR == GrrRR | (ky3, dy3)\n", " GR + rrrR == GrrrRR | (ky3, dy3)\n", " GrR + R == GrRR | (ky3, dy3)\n", " GrR + rR == GrrRR | (ky3, dy3)\n", " GrR + rrR == GrrrRR | (ky3, dy3)\n", " GrR + rrrR == GrrrrRR | (ky3, dy3)\n", " GrrR + R == GrrRR | (ky3, dy3)\n", " GrrR + rR == GrrrRR | (ky3, dy3)\n", " GrrR + rrR == GrrrrRR | (ky3, dy3)\n", " GrrR + rrrR == GrrrrrRR | (ky3, dy3)\n", " GrrrR + R == GrrrRR | (ky3, dy3)\n", " GrrrR + rR == GrrrrRR | (ky3, dy3)\n", " GrrrR + rrR == GrrrrrRR | (ky3, dy3)\n", " GrrrR + rrrR == GrrrrrrRR | (ky3, dy3)\n", "\n", " Grr == GrR | (ka1*L, da1)\n", " Grrr == GrrR | (ka1*L, da1)\n", " Grrrr == GrrrR | (ka1*L, da1)\n", " Grrrrr == GrrrrR | (ka1*L, da1)\n", " Grrrrrr == GrrrrrR | (ka1*L, da1)\n", " Grrrrrrr == GrrrrrrR | (ka1*L, da1)\n", " Grrrrrrrr == GrrrrrrrR | (ka1*L, da1)\n", "\n", " GrR == GRR | (ka2*L, da2)\n", " GrrR == GrRR | (ka2*L, da2)\n", " GrrrR == GrrRR | (ka2*L, da2)\n", " GrrrrR == GrrrRR | (ka2*L, da2)\n", " GrrrrrR == GrrrrRR | (ka2*L, da2)\n", " GrrrrrrR == GrrrrrRR | (ka2*L, da2)\n", " GrrrrrrrR == GrrrrrrRR | (ka2*L, da2)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "7r8hp6DKvdQ0", "outputId": "f31dbd47-f1b4-44db-c80e-5183666d8c60" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "rr : 0\n", "rrr : 0\n", "rrrr : 0\n", "rrrrr : 0\n", "rrrrrr : 0\n", "rrrrrrr : 0\n", "rrrrrrrr : 0\n", "R : 0\n", "rR : 0\n", "rrR : 0\n", "rrrR : 0\n", "rrrrR : 0\n", "rrrrrR : 0\n", "rrrrrrR : 0\n", "rrrrrrrR : 0\n", "RR : 0\n", "rRR : 0\n", "rrRR : 0\n", "rrrRR : 0\n", "rrrrRR : 0\n", "rrrrrRR : 0\n", "rrrrrrRR : 0\n", "Gr : 0\n", "Grr : 0\n", "Grrr : 0\n", "Grrrr : 0\n", "Grrrrr : 0\n", "Grrrrrr : 0\n", "Grrrrrrr : 0\n", "Grrrrrrrr : 0\n", "GR : 0\n", "GrR : 0\n", "GrrR : 0\n", "GrrrR : 0\n", "GrrrrR : 0\n", "GrrrrrR : 0\n", "GrrrrrrR : 0\n", "GrrrrrrrR : 0\n", "GRR : 0\n", "GrRR : 0\n", "GrrRR : 0\n", "GrrrRR : 0\n", "GrrrrRR : 0\n", "GrrrrrRR : 0\n", "GrrrrrrRR : 0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "run_N4(m, mols, obs0)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "P2HyqshwqXrC" }, "source": [ "### Pentavalent model (N = 5 and kx > 0)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": {}, "colab_type": "code", "id": "Zy7KoLgdqXrE" }, "outputs": [], "source": [ "# this is the pentavalent model : N=5\n", "N = 5.00\n", "\n", "mols = [\"r\", \"rr\", \"rrr\", \"rrrr\", \"rrrrr\", \"rrrrrr\", \"rrrrrrr\", \"rrrrrrrr\", \"rrrrrrrr\", \"rrrrrrrrrr\",\n", " \"R\", \"rR\", \"rrR\", \"rrrR\", \"rrrrR\", \"rrrrrR\", \"rrrrrrR\", \"rrrrrrrR\", \"rrrrrrrR\", \"rrrrrrrrrR\",\n", " \"RR\", \"rRR\", \"rrRR\", \"rrrRR\", \"rrrrRR\", \"rrrrrRR\", \"rrrrrrRR\", \"rrrrrrRR\", \"rrrrrrrrRR\",\n", " \"Gr\", \"Grr\", \"Grrr\", \"Grrrr\", \"Grrrrr\", \"Grrrrrr\", \"Grrrrrrr\", \"Grrrrrrrr\", \"Grrrrrrrr\", \"Grrrrrrrrrr\",\n", " \"GR\", \"GrR\", \"GrrR\", \"GrrrR\", \"GrrrrR\", \"GrrrrrR\", \"GrrrrrrR\", \"GrrrrrrrR\", \"GrrrrrrrR\", \"GrrrrrrrrrR\",\n", " \"GRR\", \"GrRR\", \"GrrRR\", \"GrrrRR\", \"GrrrrRR\", \"GrrrrrRR\", \"GrrrrrrRR\", \"GrrrrrrRR\", \"GrrrrrrrrRR\"]" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "sChapKtxqXrI", "outputId": "d15b4115-2c96-475a-a0f6-4586d3bc75b1" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "r > R | 1.0\n", "R > r | 1.0\n", "R > GR | 1.0\n", "GR > R | 1.0\n", "r > Gr | 1.0\n", "Gr > r | 1.0\n", "Gr > GR | 1.0\n", "GR > Gr | 1.0\n", "r + r > rr | 0.00020092425155716296\n", "rr > r + r | 1.0\n", "r + rr > rrr | 0.00020092425155716296\n", "rrr > r + rr | 1.0\n", "r + rrr > rrrr | 0.00020092425155716296\n", "rrrr > r + rrr | 1.0\n", "r + rrrr > rrrrr | 0.00020092425155716296\n", "rrrrr > r + rrrr | 1.0\n", "r + rrrrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > r + rrrrr | 1.0\n", "rr + r > rrr | 0.00020092425155716296\n", "rrr > rr + r | 1.0\n", "rr + rr > rrrr | 0.00020092425155716296\n", "rrrr > rr + rr | 1.0\n", "rr + rrr > rrrrr | 0.00020092425155716296\n", "rrrrr > rr + rrr | 1.0\n", "rr + rrrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rr + rrrr | 1.0\n", "rr + rrrrr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rr + rrrrr | 1.0\n", "rrr + r > rrrr | 0.00020092425155716296\n", "rrrr > rrr + r | 1.0\n", "rrr + rr > rrrrr | 0.00020092425155716296\n", "rrrrr > rrr + rr | 1.0\n", "rrr + rrr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrr + rrr | 1.0\n", "rrr + rrrr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rrr + rrrr | 1.0\n", "rrr + rrrrr > rrrrrrrr | 0.00020092425155716296\n", "rrrrrrrr > rrr + rrrrr | 1.0\n", "rrrr + r > rrrrr | 0.00020092425155716296\n", "rrrrr > rrrr + r | 1.0\n", "rrrr + rr > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrrr + rr | 1.0\n", "rrrr + rrr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rrrr + rrr | 1.0\n", "rrrr + rrrr > rrrrrrrr | 0.00020092425155716296\n", "rrrrrrrr > rrrr + rrrr | 1.0\n", "rrrr + rrrrr > rrrrrrrrr | 0.00020092425155716296\n", "rrrrrrrrr > rrrr + rrrrr | 1.0\n", "rrrrr + r > rrrrrr | 0.00020092425155716296\n", "rrrrrr > rrrrr + r | 1.0\n", "rrrrr + rr > rrrrrrr | 0.00020092425155716296\n", "rrrrrrr > rrrrr + rr | 1.0\n", "rrrrr + rrr > rrrrrrrr | 0.00020092425155716296\n", "rrrrrrrr > rrrrr + rrr | 1.0\n", "rrrrr + rrrr > rrrrrrrrr | 0.00020092425155716296\n", "rrrrrrrrr > rrrrr + rrrr | 1.0\n", "rrrrr + rrrrr > rrrrrrrrrr | 0.00020092425155716296\n", "rrrrrrrrrr > rrrrr + rrrrr | 1.0\n", "R + r > rR | 2.0092425155716294e-06\n", "rR > R + r | 1.0\n", "R + rr > rrR | 2.0092425155716294e-06\n", "rrR > R + rr | 1.0\n", "R + rrr > rrrR | 2.0092425155716294e-06\n", "rrrR > R + rrr | 1.0\n", "R + rrrr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > R + rrrr | 1.0\n", "R + rrrrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > R + rrrrr | 1.0\n", "rR + r > rrR | 2.0092425155716294e-06\n", "rrR > rR + r | 1.0\n", "rR + rr > rrrR | 2.0092425155716294e-06\n", "rrrR > rR + rr | 1.0\n", "rR + rrr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rR + rrr | 1.0\n", "rR + rrrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rR + rrrr | 1.0\n", "rR + rrrrr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rR + rrrrr | 1.0\n", "rrR + r > rrrR | 2.0092425155716294e-06\n", "rrrR > rrR + r | 1.0\n", "rrR + rr > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rrR + rr | 1.0\n", "rrR + rrr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrR + rrr | 1.0\n", "rrR + rrrr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rrR + rrrr | 1.0\n", "rrR + rrrrr > rrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrR > rrR + rrrrr | 1.0\n", "rrrR + r > rrrrR | 2.0092425155716294e-06\n", "rrrrR > rrrR + r | 1.0\n", "rrrR + rr > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrrR + rr | 1.0\n", "rrrR + rrr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rrrR + rrr | 1.0\n", "rrrR + rrrr > rrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrR > rrrR + rrrr | 1.0\n", "rrrR + rrrrr > rrrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrrR > rrrR + rrrrr | 1.0\n", "rrrrR + r > rrrrrR | 2.0092425155716294e-06\n", "rrrrrR > rrrrR + r | 1.0\n", "rrrrR + rr > rrrrrrR | 2.0092425155716294e-06\n", "rrrrrrR > rrrrR + rr | 1.0\n", "rrrrR + rrr > rrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrR > rrrrR + rrr | 1.0\n", "rrrrR + rrrr > rrrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrrR > rrrrR + rrrr | 1.0\n", "rrrrR + rrrrr > rrrrrrrrrR | 2.0092425155716294e-06\n", "rrrrrrrrrR > rrrrR + rrrrr | 1.0\n", "R + R > RR | 2.0092425155716296e-08\n", "RR > R + R | 1.0\n", "R + rR > rRR | 2.0092425155716296e-08\n", "rRR > R + rR | 1.0\n", "R + rrR > rrRR | 2.0092425155716296e-08\n", "rrRR > R + rrR | 1.0\n", "R + rrrR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > R + rrrR | 1.0\n", "R + rrrrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > R + rrrrR | 1.0\n", "rR + R > rRR | 2.0092425155716296e-08\n", "rRR > rR + R | 1.0\n", "rR + rR > rrRR | 2.0092425155716296e-08\n", "rrRR > rR + rR | 1.0\n", "rR + rrR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rR + rrR | 1.0\n", "rR + rrrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rR + rrrR | 1.0\n", "rR + rrrrR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rR + rrrrR | 1.0\n", "rrR + R > rrRR | 2.0092425155716296e-08\n", "rrRR > rrR + R | 1.0\n", "rrR + rR > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rrR + rR | 1.0\n", "rrR + rrR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrR + rrR | 1.0\n", "rrR + rrrR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rrR + rrrR | 1.0\n", "rrR + rrrrR > rrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrRR > rrR + rrrrR | 1.0\n", "rrrR + R > rrrRR | 2.0092425155716296e-08\n", "rrrRR > rrrR + R | 1.0\n", "rrrR + rR > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrrR + rR | 1.0\n", "rrrR + rrR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rrrR + rrR | 1.0\n", "rrrR + rrrR > rrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrRR > rrrR + rrrR | 1.0\n", "rrrR + rrrrR > rrrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrrRR > rrrR + rrrrR | 1.0\n", "rrrrR + R > rrrrRR | 2.0092425155716296e-08\n", "rrrrRR > rrrrR + R | 1.0\n", "rrrrR + rR > rrrrrRR | 2.0092425155716296e-08\n", "rrrrrRR > rrrrR + rR | 1.0\n", "rrrrR + rrR > rrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrRR > rrrrR + rrR | 1.0\n", "rrrrR + rrrR > rrrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrrRR > rrrrR + rrrR | 1.0\n", "rrrrR + rrrrR > rrrrrrrrRR | 2.0092425155716296e-08\n", "rrrrrrrrRR > rrrrR + rrrrR | 1.0\n", "rr > rR | 0.01\n", "rR > rr | 1.0\n", "rrr > rrR | 0.01\n", "rrR > rrr | 1.0\n", "rrrr > rrrR | 0.01\n", "rrrR > rrrr | 1.0\n", "rrrrr > rrrrR | 0.01\n", "rrrrR > rrrrr | 1.0\n", "rrrrrr > rrrrrR | 0.01\n", "rrrrrR > rrrrrr | 1.0\n", "rrrrrrr > rrrrrrR | 0.01\n", "rrrrrrR > rrrrrrr | 1.0\n", "rrrrrrrr > rrrrrrrR | 0.01\n", "rrrrrrrR > rrrrrrrr | 1.0\n", "rrrrrrrrr > rrrrrrrrR | 0.01\n", "rrrrrrrrR > rrrrrrrrr | 1.0\n", "rrrrrrrrrr > rrrrrrrrrR | 0.01\n", "rrrrrrrrrR > rrrrrrrrrr | 1.0\n", "rR > RR | 0.01\n", "RR > rR | 1.0\n", "rrR > rRR | 0.01\n", "rRR > rrR | 1.0\n", "rrrR > rrRR | 0.01\n", "rrRR > rrrR | 1.0\n", "rrrrR > rrrRR | 0.01\n", "rrrRR > rrrrR | 1.0\n", "rrrrrR > rrrrRR | 0.01\n", "rrrrRR > rrrrrR | 1.0\n", "rrrrrrR > rrrrrRR | 0.01\n", "rrrrrRR > rrrrrrR | 1.0\n", "rrrrrrrR > rrrrrrRR | 0.01\n", "rrrrrrRR > rrrrrrrR | 1.0\n", "rrrrrrrrR > rrrrrrrRR | 0.01\n", "rrrrrrrRR > rrrrrrrrR | 1.0\n", "rrrrrrrrrR > rrrrrrrrRR | 0.01\n", "rrrrrrrrRR > rrrrrrrrrR | 1.0\n", "rr > Grr | 0.01\n", "Grr > rr | 1.0\n", "rrr > Grrr | 0.01\n", "Grrr > rrr | 1.0\n", "rrrr > Grrrr | 0.01\n", "Grrrr > rrrr | 1.0\n", "rrrrr > Grrrrr | 0.01\n", "Grrrrr > rrrrr | 1.0\n", "rrrrrr > Grrrrrr | 0.01\n", "Grrrrrr > rrrrrr | 1.0\n", "rrrrrrr > Grrrrrrr | 0.01\n", "Grrrrrrr > rrrrrrr | 1.0\n", "rrrrrrrr > Grrrrrrrr | 0.01\n", "Grrrrrrrr > rrrrrrrr | 1.0\n", "rrrrrrrrr > Grrrrrrrrr | 0.01\n", "Grrrrrrrrr > rrrrrrrrr | 1.0\n", "rrrrrrrrrr > Grrrrrrrrrr | 0.01\n", "Grrrrrrrrrr > rrrrrrrrrr | 1.0\n", "rR > GrR | 0.01\n", "GrR > rR | 1.0\n", "rrR > GrrR | 0.01\n", "GrrR > rrR | 1.0\n", "rrrR > GrrrR | 0.01\n", "GrrrR > rrrR | 1.0\n", "rrrrR > GrrrrR | 0.01\n", "GrrrrR > rrrrR | 1.0\n", "rrrrrR > GrrrrrR | 0.01\n", "GrrrrrR > rrrrrR | 1.0\n", "rrrrrrR > GrrrrrrR | 0.01\n", "GrrrrrrR > rrrrrrR | 1.0\n", "rrrrrrrR > GrrrrrrrR | 0.01\n", "GrrrrrrrR > rrrrrrrR | 1.0\n", "rrrrrrrrR > GrrrrrrrrR | 0.01\n", "GrrrrrrrrR > rrrrrrrrR | 1.0\n", "rrrrrrrrrR > GrrrrrrrrrR | 0.01\n", "GrrrrrrrrrR > rrrrrrrrrR | 1.0\n", "RR > GRR | 0.01\n", "GRR > RR | 1.0\n", "rRR > GrRR | 0.01\n", "GrRR > rRR | 1.0\n", "rrRR > GrrRR | 0.01\n", "GrrRR > rrRR | 1.0\n", "rrrRR > GrrrRR | 0.01\n", "GrrrRR > rrrRR | 1.0\n", "rrrrRR > GrrrrRR | 0.01\n", "GrrrrRR > rrrrRR | 1.0\n", "rrrrrRR > GrrrrrRR | 0.01\n", "GrrrrrRR > rrrrrRR | 1.0\n", "rrrrrrRR > GrrrrrrRR | 0.01\n", "GrrrrrrRR > rrrrrrRR | 1.0\n", "rrrrrrrRR > GrrrrrrrRR | 0.01\n", "GrrrrrrrRR > rrrrrrrRR | 1.0\n", "rrrrrrrrRR > GrrrrrrrrRR | 0.01\n", "GrrrrrrrrRR > rrrrrrrrRR | 1.0\n", "Gr + r > Grr | 0.00020092425155716296\n", "Grr > Gr + r | 1.0\n", "Gr + rr > Grrr | 0.00020092425155716296\n", "Grrr > Gr + rr | 1.0\n", "Gr + rrr > Grrrr | 0.00020092425155716296\n", "Grrrr > Gr + rrr | 1.0\n", "Gr + rrrr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Gr + rrrr | 1.0\n", "Gr + rrrrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Gr + rrrrr | 1.0\n", "Grr + r > Grrr | 0.00020092425155716296\n", "Grrr > Grr + r | 1.0\n", "Grr + rr > Grrrr | 0.00020092425155716296\n", "Grrrr > Grr + rr | 1.0\n", "Grr + rrr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grr + rrr | 1.0\n", "Grr + rrrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grr + rrrr | 1.0\n", "Grr + rrrrr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grr + rrrrr | 1.0\n", "Grrr + r > Grrrr | 0.00020092425155716296\n", "Grrrr > Grrr + r | 1.0\n", "Grrr + rr > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grrr + rr | 1.0\n", "Grrr + rrr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrr + rrr | 1.0\n", "Grrr + rrrr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grrr + rrrr | 1.0\n", "Grrr + rrrrr > Grrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrr > Grrr + rrrrr | 1.0\n", "Grrrr + r > Grrrrr | 0.00020092425155716296\n", "Grrrrr > Grrrr + r | 1.0\n", "Grrrr + rr > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrrr + rr | 1.0\n", "Grrrr + rrr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grrrr + rrr | 1.0\n", "Grrrr + rrrr > Grrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrr > Grrrr + rrrr | 1.0\n", "Grrrr + rrrrr > Grrrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrrr > Grrrr + rrrrr | 1.0\n", "Grrrrr + r > Grrrrrr | 0.00020092425155716296\n", "Grrrrrr > Grrrrr + r | 1.0\n", "Grrrrr + rr > Grrrrrrr | 0.00020092425155716296\n", "Grrrrrrr > Grrrrr + rr | 1.0\n", "Grrrrr + rrr > Grrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrr > Grrrrr + rrr | 1.0\n", "Grrrrr + rrrr > Grrrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrrr > Grrrrr + rrrr | 1.0\n", "Grrrrr + rrrrr > Grrrrrrrrrr | 0.00020092425155716296\n", "Grrrrrrrrrr > Grrrrr + rrrrr | 1.0\n", "GR + r > GrR | 2.0092425155716294e-06\n", "GrR > GR + r | 1.0\n", "GR + rr > GrrR | 2.0092425155716294e-06\n", "GrrR > GR + rr | 1.0\n", "GR + rrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GR + rrr | 1.0\n", "GR + rrrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GR + rrrr | 1.0\n", "GR + rrrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GR + rrrrr | 1.0\n", "GrR + r > GrrR | 2.0092425155716294e-06\n", "GrrR > GrR + r | 1.0\n", "GrR + rr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrR + rr | 1.0\n", "GrR + rrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrR + rrr | 1.0\n", "GrR + rrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrR + rrrr | 1.0\n", "GrR + rrrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrR + rrrrr | 1.0\n", "GrrR + r > GrrrR | 2.0092425155716294e-06\n", "GrrrR > GrrR + r | 1.0\n", "GrrR + rr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrrR + rr | 1.0\n", "GrrR + rrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrR + rrr | 1.0\n", "GrrR + rrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrrR + rrrr | 1.0\n", "GrrR + rrrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > GrrR + rrrrr | 1.0\n", "GrrrR + r > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > GrrrR + r | 1.0\n", "GrrrR + rr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrrR + rr | 1.0\n", "GrrrR + rrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrrrR + rrr | 1.0\n", "GrrrR + rrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > GrrrR + rrrr | 1.0\n", "GrrrR + rrrrr > GrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrR > GrrrR + rrrrr | 1.0\n", "GrrrrR + r > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > GrrrrR + r | 1.0\n", "GrrrrR + rr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > GrrrrR + rr | 1.0\n", "GrrrrR + rrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > GrrrrR + rrr | 1.0\n", "GrrrrR + rrrr > GrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrR > GrrrrR + rrrr | 1.0\n", "GrrrrR + rrrrr > GrrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrrR > GrrrrR + rrrrr | 1.0\n", "R + Gr > GrR | 2.0092425155716294e-06\n", "GrR > R + Gr | 1.0\n", "R + Grr > GrrR | 2.0092425155716294e-06\n", "GrrR > R + Grr | 1.0\n", "R + Grrr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > R + Grrr | 1.0\n", "R + Grrrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > R + Grrrr | 1.0\n", "R + Grrrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > R + Grrrrr | 1.0\n", "rR + Gr > GrrR | 2.0092425155716294e-06\n", "GrrR > rR + Gr | 1.0\n", "rR + Grr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rR + Grr | 1.0\n", "rR + Grrr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rR + Grrr | 1.0\n", "rR + Grrrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rR + Grrrr | 1.0\n", "rR + Grrrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rR + Grrrrr | 1.0\n", "rrR + Gr > GrrrR | 2.0092425155716294e-06\n", "GrrrR > rrR + Gr | 1.0\n", "rrR + Grr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rrR + Grr | 1.0\n", "rrR + Grrr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrR + Grrr | 1.0\n", "rrR + Grrrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rrR + Grrrr | 1.0\n", "rrR + Grrrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > rrR + Grrrrr | 1.0\n", "rrrR + Gr > GrrrrR | 2.0092425155716294e-06\n", "GrrrrR > rrrR + Gr | 1.0\n", "rrrR + Grr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrrR + Grr | 1.0\n", "rrrR + Grrr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rrrR + Grrr | 1.0\n", "rrrR + Grrrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > rrrR + Grrrr | 1.0\n", "rrrR + Grrrrr > GrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrR > rrrR + Grrrrr | 1.0\n", "rrrrR + Gr > GrrrrrR | 2.0092425155716294e-06\n", "GrrrrrR > rrrrR + Gr | 1.0\n", "rrrrR + Grr > GrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrR > rrrrR + Grr | 1.0\n", "rrrrR + Grrr > GrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrR > rrrrR + Grrr | 1.0\n", "rrrrR + Grrrr > GrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrR > rrrrR + Grrrr | 1.0\n", "rrrrR + Grrrrr > GrrrrrrrrrR | 2.0092425155716294e-06\n", "GrrrrrrrrrR > rrrrR + Grrrrr | 1.0\n", "GR + R > GRR | 2.0092425155716296e-08\n", "GRR > GR + R | 1.0\n", "GR + rR > GrRR | 2.0092425155716296e-08\n", "GrRR > GR + rR | 1.0\n", "GR + rrR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GR + rrR | 1.0\n", "GR + rrrR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GR + rrrR | 1.0\n", "GR + rrrrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GR + rrrrR | 1.0\n", "GrR + R > GrRR | 2.0092425155716296e-08\n", "GrRR > GrR + R | 1.0\n", "GrR + rR > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrR + rR | 1.0\n", "GrR + rrR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrR + rrR | 1.0\n", "GrR + rrrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrR + rrrR | 1.0\n", "GrR + rrrrR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrR + rrrrR | 1.0\n", "GrrR + R > GrrRR | 2.0092425155716296e-08\n", "GrrRR > GrrR + R | 1.0\n", "GrrR + rR > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrrR + rR | 1.0\n", "GrrR + rrR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrR + rrR | 1.0\n", "GrrR + rrrR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrrR + rrrR | 1.0\n", "GrrR + rrrrR > GrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrRR > GrrR + rrrrR | 1.0\n", "GrrrR + R > GrrrRR | 2.0092425155716296e-08\n", "GrrrRR > GrrrR + R | 1.0\n", "GrrrR + rR > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrrR + rR | 1.0\n", "GrrrR + rrR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrrrR + rrR | 1.0\n", "GrrrR + rrrR > GrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrRR > GrrrR + rrrR | 1.0\n", "GrrrR + rrrrR > GrrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrrRR > GrrrR + rrrrR | 1.0\n", "GrrrrR + R > GrrrrRR | 2.0092425155716296e-08\n", "GrrrrRR > GrrrrR + R | 1.0\n", "GrrrrR + rR > GrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrRR > GrrrrR + rR | 1.0\n", "GrrrrR + rrR > GrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrRR > GrrrrR + rrR | 1.0\n", "GrrrrR + rrrR > GrrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrrRR > GrrrrR + rrrR | 1.0\n", "GrrrrR + rrrrR > GrrrrrrrrRR | 2.0092425155716296e-08\n", "GrrrrrrrrRR > GrrrrR + rrrrR | 1.0\n", "Grr > GrR | 0.01\n", "GrR > Grr | 1.0\n", "Grrr > GrrR | 0.01\n", "GrrR > Grrr | 1.0\n", "Grrrr > GrrrR | 0.01\n", "GrrrR > Grrrr | 1.0\n", "Grrrrr > GrrrrR | 0.01\n", "GrrrrR > Grrrrr | 1.0\n", "Grrrrrr > GrrrrrR | 0.01\n", "GrrrrrR > Grrrrrr | 1.0\n", "Grrrrrrr > GrrrrrrR | 0.01\n", "GrrrrrrR > Grrrrrrr | 1.0\n", "Grrrrrrrr > GrrrrrrrR | 0.01\n", "GrrrrrrrR > Grrrrrrrr | 1.0\n", "Grrrrrrrrr > GrrrrrrrrR | 0.01\n", "GrrrrrrrrR > Grrrrrrrrr | 1.0\n", "Grrrrrrrrrr > GrrrrrrrrrR | 0.01\n", "GrrrrrrrrrR > Grrrrrrrrrr | 1.0\n", "GrR > GRR | 0.01\n", "GRR > GrR | 1.0\n", "GrrR > GrRR | 0.01\n", "GrRR > GrrR | 1.0\n", "GrrrR > GrrRR | 0.01\n", "GrrRR > GrrrR | 1.0\n", "GrrrrR > GrrrRR | 0.01\n", "GrrrRR > GrrrrR | 1.0\n", "GrrrrrR > GrrrrRR | 0.01\n", "GrrrrRR > GrrrrrR | 1.0\n", "GrrrrrrR > GrrrrrRR | 0.01\n", "GrrrrrRR > GrrrrrrR | 1.0\n", "GrrrrrrrR > GrrrrrrRR | 0.01\n", "GrrrrrrRR > GrrrrrrrR | 1.0\n", "GrrrrrrrrR > GrrrrrrrRR | 0.01\n", "GrrrrrrrRR > GrrrrrrrrR | 1.0\n", "GrrrrrrrrrR > GrrrrrrrrRR | 0.01\n", "GrrrrrrrrRR > GrrrrrrrrrR | 1.0\n" ] } ], "source": [ "with reaction_rules():\n", "\n", " # TCM (Ternary complex model)\n", " r == R | (kl0*L, dl0)\n", " R == GR | (ka0*G, da0)\n", " r == Gr | (kg0*G, dg0)\n", " Gr == GR | (kb0*L, db0)\n", "\n", " # receptor dimerization\n", " r + r == rr | (kx0, dx0)\n", " r + rr == rrr | (kx0, dx0)\n", " r + rrr == rrrr | (kx0, dx0)\n", " r + rrrr == rrrrr | (kx0, dx0)\n", " r + rrrrr == rrrrrr | (kx0, dx0)\n", " rr + r == rrr | (kx0, dx0)\n", " rr + rr == rrrr | (kx0, dx0)\n", " rr + rrr == rrrrr | (kx0, dx0)\n", " rr + rrrr == rrrrrr | (kx0, dx0)\n", " rr + rrrrr == rrrrrrr | (kx0, dx0)\n", " rrr + r == rrrr | (kx0, dx0)\n", " rrr + rr == rrrrr | (kx0, dx0)\n", " rrr + rrr == rrrrrr | (kx0, dx0)\n", " rrr + rrrr == rrrrrrr | (kx0, dx0)\n", " rrr + rrrrr == rrrrrrrr | (kx0, dx0)\n", " rrrr + r == rrrrr | (kx0, dx0)\n", " rrrr + rr == rrrrrr | (kx0, dx0)\n", " rrrr + rrr == rrrrrrr | (kx0, dx0)\n", " rrrr + rrrr == rrrrrrrr | (kx0, dx0)\n", " rrrr + rrrrr == rrrrrrrrr | (kx0, dx0)\n", " rrrrr + r == rrrrrr | (kx0, dx0)\n", " rrrrr + rr == rrrrrrr | (kx0, dx0)\n", " rrrrr + rrr == rrrrrrrr | (kx0, dx0)\n", " rrrrr + rrrr == rrrrrrrrr | (kx0, dx0)\n", " rrrrr + rrrrr == rrrrrrrrrr | (kx0, dx0)\n", "\n", " R + r == rR | (kx1, dx1)\n", " R + rr == rrR | (kx1, dx1)\n", " R + rrr == rrrR | (kx1, dx1)\n", " R + rrrr == rrrrR | (kx1, dx1)\n", " R + rrrrr == rrrrrR | (kx1, dx1)\n", " rR + r == rrR | (kx1, dx1)\n", " rR + rr == rrrR | (kx1, dx1)\n", " rR + rrr == rrrrR | (kx1, dx1)\n", " rR + rrrr == rrrrrR | (kx1, dx1)\n", " rR + rrrrr == rrrrrrR | (kx1, dx1)\n", " rrR + r == rrrR | (kx1, dx1)\n", " rrR + rr == rrrrR | (kx1, dx1)\n", " rrR + rrr == rrrrrR | (kx1, dx1)\n", " rrR + rrrr == rrrrrrR | (kx1, dx1)\n", " rrR + rrrrr == rrrrrrrR | (kx1, dx1)\n", " rrrR + r == rrrrR | (kx1, dx1)\n", " rrrR + rr == rrrrrR | (kx1, dx1)\n", " rrrR + rrr == rrrrrrR | (kx1, dx1)\n", " rrrR + rrrr == rrrrrrrR | (kx1, dx1)\n", " rrrR + rrrrr == rrrrrrrrR | (kx1, dx1)\n", " rrrrR + r == rrrrrR | (kx1, dx1)\n", " rrrrR + rr == rrrrrrR | (kx1, dx1)\n", " rrrrR + rrr == rrrrrrrR | (kx1, dx1)\n", " rrrrR + rrrr == rrrrrrrrR | (kx1, dx1)\n", " rrrrR + rrrrr == rrrrrrrrrR | (kx1, dx1)\n", "\n", " R + R == RR | (kx2, dx2)\n", " R + rR == rRR | (kx2, dx2)\n", " R + rrR == rrRR | (kx2, dx2)\n", " R + rrrR == rrrRR | (kx2, dx2)\n", " R + rrrrR == rrrrRR | (kx2, dx2)\n", " rR + R == rRR | (kx2, dx2)\n", " rR + rR == rrRR | (kx2, dx2)\n", " rR + rrR == rrrRR | (kx2, dx2)\n", " rR + rrrR == rrrrRR | (kx2, dx2)\n", " rR + rrrrR == rrrrrRR | (kx2, dx2)\n", " rrR + R == rrRR | (kx2, dx2)\n", " rrR + rR == rrrRR | (kx2, dx2)\n", " rrR + rrR == rrrrRR | (kx2, dx2)\n", " rrR + rrrR == rrrrrRR | (kx2, dx2)\n", " rrR + rrrrR == rrrrrrRR | (kx2, dx2)\n", " rrrR + R == rrrRR | (kx2, dx2)\n", " rrrR + rR == rrrrRR | (kx2, dx2)\n", " rrrR + rrR == rrrrrRR | (kx2, dx2)\n", " rrrR + rrrR == rrrrrrRR | (kx2, dx2)\n", " rrrR + rrrrR == rrrrrrrRR | (kx2, dx2)\n", " rrrrR + R == rrrrRR | (kx2, dx2)\n", " rrrrR + rR == rrrrrRR | (kx2, dx2)\n", " rrrrR + rrR == rrrrrrRR | (kx2, dx2)\n", " rrrrR + rrrR == rrrrrrrRR | (kx2, dx2)\n", " rrrrR + rrrrR == rrrrrrrrRR | (kx2, dx2)\n", "\n", " rr == rR | (kl1*L, dl1)\n", " rrr == rrR | (kl1*L, dl1)\n", " rrrr == rrrR | (kl1*L, dl1)\n", " rrrrr == rrrrR | (kl1*L, dl1)\n", " rrrrrr == rrrrrR | (kl1*L, dl1)\n", " rrrrrrr == rrrrrrR | (kl1*L, dl1)\n", " rrrrrrrr == rrrrrrrR | (kl1*L, dl1)\n", " rrrrrrrrr == rrrrrrrrR | (kl1*L, dl1)\n", " rrrrrrrrrr == rrrrrrrrrR | (kl1*L, dl1)\n", "\n", " rR == RR | (kl2*L, dl2)\n", " rrR == rRR | (kl2*L, dl2)\n", " rrrR == rrRR | (kl2*L, dl2)\n", " rrrrR == rrrRR | (kl2*L, dl2)\n", " rrrrrR == rrrrRR | (kl2*L, dl2)\n", " rrrrrrR == rrrrrRR | (kl2*L, dl2)\n", " rrrrrrrR == rrrrrrRR | (kl2*L, dl2)\n", " rrrrrrrrR == rrrrrrrRR | (kl2*L, dl2)\n", " rrrrrrrrrR == rrrrrrrrRR | (kl2*L, dl2)\n", "\n", " # dimers coupled with G-proteins\n", " rr == Grr | (kg1*G, dg1)\n", " rrr == Grrr | (kg1*G, dg1)\n", " rrrr == Grrrr | (kg1*G, dg1)\n", " rrrrr == Grrrrr | (kg1*G, dg1)\n", " rrrrrr == Grrrrrr | (kg1*G, dg1)\n", " rrrrrrr == Grrrrrrr | (kg1*G, dg1)\n", " rrrrrrrr == Grrrrrrrr | (kg1*G, dg1)\n", " rrrrrrrrr == Grrrrrrrrr | (kg1*G, dg1)\n", " rrrrrrrrrr == Grrrrrrrrrr | (kg1*G, dg1)\n", "\n", " rR == GrR | (kb1*G, db1)\n", " rrR == GrrR | (kb1*G, db1)\n", " rrrR == GrrrR | (kb1*G, db1)\n", " rrrrR == GrrrrR | (kb1*G, db1)\n", " rrrrrR == GrrrrrR | (kb1*G, db1)\n", " rrrrrrR == GrrrrrrR | (kb1*G, db1)\n", " rrrrrrrR == GrrrrrrrR | (kb1*G, db1)\n", " rrrrrrrrR == GrrrrrrrrR | (kb1*G, db1)\n", " rrrrrrrrrR == GrrrrrrrrrR | (kb1*G, db1)\n", "\n", " RR == GRR | (kb2*G, db2)\n", " rRR == GrRR | (kb2*G, db2)\n", " rrRR == GrrRR | (kb2*G, db2)\n", " rrrRR == GrrrRR | (kb2*G, db2)\n", " rrrrRR == GrrrrRR | (kb2*G, db2)\n", " rrrrrRR == GrrrrrRR | (kb2*G, db2)\n", " rrrrrrRR == GrrrrrrRR | (kb2*G, db2)\n", " rrrrrrrRR == GrrrrrrrRR | (kb2*G, db2)\n", " rrrrrrrrRR == GrrrrrrrrRR | (kb2*G, db2)\n", "\n", " Gr + r == Grr | (ky0, dy0)\n", " Gr + rr == Grrr | (ky0, dy0)\n", " Gr + rrr == Grrrr | (ky0, dy0)\n", " Gr + rrrr == Grrrrr | (ky0, dy0)\n", " Gr + rrrrr == Grrrrrr | (ky0, dy0)\n", " Grr + r == Grrr | (ky0, dy0)\n", " Grr + rr == Grrrr | (ky0, dy0)\n", " Grr + rrr == Grrrrr | (ky0, dy0)\n", " Grr + rrrr == Grrrrrr | (ky0, dy0)\n", " Grr + rrrrr == Grrrrrrr | (ky0, dy0)\n", " Grrr + r == Grrrr | (ky0, dy0)\n", " Grrr + rr == Grrrrr | (ky0, dy0)\n", " Grrr + rrr == Grrrrrr | (ky0, dy0)\n", " Grrr + rrrr == Grrrrrrr | (ky0, dy0)\n", " Grrr + rrrrr == Grrrrrrrr | (ky0, dy0)\n", " Grrrr + r == Grrrrr | (ky0, dy0)\n", " Grrrr + rr == Grrrrrr | (ky0, dy0)\n", " Grrrr + rrr == Grrrrrrr | (ky0, dy0)\n", " Grrrr + rrrr == Grrrrrrrr | (ky0, dy0)\n", " Grrrr + rrrrr == Grrrrrrrrr | (ky0, dy0)\n", " Grrrrr + r == Grrrrrr | (ky0, dy0)\n", " Grrrrr + rr == Grrrrrrr | (ky0, dy0)\n", " Grrrrr + rrr == Grrrrrrrr | (ky0, dy0)\n", " Grrrrr + rrrr == Grrrrrrrrr | (ky0, dy0)\n", " Grrrrr + rrrrr == Grrrrrrrrrr | (ky0, dy0)\n", "\n", " GR + r == GrR | (ky1, dy1)\n", " GR + rr == GrrR | (ky1, dy1)\n", " GR + rrr == GrrrR | (ky1, dy1)\n", " GR + rrrr == GrrrrR | (ky1, dy1)\n", " GR + rrrrr == GrrrrrR | (ky1, dy1)\n", " GrR + r == GrrR | (ky1, dy1)\n", " GrR + rr == GrrrR | (ky1, dy1)\n", " GrR + rrr == GrrrrR | (ky1, dy1)\n", " GrR + rrrr == GrrrrrR | (ky1, dy1)\n", " GrR + rrrrr == GrrrrrrR | (ky1, dy1)\n", " GrrR + r == GrrrR | (ky1, dy1)\n", " GrrR + rr == GrrrrR | (ky1, dy1)\n", " GrrR + rrr == GrrrrrR | (ky1, dy1)\n", " GrrR + rrrr == GrrrrrrR | (ky1, dy1)\n", " GrrR + rrrrr == GrrrrrrrR | (ky1, dy1)\n", " GrrrR + r == GrrrrR | (ky1, dy1)\n", " GrrrR + rr == GrrrrrR | (ky1, dy1)\n", " GrrrR + rrr == GrrrrrrR | (ky1, dy1)\n", " GrrrR + rrrr == GrrrrrrrR | (ky1, dy1)\n", " GrrrR + rrrrr == GrrrrrrrrR | (ky1, dy1)\n", " GrrrrR + r == GrrrrrR | (ky1, dy1)\n", " GrrrrR + rr == GrrrrrrR | (ky1, dy1)\n", " GrrrrR + rrr == GrrrrrrrR | (ky1, dy1)\n", " GrrrrR + rrrr == GrrrrrrrrR | (ky1, dy1)\n", " GrrrrR + rrrrr == GrrrrrrrrrR | (ky1, dy1)\n", "\n", "\n", " R + Gr == GrR | (ky2, dy2)\n", " R + Grr == GrrR | (ky2, dy2)\n", " R + Grrr == GrrrR | (ky2, dy2)\n", " R + Grrrr == GrrrrR | (ky2, dy2)\n", " R + Grrrrr == GrrrrrR | (ky2, dy2)\n", " rR + Gr == GrrR | (ky2, dy2)\n", " rR + Grr == GrrrR | (ky2, dy2)\n", " rR + Grrr == GrrrrR | (ky2, dy2)\n", " rR + Grrrr == GrrrrrR | (ky2, dy2)\n", " rR + Grrrrr == GrrrrrrR | (ky2, dy2)\n", " rrR + Gr == GrrrR | (ky2, dy2)\n", " rrR + Grr == GrrrrR | (ky2, dy2)\n", " rrR + Grrr == GrrrrrR | (ky2, dy2)\n", " rrR + Grrrr == GrrrrrrR | (ky2, dy2)\n", " rrR + Grrrrr == GrrrrrrrR | (ky2, dy2)\n", " rrrR + Gr == GrrrrR | (ky2, dy2)\n", " rrrR + Grr == GrrrrrR | (ky2, dy2)\n", " rrrR + Grrr == GrrrrrrR | (ky2, dy2)\n", " rrrR + Grrrr == GrrrrrrrR | (ky2, dy2)\n", " rrrR + Grrrrr == GrrrrrrrrR | (ky2, dy2)\n", " rrrrR + Gr == GrrrrrR | (ky2, dy2)\n", " rrrrR + Grr == GrrrrrrR | (ky2, dy2)\n", " rrrrR + Grrr == GrrrrrrrR | (ky2, dy2)\n", " rrrrR + Grrrr == GrrrrrrrrR | (ky2, dy2)\n", " rrrrR + Grrrrr == GrrrrrrrrrR | (ky2, dy2)\n", "\n", " GR + R == GRR | (ky3, dy3)\n", " GR + rR == GrRR | (ky3, dy3)\n", " GR + rrR == GrrRR | (ky3, dy3)\n", " GR + rrrR == GrrrRR | (ky3, dy3)\n", " GR + rrrrR == GrrrrRR | (ky3, dy3)\n", " GrR + R == GrRR | (ky3, dy3)\n", " GrR + rR == GrrRR | (ky3, dy3)\n", " GrR + rrR == GrrrRR | (ky3, dy3)\n", " GrR + rrrR == GrrrrRR | (ky3, dy3)\n", " GrR + rrrrR == GrrrrrRR | (ky3, dy3)\n", " GrrR + R == GrrRR | (ky3, dy3)\n", " GrrR + rR == GrrrRR | (ky3, dy3)\n", " GrrR + rrR == GrrrrRR | (ky3, dy3)\n", " GrrR + rrrR == GrrrrrRR | (ky3, dy3)\n", " GrrR + rrrrR == GrrrrrrRR | (ky3, dy3)\n", " GrrrR + R == GrrrRR | (ky3, dy3)\n", " GrrrR + rR == GrrrrRR | (ky3, dy3)\n", " GrrrR + rrR == GrrrrrRR | (ky3, dy3)\n", " GrrrR + rrrR == GrrrrrrRR | (ky3, dy3)\n", " GrrrR + rrrrR == GrrrrrrrRR | (ky3, dy3)\n", " GrrrrR + R == GrrrrRR | (ky3, dy3)\n", " GrrrrR + rR == GrrrrrRR | (ky3, dy3)\n", " GrrrrR + rrR == GrrrrrrRR | (ky3, dy3)\n", " GrrrrR + rrrR == GrrrrrrrRR | (ky3, dy3)\n", " GrrrrR + rrrrR == GrrrrrrrrRR | (ky3, dy3)\n", "\n", " Grr == GrR | (ka1*L, da1)\n", " Grrr == GrrR | (ka1*L, da1)\n", " Grrrr == GrrrR | (ka1*L, da1)\n", " Grrrrr == GrrrrR | (ka1*L, da1)\n", " Grrrrrr == GrrrrrR | (ka1*L, da1)\n", " Grrrrrrr == GrrrrrrR | (ka1*L, da1)\n", " Grrrrrrrr == GrrrrrrrR | (ka1*L, da1)\n", " Grrrrrrrrr == GrrrrrrrrR | (ka1*L, da1)\n", " Grrrrrrrrrr == GrrrrrrrrrR | (ka1*L, da1)\n", "\n", " GrR == GRR | (ka2*L, da2)\n", " GrrR == GrRR | (ka2*L, da2)\n", " GrrrR == GrrRR | (ka2*L, da2)\n", " GrrrrR == GrrrRR | (ka2*L, da2)\n", " GrrrrrR == GrrrrRR | (ka2*L, da2)\n", " GrrrrrrR == GrrrrrRR | (ka2*L, da2)\n", " GrrrrrrrR == GrrrrrrRR | (ka2*L, da2)\n", " GrrrrrrrrR == GrrrrrrrRR | (ka2*L, da2)\n", " GrrrrrrrrrR == GrrrrrrrrRR | (ka2*L, da2)\n", "\n", "m = get_model()\n", "show(m)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, "colab_type": "code", "id": "hsR81wscv15V", "outputId": "784b2211-76f0-4aca-cef9-f9ec652d4ff5" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Initial condition\n", "r : 49770\n", "rr : 0\n", "rrr : 0\n", "rrrr : 0\n", "rrrrr : 0\n", "rrrrrr : 0\n", "rrrrrrr : 0\n", "rrrrrrrr : 0\n", "rrrrrrrr : 0\n", "rrrrrrrrrr : 0\n", "R : 0\n", "rR : 0\n", "rrR : 0\n", "rrrR : 0\n", "rrrrR : 0\n", "rrrrrR : 0\n", "rrrrrrR : 0\n", "rrrrrrrR : 0\n", "rrrrrrrR : 0\n", "rrrrrrrrrR : 0\n", "RR : 0\n", "rRR : 0\n", "rrRR : 0\n", "rrrRR : 0\n", "rrrrRR : 0\n", "rrrrrRR : 0\n", "rrrrrrRR : 0\n", "rrrrrrRR : 0\n", "rrrrrrrrRR : 0\n", "Gr : 0\n", "Grr : 0\n", "Grrr : 0\n", "Grrrr : 0\n", "Grrrrr : 0\n", "Grrrrrr : 0\n", "Grrrrrrr : 0\n", "Grrrrrrrr : 0\n", "Grrrrrrrr : 0\n", "Grrrrrrrrrr : 0\n", "GR : 0\n", "GrR : 0\n", "GrrR : 0\n", "GrrrR : 0\n", "GrrrrR : 0\n", "GrrrrrR : 0\n", "GrrrrrrR : 0\n", "GrrrrrrrR : 0\n", "GrrrrrrrR : 0\n", "GrrrrrrrrrR : 0\n", "GRR : 0\n", "GrRR : 0\n", "GrrRR : 0\n", "GrrrRR : 0\n", "GrrrrRR : 0\n", "GrrrrrRR : 0\n", "GrrrrrrRR : 0\n", "GrrrrrrRR : 0\n", "GrrrrrrrrRR : 0\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "obs0 = numpy.zeros(shape=(len(mols)))\n", "obs0[0] = par.get_r0()\n", "run_N5(m, mols, obs0)" ] } ], "metadata": { "colab": { "collapsed_sections": [ "n3Ind7RzqvPU" ], "name": "example13.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "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.7.1" } }, "nbformat": 4, "nbformat_minor": 1 }