Non_Diagonal_article.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import division, print_function\n",
    "from sympy import Rational, re, im\n",
    "import math, cmath, time\n",
    "\n",
    "from CFT import *\n",
    "from Correlators import *\n",
    "from Spectrum_bootstrap import *\n",
    "from Data import Table\n",
    "from Non_Diagonal_Shifts import *\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numerical tests of crossing symmetry\n",
    "\n",
    "In this notebook we produce the tables of Section 4.2 of the article \"The analytic bootstrap equations of non-diagonal two-dimensional CFT\", by S. Migliaccio and S. Ribault.\n",
    "\n",
    "## Comparison with numerical bootstrap\n",
    "We generate a table comparing the four-point structure constants obtained analytically with those of the numerical bootstrap, in the case of the four-point function $Z_0 = \\left\\langle V^D_{P_{(0,\\frac{1}{2})}} V^N_{(0,\\frac{1}{2})} V^D_{P_{(0,\\frac{1}{2})}} V^N_{(0,\\frac{1}{2})} \\right\\rangle$ ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\" Select central charge and truncation parameters. \"\"\"\n",
    "\n",
    "c = 0 # Values of the central charge.\n",
    "eps = 10**(-9) # A small shift to allow the computation of conformal blocks.\n",
    "\n",
    "charge = Charge('c', c + eps)\n",
    "beta0 = charge.get('beta')\n",
    "\n",
    "N, L, bl = (8, 5.5, 30) #Truncation parameters. \n",
    "\n",
    "# N: Number of sample sets for the numerical bootstrap.\n",
    "# L: Truncation parameter for the spectrum.\n",
    "# bl: Truncation paramenter of the conformal blocks. \n",
    "\n",
    "\"\"\"Generating numerical bootstrap data\"\"\"\n",
    "t0 = time.clock()\n",
    "spectrum = Another_Spectrum(beta = beta0) # spectrum 2Z,Z+1/2 for num bootstrap.\n",
    "\n",
    "num_bootstrap = Struct_Csts_Stats(spectrum = spectrum, Nsamples = N, L = L, blocklevel = bl)\n",
    "\n",
    "dur = time.clock() - t0\n",
    "\n",
    "print('Numerical results in %s seconds.' % Table.format_time(dur))\n",
    "\n",
    "rbound = max([indices[0] for indices in num_bootstrap.indices]) # maximal r index\n",
    "sbound = max([indices[1] for indices in num_bootstrap.indices]) # maximal s index\n",
    "\n",
    "\"\"\" Generating analytic results\"\"\"\n",
    "t0 = time.clock()\n",
    "\n",
    "Ext_fields = four_point_args(beta0, (0,1/2,'d'), (0,1/2,'n')).fields # Building fields.\n",
    "Z = ND_csts(Ext_fields) # Building constants object.\n",
    "\n",
    "analytic_csts = Z.make_table((rbound, sbound))\n",
    "dur = time.clock() - t0\n",
    "\n",
    "print('Analytic results in %s seconds.' % Table.format_time(dur))\n",
    "\n",
    "\"\"\"Computing relative differences\"\"\"\n",
    "compared_data = []\n",
    "for i in range(len(num_bootstrap.indices)):\n",
    "    if num_bootstrap.indices[i][1] > 0: #keepin only positive s\n",
    "        k = analytic_csts[1].index(num_bootstrap.indices[i][0])\n",
    "        j = analytic_csts[2].index(num_bootstrap.indices[i][1])\n",
    "\n",
    "        an_c = analytic_csts[0][j][k]\n",
    "\n",
    "        num_c = num_bootstrap.mean_cst[i]\n",
    "        num_var = num_bootstrap.cvar[i]\n",
    "\n",
    "        d = 2 * abs( (an_c - num_c)/(an_c + num_c) )\n",
    "\n",
    "        row_values = [num_bootstrap.indices[i], num_c, num_var, an_c, d ]\n",
    "\n",
    "        compared_data.append(row_values)\n",
    "\n",
    "\"\"\"Truncating table\"\"\"\n",
    "j = None\n",
    "for row in compared_data:\n",
    "    if row[0] == (0,7/2): # We choose to keep constants only up to (0,7/2).\n",
    "        j = compared_data.index(row)\n",
    "        break\n",
    "if j is not None:\n",
    "    compared_data = compared_data[:j+1]\n",
    "\n",
    "\"\"\"Creating list with formatted results for the table\"\"\"\n",
    "tbl_contents = []\n",
    "for row in compared_data:\n",
    "    pretty_indices = (Rational(row[0][0]), Rational(row[0][1])) #formattin indices\n",
    "    \n",
    "    if abs(row[1]) < 10**(-4):\n",
    "        pretty_num_csts = Table.format_exp('{:.5g}'.format(row[1].real) )\n",
    "    else:\n",
    "        pretty_num_csts = Table.format_result(row[1], digits = 10, real = True)  # formatting numerical csts.\n",
    "    \n",
    "    pretty_cvar = Table.format_precision(row[2]) # formatting numeric variations\n",
    "    \n",
    "    if abs(row[3]) < 10**(-4):\n",
    "        pretty_a_csts = Table.format_exp('{:.5g}'.format(row[3]) )\n",
    "    else:\n",
    "        pretty_a_csts = Table.format_result(row[3], digits = 10, real = True)  # formatting analytic csts.\n",
    "    \n",
    "    pretty_diffs = Table.format_precision(row[4])\n",
    "    \n",
    "    tbl_contents.append([ pretty_indices, pretty_num_csts, pretty_cvar, \n",
    "                         pretty_a_csts, pretty_diffs  ])\n",
    "    \n",
    "\n",
    "\"\"\"Make Tex table.\"\"\"\n",
    "\n",
    "header = (r'\\begin{array}{|c|cr|c|c|} \\hline ' + '\\n' + r' & \\text{Numerical bootstrap} ' \n",
    "          + r'& & \\text{Analytic bootstrap} & \\text{Relative} \\\\' + '\\n'\n",
    "         + r'(r,s) & D_{(r,s)} & c_{(r,s)} & D_{(r,s)} & \\text{difference} \\\\ \\hline '+ '\\n')\n",
    "\n",
    "contents = ''\n",
    "for row in tbl_contents:\n",
    "    contents += latex(row[0])\n",
    "    for i in range(1,len(row)):\n",
    "        contents += r'& ' + row[i]\n",
    "    \n",
    "    contents += r' \\\\ ' + '\\n'\n",
    "    \n",
    "ending = r'\\hline' + '\\n' + r'\\end{array}'\n",
    "\n",
    "tbl_str = header + contents + ending\n",
    "display(Math(tbl_str))\n",
    "\n",
    "parameters = (r'c = %s, \\epsilon = %s \\\\'%(c, eps) + '\\n ' \n",
    "              + 'Nsamples = %s, L = %s, bl = %s . \\\\'%(N, L, bl) + '\\n')\n",
    "print(parameters + tbl_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crossing symmetry tests\n",
    "\n",
    "We compute four-point functions of the form \n",
    "\n",
    "\\begin{align}\n",
    "\\left\\langle V^D_{P_1} \\, V^N_{(r_2,s_2)} \\, V^D_{P_1} \\, V^N_{(r_2,s_2)} \\right\\rangle\\ ,\n",
    "\\end{align}\n",
    "\n",
    "and display tables of the $s$- and $t$-channel values. \n",
    "\n",
    "The code below builds one table at a time. For use:\n",
    "\n",
    "* Run a cell to generate the central charge and the corresponding fields. There are three different cells, corresponding to the different values used in the article. \n",
    "\n",
    "* Run the cell to generate the four-point function and compute its values.\n",
    "\n",
    "* Run the table builder. \n",
    "\n",
    "\n",
    "###  Generate charge and fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Select central charge and truncation parameters. \n",
    "c = 0\n",
    "eps = 10**(-9)\n",
    "charge = Charge('c', c + eps)\n",
    "beta0 = charge.get('beta')\n",
    "\n",
    "L_s = 8  #spectrum truncation order\n",
    "bl = 25 # blocks truncation order\n",
    "\n",
    "Ext_fields = four_point_args(beta0, (0,1/2,'d'), (0,1/2,'n')).fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 0.7513\n",
    "eps = 0\n",
    "charge = Charge('c', c + eps)\n",
    "beta0 = charge.get('beta')\n",
    "\n",
    "L_s = 8  #spectrum truncation order\n",
    "bl = 25 # blocks truncation order\n",
    "\n",
    "\"\"\"Generating fields. Change commented line to get both cases.\"\"\"\n",
    "Ext_fields = four_point_args(beta0, 0.0731, (0,3/2,'n')).fields\n",
    "#Ext_fields = four_point_args(beta0, 0.0731, (2,1/2,'n')).fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 4.72+0.12*1j\n",
    "eps = 0\n",
    "charge = Charge('c', c + eps)\n",
    "beta0 = charge.get('beta')\n",
    "\n",
    "L_s = 8  #spectrum truncation order\n",
    "bl = 25 # blocks truncation order\n",
    "\n",
    "\"\"\"Generating fields. Change commented line to get both cases.\"\"\"\n",
    "Ext_fields = four_point_args(beta0, 0.231+0.1432*1j, (0,1/2,'n')).fields\n",
    "#Ext_fields = four_point_args(beta0, 0.231+0.1432*1j, (2,3/2,'n')).fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Computing function values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Generating functions and computing their values.\"\"\"\n",
    "\n",
    "\"\"\"Generating four-point function\"\"\"\n",
    "t0 = time.clock()\n",
    "Z = ND4(Ext_fields, L = L_s, blocklevel = bl)\n",
    "dur = time.clock()-t0\n",
    "print('Function created in %s seconds.' %Table.format_time(dur))\n",
    "\n",
    "\"\"\"Computing s-and-t-channel values.\"\"\"\n",
    "\n",
    "points = [0.01, 0.03, 0.1, 0.2, 0.4] # points to compute the functions.\n",
    "\n",
    "st_vals = [Z.values(z = p) for p in points] # s-ch, t-ch for each point.\n",
    "\n",
    "\"\"\"Computing relative differences\"\"\"\n",
    "diffs = []\n",
    "\n",
    "for pair in st_vals:\n",
    "    rel_dif = abs(2*(pair[0]-pair[1])/(pair[0]+pair[1]))\n",
    "    diffs.append(rel_dif)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Building table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Building the Tex table\"\"\"\n",
    "\n",
    "pretty_vals = []\n",
    "for pair in st_vals:\n",
    "    point_vals = []\n",
    "    for i in range(2):\n",
    "        if abs(pair[i]) < 10**(-2):\n",
    "            point_vals.append(Table.format_exp('{:.9g}'.format(pair[i].real)))\n",
    "        else:\n",
    "            point_vals.append(Table.format_result(pair[i], digits = 15))\n",
    "    pretty_vals.append(point_vals)\n",
    "\n",
    "header = r'\\begin{array}{|c|c|c|} \\hline ' + '\\n'\n",
    "\n",
    "header += r' z & Z(z) & \\text{Difference} \\\\ \\hline'\n",
    "\n",
    "data = ''\n",
    "for i in range(len(points)):\n",
    "    data += '\\n ' + '%s & ' % points[i]\n",
    "    \n",
    "    data += (r'\\begin{array}{l}  ' + '\\n' + r's: %s \\\\' %pretty_vals[i][0]\n",
    "             + '\\n ' + r't: %s ' %pretty_vals[i][1] + '\\n'+ r'\\end{array}')\n",
    "    \n",
    "    data += r' & ' + Table.format_precision(diffs[i]) + r' \\\\ \\hline'\n",
    "        \n",
    "ending = '\\n' + r'\\end{array}'\n",
    "\n",
    "tbl_st = header + data + ending # string for the table.\n",
    "\n",
    "\"\"\"Creating references for the table\"\"\"\n",
    "\n",
    "ref_str = (r'\\left[ \\begin{array}{l}' + '\\n' \n",
    "            + r'c = %s \\\\ ' %c  + '\\n' \n",
    "            + r'\\Delta_1 = ')\n",
    "\n",
    "D1 = Ext_fields[0].dims[0].get('degenerate') \n",
    "if D1 == None:\n",
    "    D1 = Ext_fields[0].dims[0].get('Delta')\n",
    "    ref_str += str(D1) + r'\\\\' + '\\n'\n",
    "else:\n",
    "    ref_str += r'\\Delta_{%s} \\\\' %latex((Rational(D1[0]), Rational(D1[1])) )+ '\\n'\n",
    "\n",
    "D2 = Ext_fields[1].dims[0].get('degenerate') \n",
    "ref_str += r'(r_2, s_2) = %s \\\\ ' %latex((Rational(D2[0]), Rational(D2[1]))) + '\\n'\n",
    "\n",
    "ref_str += r'\\end{array} \\right] \\rightarrow' + '\\n' #string for references.\n",
    "\n",
    "\n",
    "\"\"\" Displaying Table and Tex commands\"\"\"\n",
    "\n",
    "display(Math(ref_str + tbl_st))\n",
    "print(r'\\epsilon = %s, L= %s, blocklevel = %s' %(eps, L_s, bl))\n",
    "print(ref_str + tbl_st)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  Functions with four different fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we compute a function of the type\n",
    "\\begin{align}\n",
    "\\left\\langle V^D_{P_1} V^N_{(r_2,s_2)} V^D_{P_3} V^N_{(r_4,s_4)} \\right \\rangle\n",
    "\\end{align}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Generate charge and fields\"\"\"\n",
    "\n",
    "c = -0.5432\n",
    "eps = 0\n",
    "C = Charge('c', c+eps)\n",
    "beta0 = C.get('beta')\n",
    "\n",
    "L_s = 8  #spectrum truncation order\n",
    "bl = 20 # blocks truncation order\n",
    "\n",
    "Ext_fields = four_point_args(beta0, 0.2314, (4,-7/2 ,'n') , 1.265, (2,1/2,'n')).fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Generating functions and computing their values.\"\"\"\n",
    "\n",
    "\"\"\"Generating four-point function\"\"\"\n",
    "t0 = time.clock()\n",
    "Z = ND4(Ext_fields, L = L_s, blocklevel = bl)\n",
    "dur = time.clock()-t0\n",
    "print('Function created in %s seconds.' %Table.format_time(dur))\n",
    "\n",
    "\"\"\"Computing s-and-t-channel values.\"\"\"\n",
    "\n",
    "points = [0.01, 0.03, 0.1, 0.2, 0.4, 0.6, 0.8, 0.9] # points to compute the functions.\n",
    "\n",
    "st_vals = [Z.values(z = p) for p in points] # s-ch, t-ch for each point.\n",
    "\n",
    "\"\"\"Computing relative differences\"\"\"\n",
    "diffs = []\n",
    "\n",
    "for pair in st_vals:\n",
    "    rel_dif = abs(2*(pair[0]-pair[1])/(pair[0]+pair[1]))\n",
    "    diffs.append(rel_dif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Building the Tex table\"\"\"\n",
    "\n",
    "pretty_vals = []\n",
    "for pair in st_vals:\n",
    "    point_vals = []\n",
    "    for i in range(2):\n",
    "        if abs(pair[i]) < 10**(-2):\n",
    "            point_vals.append(Table.format_exp('{:.9g}'.format(pair[i].real)))\n",
    "        else:\n",
    "            point_vals.append(Table.format_result(pair[i], digits = 15))\n",
    "    pretty_vals.append(point_vals)\n",
    "\n",
    "header = r'\\begin{array}{|c|c|c|} \\hline ' + '\\n'\n",
    "\n",
    "header += r' z & Z(z) & \\text{Difference} \\\\ \\hline'\n",
    "\n",
    "data = ''\n",
    "for i in range(len(points)):\n",
    "    data += '\\n ' + '%s & ' % points[i]\n",
    "    \n",
    "    data += (r'\\begin{array}{l}  ' + '\\n' + r's: %s \\\\' %pretty_vals[i][0]\n",
    "             + '\\n ' + r't: %s ' %pretty_vals[i][1] + '\\n'+ r'\\end{array}')\n",
    "    \n",
    "    data += r' & ' + Table.format_precision(diffs[i]) + r' \\\\ \\hline'\n",
    "        \n",
    "ending = '\\n' + r'\\end{array}'\n",
    "\n",
    "tbl_st = header + data + ending # string for the table.\n",
    "\n",
    "\"\"\"Creating references for the table\"\"\"\n",
    "\n",
    "ref_str = (r'\\left[ \\begin{array}{l}' + '\\n' \n",
    "            + r'c = %s \\\\ ' %c  + '\\n' )\n",
    "\n",
    "\n",
    "D1 = Ext_fields[0].dims[0].get('degenerate') \n",
    "ref_str += r'\\Delta_1 = '\n",
    "if D1 == None:\n",
    "    D1 = Ext_fields[0].dims[0].get('Delta')\n",
    "    ref_str += str(D1) + r'\\\\' + '\\n'\n",
    "else:\n",
    "    ref_str += r' \\Delta_{%s} \\\\' %latex((Rational(D1[0]), Rational(D1[1])) )+ '\\n'\n",
    "\n",
    "D2 = Ext_fields[1].dims[0].get('degenerate') \n",
    "ref_str += r'(r_2, s_2) = %s \\\\ ' %latex((Rational(D2[0]), Rational(D2[1]))) + '\\n'\n",
    "\n",
    "D3 = Ext_fields[2].dims[0].get('degenerate') \n",
    "ref_str += r'\\Delta_3 = '\n",
    "if D3 == None:\n",
    "    D3 = Ext_fields[2].dims[0].get('Delta')\n",
    "    ref_str += str(D3) + r'\\\\' + '\\n'\n",
    "else:\n",
    "    ref_str += r'\\Delta_{%s} \\\\' %latex((Rational(D3[0]), Rational(D3[1])) )+ '\\n'\n",
    "\n",
    "D4 = Ext_fields[3].dims[0].get('degenerate') \n",
    "ref_str += r'(r_4, s_4) = %s \\\\ ' %latex((Rational(D4[0]), Rational(D4[1]))) + '\\n'\n",
    "\n",
    "ref_str += r'\\end{array} \\right] \\rightarrow' + '\\n' #string for references.\n",
    "\n",
    "\n",
    "\"\"\" Displaying Table and Tex commands\"\"\"\n",
    "\n",
    "display(Math(ref_str + tbl_st))\n",
    "print(r'\\epsilon = %s, L= %s, blocklevel = %s' %(eps, L_s, bl))\n",
    "print(ref_str + tbl_st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}