{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Incoherent Type 4 FFL with AND gate\n", "\n", "Implement the incoherent type 4 FFL with an AND gate, as described by Mangan & Alon (PNAS, 2003).\n", "\n", "The parameters are\n", "- B_y: basal rate of Y's transcription\n", "- Beta_y: maximum rate of Y's transcription\n", "- B_z: basal rate of Z's transcription\n", "- Beta_z: maximum rate of Z's transcription\n", "- K_xy: the activation threshold for X's activation of Y\n", "- K_xz: the activation threshold for X's activation of Z\n", "- K_yz: the activation threshold for Y's activation of Z\n", "- H: the Hill coefficient (exponent) for all regulation\n", "- alpha_y: the degradation rate constant for Y\n", "- alpha_z: the degradation rate constant for Z\n", "- SX: amount of active X in system (X*=SX)\n", "- SY: whether or not Y is activated (Y*=Y if SY=1, Y*=0 if SY=0)\n", "\n", "The model is\n", "\\begin{eqnarray*}\n", "\\frac{dY}{dt} &=& B_y + \\beta_Y \\frac{1}{1+(X^*/K_{xy})^H} - \\alpha_y Y\\\\\n", "\\frac{dZ}{dt} &=& B_z + \\beta_Z \\left(\\frac{(X^*/K_{xz})^H}{1+(X^*/K_{xz})^H}\\right) \\left(\\frac{(Y^*/K_{yz})^H}{1+(Y^*/K_{yz})^H}\\right) - \\alpha_z Z\\\\\n", "\\end{eqnarray*}\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import scipy.integrate\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def incoherent_type_4_and_model( t, statevars, params ):\n", " # Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulate the model\n", "\n", "Simulate the model. In the paper, they specify that for most simulations,\n", "\n", "- B_y = 0\n", "- Beta_y = 1\n", "- B_z = 0\n", "- Beta_z = 1\n", "- H = 2\n", "- alpha_y = 1\n", "- alpha_z = 1\n", "\n", "The activation thresholds are given in the figure captions, as are SX and SY." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the simulation\n", "Plot X over time in an upper subplot and Z over time in a lower subplot." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the right-hand side of Figure 3 in Mangan & Alon, 2003." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Incoherent Type 1 FFL with AND gate\n", "\n", "Implement the incoherent type 1 FFL with an AND gate, as described by Mangan & Alon (PNAS, 2003).\n", "\n", "The parameters are\n", "- B_y: basal rate of Y's transcription\n", "- Beta_y: maximum rate of Y's transcription\n", "- B_z: basal rate of Z's transcription\n", "- Beta_z: maximum rate of Z's transcription\n", "- K_xy: the activation threshold for X's activation of Y\n", "- K_xz: the activation threshold for X's activation of Z\n", "- K_yz: the activation threshold for Y's activation of Z\n", "- H: the Hill coefficient (exponent) for all regulation\n", "- alpha_y: the degradation rate constant for Y\n", "- alpha_z: the degradation rate constant for Z\n", "- SX: amount of active X in system (X*=SX)\n", "- SY: whether or not Y is activated (Y*=Y if SY=1, Y*=0 if SY=0)\n", "\n", "The model is\n", "\\begin{eqnarray*}\n", "\\frac{dY}{dt} &=& B_y + \\beta_Y \\frac{(X^*/K_{xy})^H}{1+(X^*/K_{xy})^H} - \\alpha_y Y\\\\\n", "\\frac{dZ}{dt} &=& B_z + \\beta_Z \\left(\\frac{(X^*/K_{xz})^H}{1+(X^*/K_{xz})^H}\\right) \\left(\\frac{1}{1+(Y^*/K_{yz})^H}\\right) - \\alpha_z Z\\\\\n", "\\end{eqnarray*}" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "def incoherent_type_1_and_model( t, statevars, params ):\n", " # Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Simulate the model\n", "\n", "Simulate the model. In the paper, they specify that for most simulations,\n", "\n", "- B_y = 0\n", "- Beta_y = 1\n", "- B_z = 0\n", "- Beta_z = 1\n", "- H = 2\n", "- alpha_y = 1\n", "- alpha_z = 1\n", "\n", "The activation thresholds are given in the figure captions, as are SX and SY." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Plot the simulation\n", "Plot X over time in an upper subplot and Z over time in a lower subplot." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Write code here" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Put it all together. \n", "# Figure 3!\n", "B_y = 0\n", "Beta_y = 1\n", "B_z = 0\n", "Beta_z = 1\n", "K_xy = 0.1\n", "K_xz = 0.1\n", "H = 2\n", "alpha_y = 1\n", "alpha_z = 1\n", "\n", "time_x_on = 0.5\n", "time_x_off = 2.5\n", "\n", "colors = ['gray', 'gray', 'black']\n", "thickness = [0.5,1,2]\n", "fig, axs = plt.subplots( nrows=3, ncols=2 )\n", "\n", "# For type 1\n", "K_yzs = [0.01, 0.1, .3]\n", "\n", "# X on top\n", "axs[0,0].plot( [sol1.t[0],time_x_on,time_x_on,time_x_off,time_x_off,sol3.t[-1]], \n", " [0,0,1,1,0,0], color='k' )\n", "axs[0,0].set_xlim( [0,6])\n", "axs[0,0].set_ylabel( \"X\")\n", "axs[0,0].set_ylim( [0,1.1])\n", "\n", "# Z when SY=1\n", "for i in range(3):\n", " K_yz = K_yzs[i]\n", " params_off = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,0,1);\n", " params_on = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,1,1);\n", "\n", " mf_off = lambda t,y : incoherent_type_1_and_model(t,y, params_off)\n", " mf_on = lambda t,y : incoherent_type_1_and_model(t,y, params_on)\n", "\n", " sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,0), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", " sol2 = scipy.integrate.solve_ivp( fun=mf_on, t_span=(time_x_on,time_x_off), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_x_off,.01) )\n", " sol3 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(time_x_off,6), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_x_off,6,.01) )\n", "\n", " ax = axs[1,0]\n", " ax.plot(sol1.t, sol1.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation before signal on\n", " ax.plot(sol2.t, sol2.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", " ax.plot(sol3.t, sol3.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", "axs[1,0].set_ylabel( \"Z\")\n", "axs[1,0].set_xlim( [0,6])\n", "axs[1,0].set_ylim( [0,1.1])\n", "\n", "# Z when SY=0\n", "for i in range(3):\n", " K_yz = K_yzs[i]\n", " params_off = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,0,0);\n", " params_on = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,1,0);\n", "\n", " mf_off = lambda t,y : incoherent_type_1_and_model(t,y, params_off)\n", " mf_on = lambda t,y : incoherent_type_1_and_model(t,y, params_on)\n", "\n", " sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,0), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", " sol2 = scipy.integrate.solve_ivp( fun=mf_on, t_span=(time_x_on,time_x_off), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_x_off,.01) )\n", " sol3 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(time_x_off,6), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_x_off,6,.01) )\n", "\n", " ax = axs[2,0]\n", " ax.plot(sol1.t, sol1.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation before signal on\n", " ax.plot(sol2.t, sol2.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", " ax.plot(sol3.t, sol3.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", "axs[2,0].set_ylabel( \"Z\")\n", "axs[2,0].set_xlim( [0,6])\n", "axs[2,0].set_ylim( [0,1.1])\n", "\n", "# For type 4\n", "K_yzs = [1, 0.3, .1]\n", "\n", "# X on top\n", "axs[0,1].plot( [sol1.t[0],time_x_on,time_x_on,time_x_off,time_x_off,sol3.t[-1]], \n", " [0,0,1,1,0,0], color='k' )\n", "axs[0,1].set_xlim( [0,6])\n", "axs[0,1].set_ylabel( \"X\")\n", "axs[0,1].set_ylim( [0,1.1])\n", "\n", "\n", "# Z when SY=1\n", "for i in range(3):\n", " K_yz = K_yzs[i]\n", " params_off = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,0,1);\n", " params_on = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,1,1);\n", "\n", " mf_off = lambda t,y : incoherent_type_4_and_model(t,y, params_off)\n", " mf_on = lambda t,y : incoherent_type_4_and_model(t,y, params_on)\n", "\n", " sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,0), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", " sol2 = scipy.integrate.solve_ivp( fun=mf_on, t_span=(time_x_on,time_x_off), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_x_off,.01) )\n", " sol3 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(time_x_off,6), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_x_off,6,.01) )\n", "\n", " ax = axs[1,1]\n", " ax.plot(sol1.t, sol1.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation before signal on\n", " ax.plot(sol2.t, sol2.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", " ax.plot(sol3.t, sol3.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", "axs[1,1].set_ylabel( \"Z\")\n", "axs[1,1].set_xlim( [0,6])\n", "axs[1,1].set_ylim( [0,1.1])\n", "\n", "\n", "# Z when SY=0\n", "for i in range(3):\n", " K_yz = K_yzs[i]\n", " params_off = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,0,0);\n", " params_on = (B_y,Beta_y,B_z,Beta_z,K_xy,K_xz,K_yz,H,alpha_y,alpha_z,1,0);\n", "\n", " mf_off = lambda t,y : incoherent_type_4_and_model(t,y, params_off)\n", " mf_on = lambda t,y : incoherent_type_4_and_model(t,y, params_on)\n", "\n", " sol1 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(0,time_x_on), y0=(0,0), \n", " t_eval=np.arange(0,time_x_on,.01) )\n", " sol2 = scipy.integrate.solve_ivp( fun=mf_on, t_span=(time_x_on,time_x_off), y0=sol1.y[:,-1], \n", " t_eval=np.arange(time_x_on,time_x_off,.01) )\n", " sol3 = scipy.integrate.solve_ivp( fun=mf_off, t_span=(time_x_off,6), y0=sol2.y[:,-1], \n", " t_eval=np.arange(time_x_off,6,.01) )\n", "\n", " ax = axs[2,1]\n", " ax.plot(sol1.t, sol1.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation before signal on\n", " ax.plot(sol2.t, sol2.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", " ax.plot(sol3.t, sol3.y[1,:].T, color=colors[i], linewidth=thickness[i]); #Simulation after signal on\n", "axs[2,1].set_ylabel( \"Z\")\n", "axs[2,1].set_xlim( [0,6])\n", "axs[2,1].set_ylim( [0,1.1])\n", "\n", "\n", "plt.tight_layout()\n", " " ] } ], "metadata": { "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.8.5" } }, "nbformat": 4, "nbformat_minor": 4 }