Example_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "946dbc34",
   "metadata": {},
   "source": [
    "Let us illustrate how to use our code. <br>\n",
    "As the first thing, we import the libraries and the definitions needed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c8560bcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy.polynomial import polynomial as P\n",
    "from itertools import product\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "from Definitions import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "951f1295",
   "metadata": {},
   "source": [
    "Then, we introduce our functions with an example based on a simple CY three-fold. <br>\n",
    "Let us start with the exact formula..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2a437a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The full polynomial is:\n",
      "[[  1.   3.   3.]\n",
      " [ 14.   2.   2.]\n",
      " [ 14.   1.   1.]\n",
      " [  1.   0.   0.]\n",
      " [ -1.   0.   3.]\n",
      " [-84.   1.   2.]\n",
      " [-84.   2.   1.]\n",
      " [ -1.   3.   0.]]\n",
      "...from which we read the following non-trivial Hodge numbers: [h11, h12] = [14.0, 84.0]\n",
      "\n",
      "The computational time was: 2.4844539165496826 seconds\n"
     ]
    }
   ],
   "source": [
    "# Define the weight system\n",
    "example_weight_threefold = [10, 27, 53, 85, 175]\n",
    "\n",
    "# Finds both the exact result and the approximation, and saves the time needed to compute the full formula.\n",
    "start_time = time.time()\n",
    "exact_poly, approx_poly = Poincare_clean(np.array(np.array(example_weight_threefold)))\n",
    "end_time = time.time()\n",
    "compute_time_exact = end_time - start_time\n",
    "\n",
    "print(f\"The full polynomial is:\\n{exact_poly}\")\n",
    "print(f\"...from which we read the following non-trivial Hodge numbers: [h11, h12] = {Hodge_reader_3folds(exact_poly)}\")\n",
    "print(f\"\\nThe computational time was: {compute_time_exact} seconds\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f75ba5cb",
   "metadata": {},
   "source": [
    "And we now move to the approximation on its own..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e8983fe4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The truncated polynomial is:\n",
      "[[  1.   3.   3.]\n",
      " [ 10.   2.   2.]\n",
      " [ 10.   1.   1.]\n",
      " [  1.   0.   0.]\n",
      " [ -1.   0.   3.]\n",
      " [-84.   1.   2.]\n",
      " [-84.   2.   1.]\n",
      " [ -1.   3.   0.]]\n",
      "...from which we read the following approximated Hodge numbers: [10.0, 84.0]\n",
      "\n",
      "The computational time was: 0.11216497421264648 seconds\n"
     ]
    }
   ],
   "source": [
    "# Finds the approxiamted Hodge numbers using truncated formula, and saves the time needed to calculate.\n",
    "start_time = time.time()\n",
    "approximated_poly = Poincare_approx_clean(np.array(np.array(example_weight_threefold)))\n",
    "end_time = time.time()\n",
    "compute_time_approx = end_time - start_time\n",
    "\n",
    "print(f\"The truncated polynomial is:\\n{approximated_poly}\")\n",
    "print(f\"...from which we read the following approximated Hodge numbers: {Hodge_reader_3folds(approximated_poly)}\")\n",
    "print(f\"\\nThe computational time was: {compute_time_approx} seconds\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3f11dd5",
   "metadata": {},
   "source": [
    "Extending these results to the consideration of a CY four-fold..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "52425247",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The full polynomial is:\n",
      "[[  1.   4.   4.]\n",
      " [122.   3.   3.]\n",
      " [824.   2.   2.]\n",
      " [122.   1.   1.]\n",
      " [  1.   0.   0.]\n",
      " [  1.   0.   4.]\n",
      " [ 76.   1.   3.]\n",
      " [ 76.   3.   1.]\n",
      " [ -6.   2.   3.]\n",
      " [ -6.   1.   2.]\n",
      " [ -6.   3.   2.]\n",
      " [ -6.   2.   1.]\n",
      " [  1.   4.   0.]]\n",
      "...from which we read the following Hodge numbers: [h11, h12, h13, h22] = [122.0, 6.0, 76.0, 824.0]\n",
      "The computational time was: 6.788607120513916 seconds\n",
      "---------------------------------------\n",
      "The truncated polynomial is:\n",
      "[[  1.   4.   4.]\n",
      " [118.   3.   3.]\n",
      " [787.   2.   2.]\n",
      " [118.   1.   1.]\n",
      " [  1.   0.   0.]\n",
      " [  1.   0.   4.]\n",
      " [ 75.   1.   3.]\n",
      " [ 75.   3.   1.]\n",
      " [  1.   4.   0.]]\n",
      "...from which we read the following approximated Hodge numbers:[h11, h12, h13, h22] = [118.0, 0, 75.0, 787.0]\n",
      "The computational time was: 0.14397406578063965 seconds\n"
     ]
    }
   ],
   "source": [
    "# Define the weight system\n",
    "example_weight_fourfold = [ 10,  27,  36,  38, 159, 234]\n",
    "\n",
    "# Finds both the exact result and the approximation, and saves the time needed to compute the full formula.\n",
    "start_time = time.time()\n",
    "exact_poly, approx_poly = Poincare_clean(np.array(np.array(example_weight_fourfold)))\n",
    "end_time = time.time()\n",
    "compute_time_exact = end_time - start_time\n",
    "\n",
    "# Finds the approxiamted Hodge numbers using truncated formula, and saves the time needed to calculate.\n",
    "start_time = time.time()\n",
    "approximated_poly = Poincare_approx_clean(np.array(np.array(example_weight_fourfold)))\n",
    "end_time = time.time()\n",
    "compute_time_approx = end_time - start_time\n",
    "\n",
    "print(f\"The full polynomial is:\\n{exact_poly}\")\n",
    "print(f\"...from which we read the following Hodge numbers: [h11, h12, h13, h22] = {Hodge_reader_4folds(exact_poly)}\")\n",
    "print(f\"The computational time was: {compute_time_exact} seconds\")\n",
    "print(\"---------------------------------------\")\n",
    "print(f\"The truncated polynomial is:\\n{approximated_poly}\")\n",
    "print(f\"...from which we read the following approximated Hodge numbers:[h11, h12, h13, h22] = {Hodge_reader_4folds(approximated_poly)}\")\n",
    "print(f\"The computational time was: {compute_time_approx} seconds\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df6be3f7",
   "metadata": {},
   "source": [
    "We now demonstrate the computation of the Euler number (exactly) for the example weight system..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e5423325",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The euler number is:\n",
      "-1200\n"
     ]
    }
   ],
   "source": [
    "# Define the weight system\n",
    "example_weight_fourfold = [ 10,  27,  36,  38, 159, 234]\n",
    "\n",
    "#Compute the Euler number of Calabi-Yau hypersurface of the weight system's respective weighted projective space.\n",
    "euler = EulerNumber(example_weight_fourfold)\n",
    "\n",
    "print(f\"The euler number is:\\n{euler}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f15ef012",
   "metadata": {},
   "source": [
    "Alternatively one can check an input weight system for the intradivisibility property..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "98e526f7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Is this weight system intradivisible? --> True\n"
     ]
    }
   ],
   "source": [
    "# Define the weight system\n",
    "example_weight_fourfold = [ 10,  27,  36,  38, 159, 234]\n",
    "\n",
    "#Compute the intravisibility check (as a boolean True/False output)\n",
    "D = intradivisibility(example_weight_fourfold)\n",
    "\n",
    "print(f\"Is this weight system intradivisible? --> {D}\")\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": 5
}