notebooks/pyfhel_hello_world.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "14752d15-af93-411a-9083-1f8d6f401726",
   "metadata": {},
   "source": [
    "# Getting Started with [`Pyfhel`](https://dl.acm.org/doi/pdf/10.1145/3474366.3486923)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffac4dfe-8821-40b1-8d44-d7aa17341d8d",
   "metadata": {},
   "source": [
    "In this notebook, we will be exploring two FHE schemes, viz. `bfv` and `ckks` using Pyfhel along with supporting examples of mathematical operations on 1D array."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb315c20-a15e-45ba-a78c-93dedd35e4ad",
   "metadata": {},
   "source": [
    "### Importing the libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "258709db-e037-45b7-81ca-41fa8816eb9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d67eba95-511a-45a9-997e-89fd15417e6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from Pyfhel import PyCtxt, Pyfhel, PyPtxt\n",
    "\n",
    "HE1 = Pyfhel() # creating an empty Pyfhel object"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f72f674b-8eaa-41f6-b06c-bc696ef7cf96",
   "metadata": {},
   "source": [
    "### [FHE Schemes](https://dl.acm.org/doi/pdf/10.1145/3474366.3486923)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11c23d4d-f6dd-4ae8-9b90-f83eecdc158d",
   "metadata": {},
   "source": [
    "Virtually all modern FHE schemes are based on (variants of) the Learning with Errors (LWE) hardness assumption and rely on a small amount of noise added during encryption to guarantee security. During homomorphic operations, this noise grows. This effect is negligible for additions, but very significant for multiplications. Should the noise grow too large, decryption would no longer produce correct results. Theoretically, a technique known as bootstrapping can be used to homomorphically reset the noise in a ciphertext. However, this can be computationally expensive and therefore is not frequently used in practice. Instead, schemes are instantiated with parameters large enough to allow the computation to complete without requiring bootstrapping. In this notebook, we explore a second generation FHE scheme, **Brakerski/Fan-Vercauteren (BFV)** and Fourth generation, **Cheon-Kim-Kim-Song (CKKS)** schemes implemented in SEAL library. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee902396-afa2-4aa9-873c-534e9916a369",
   "metadata": {},
   "source": [
    "### Exploring `Brakerski/Fan-Vercauteren (BFV)` scheme"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08604806-c3ff-4be3-a4fe-d40e4f017309",
   "metadata": {},
   "source": [
    "Lets first define the parameters for `bfv` schemes,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6814e998-17d9-4411-9549-800a473c1165",
   "metadata": {},
   "outputs": [],
   "source": [
    "bfv_params = {\n",
    "    'scheme':'bfv',\n",
    "    'n':2**13,\n",
    "    't':65537,\n",
    "    't_bits':20,\n",
    "    'sec':128,\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c0c2371-777e-42a2-a7db-900c9feaa23b",
   "metadata": {},
   "source": [
    "where,\n",
    "\n",
    "- scheme : 'BFV' , can also be 'bfv'.\n",
    "- 'n' :  2\\**13, Polynomial modulus degree, the number of slots per plain text of elements to be encoded in single ciphertext in a 2 by n/2 rectangular matrix (Type 2^D for D in [10,16]\n",
    "- 't' : 65537, Plain text modulus. Encrypted operations happen modulo t. Must be prime such that t-1 be divisible by 2^N.\n",
    "- 't_bits' : Number of bits in t. Used to generate suitable value for t. Overrides t if specified. \n",
    "- 'sec' :128, Security parameter. The equivalentlength of AES key is bits. Sets the ciphertext modulus q, can be one of {128, 192, 256}. More means more security but slower computations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3e3653a-e4aa-4774-b0c6-c3acb5955aae",
   "metadata": {},
   "source": [
    "**Generate context for `bfv` scheme**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bdb38337-6b70-46cb-aea3-1d71dc102659",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE1.contextGen(**bfv_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ed425a-4f25-41bb-b63d-e3073d63e1e8",
   "metadata": {},
   "source": [
    "**Generate a pair of public/secret keys**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f7c08b5e-3b45-4e10-913d-09d8f9daf9e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE1.keyGen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "638d7dd0-3df8-44dd-b04e-b182d4f08b55",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE1.rotateKeyGen() #Allows rotation/shifting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ca4947a4-15fe-4826-9960-56add3275780",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE1.relinKeyGen() #relinearization Key Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ef23600a-d9eb-429e-a12f-25514d96eaf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "1. Pyfhel FHE context generation\n",
      "\t<bfv Pyfhel obj at 0x7f5788395490, [pk:Y, sk:Y, rtk:Y, rlk:Y, contx(n=8192, t=1032193, sec=128, qi=[], scale=1.0, )]>\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n1. Pyfhel FHE context generation\")\n",
    "print(f\"\\t{HE1}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "996218d6-e453-44e5-afea-e530b8c57f6b",
   "metadata": {},
   "source": [
    "## Integer Array Encoding and Encryption"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e906a23-3f55-434f-a385-6b32509538c4",
   "metadata": {},
   "source": [
    "We will define two 1D integer array, encode and encrypt them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1c27f9cc-f938-41c6-bed8-5bba9f4f51d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.arange(bfv_params['n'], dtype=np.int64) # arr1 = [0,1,2..., n-1]\n",
    "arr2 = np.array([-bfv_params['t']//2, -1, -1], dtype=np.int64) # arr2 = [-t//2, -1, -1] (length = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "127e0c27-2b24-4e96-b195-86e4b8a93347",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   0    1    2 ... 8189 8190 8191]\n",
      "[-32769     -1     -1]\n"
     ]
    }
   ],
   "source": [
    "print(arr1)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "918af613-a7d4-43c5-965b-11b3097ab810",
   "metadata": {},
   "source": [
    "We now create a PyPtxt plaintext with the encoded arrays. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a4a644e1-ae5b-47d8-b6a4-ec8a5264d2fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "ptxt1 = HE1.encodeInt(arr1)\n",
    "ptxt2 = HE1.encodeInt(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4b22e9bc-6160-4adf-b58c-fb62f8503633",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Pyfhel Plaintext at 0x7f57160b2040, scheme=bfv, poly=76277x^8191 + F8950x^8190..., is_ntt=->\n",
      "<Pyfhel Plaintext at 0x7f57160b20c0, scheme=bfv, poly=C54C9x^8191 + A8DA8x^8190..., is_ntt=->\n"
     ]
    }
   ],
   "source": [
    "print(ptxt1)\n",
    "print(ptxt2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef794e80-c851-49b6-a274-8718986aa471",
   "metadata": {},
   "source": [
    "We now encrypt the plaintxt ptxt and returns the ciphertext."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "efb0078a-f890-4256-9caf-fd739207a29a",
   "metadata": {},
   "outputs": [],
   "source": [
    "ctxt1 = HE1.encryptPtxt(ptxt1)\n",
    "ctxt2 = HE1.encryptPtxt(ptxt2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7a92989f-4d04-4aaa-9bc2-ecb68588bfa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Pyfhel Ciphertext at 0x7f57160acb80, scheme=bfv, size=2/2, noiseBudget=146>\n",
      "<Pyfhel Ciphertext at 0x7f57160b56d0, scheme=bfv, size=2/2, noiseBudget=146>\n"
     ]
    }
   ],
   "source": [
    "print(ctxt1)\n",
    "print(ctxt2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "711a14db-826a-40c7-9997-519f00d1a67c",
   "metadata": {},
   "source": [
    "Once we finish the encoding and encryption steps. In the next steps we will show some operations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef0c1343-b853-44ef-83f4-43ebef6097d8",
   "metadata": {},
   "source": [
    "### Mathematical Operations on Encrypted data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6d1123f1-164f-4435-a4e5-1def935d19a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "cSum = ctxt1 + ctxt2  # Additon\n",
    "\n",
    "cSub = ctxt1 - ctxt2 # Substraction\n",
    "\n",
    "cMul = ctxt1 * ctxt2 # Multiplication\n",
    "\n",
    "cSq = ctxt1**2 # Square of the ciphertext\n",
    "\n",
    "cNeg = -ctxt1 # Negate\n",
    "\n",
    "cPow = ctxt1**3 # Power Operation\n",
    "\n",
    "cRotR = ctxt1 >> 2 # rotation operation 2 steps, the encoded data is places in a n//2 by 2 matrix. These rotation applys independently to each of the rows.\n",
    "\n",
    "cRotL = ctxt1 << 2 # rotation left 2 steps\n",
    "\n",
    "cCom = ctxt1 == ctxt2 # Comparing the two cipher text\n",
    "\n",
    "# Operation with plain text\n",
    "\n",
    "cpSum = ctxt1 + ptxt2 \n",
    "\n",
    "cpSub = ctxt1 - ptxt2\n",
    "\n",
    "cpMul = ctxt1 * ptxt2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "b095956d-1acc-4655-a2c3-db515300db59",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secure operations\n",
      " Ciphertext-ciphertext: \n",
      "->\tctxt1 + ctxt2 = cSum:  <Pyfhel Ciphertext at 0x7f57160b5770, scheme=bfv, size=2/2, noiseBudget=145>\n",
      "->\tctxt1 - ctxt2 = cSub:  <Pyfhel Ciphertext at 0x7f57160c2770, scheme=bfv, size=2/2, noiseBudget=145>\n",
      "->\tctxt1 * ctxt2 = cMul:  <Pyfhel Ciphertext at 0x7f57160c2810, scheme=bfv, size=3/3, noiseBudget=114>\n",
      " Single ciphertext: \n",
      "->\tctxt1**2      = cSq  :  <Pyfhel Ciphertext at 0x7f57160c28b0, scheme=bfv, size=3/3, noiseBudget=114>\n",
      "->\t- ctxt1       = cNeg :  <Pyfhel Ciphertext at 0x7f57160c2900, scheme=bfv, size=2/2, noiseBudget=146>\n",
      "->\tctxt1**3      = cPow :  <Pyfhel Ciphertext at 0x7f57160c2950, scheme=bfv, size=2/2, noiseBudget=81>\n",
      "->\tctxt1 >> 2    = cRotR:  <Pyfhel Ciphertext at 0x7f57160c29a0, scheme=bfv, size=2/2, noiseBudget=142>\n",
      "->\tctxt1 << 2    = cRotL:  <Pyfhel Ciphertext at 0x7f57160c29f0, scheme=bfv, size=2/2, noiseBudget=143>\n",
      "->\tctxt1 == ctxt2 = cCom:  False\n",
      " Ciphertext-plaintext: \n",
      "->\tctxt1 + ptxt2 = cpSum:  <Pyfhel Ciphertext at 0x7f57160c2a40, scheme=bfv, size=2/2, noiseBudget=146>\n",
      "->\tctxt1 - ptxt2 = cpSub:  <Pyfhel Ciphertext at 0x7f57160c2a90, scheme=bfv, size=2/2, noiseBudget=146>\n",
      "->\tctxt1 * ptxt2 = cpMul:  <Pyfhel Ciphertext at 0x7f57160c2ae0, scheme=bfv, size=2/2, noiseBudget=121>\n"
     ]
    }
   ],
   "source": [
    "# All operations leads cipher text\n",
    "\n",
    "print(\"Secure operations\")\n",
    "print(\" Ciphertext-ciphertext: \")\n",
    "print(\"->\\tctxt1 + ctxt2 = cSum: \", cSum)\n",
    "print(\"->\\tctxt1 - ctxt2 = cSub: \", cSub)\n",
    "print(\"->\\tctxt1 * ctxt2 = cMul: \", cMul)\n",
    "print(\" Single ciphertext: \")\n",
    "print(\"->\\tctxt1**2      = cSq  : \", cSq)\n",
    "print(\"->\\t- ctxt1       = cNeg : \", cNeg)\n",
    "print(\"->\\tctxt1**3      = cPow : \", cPow)\n",
    "print(\"->\\tctxt1 >> 2    = cRotR: \", cRotR)\n",
    "print(\"->\\tctxt1 << 2    = cRotL: \", cRotL)\n",
    "print(\"->\\tctxt1 == ctxt2 = cCom: \", cCom)\n",
    "print(\" Ciphertext-plaintext: \")\n",
    "print(\"->\\tctxt1 + ptxt2 = cpSum: \", cpSum)\n",
    "print(\"->\\tctxt1 - ptxt2 = cpSub: \", cpSub)\n",
    "print(\"->\\tctxt1 * ptxt2 = cpMul: \", cpMul)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69bcbe5e-cc77-4d78-91cd-1babfbc2f3d3",
   "metadata": {},
   "source": [
    "In case of multiplication, ciphertext-ciphertext multiplication increases the size of the ploynomials representing the resulting ciphertext. To prevent this growth, the relinearization technique is used (typically right after the multiplication operation) to resude the size of the cipher text back to the minimal size. For this, a special type of public key called Relinearization key is used. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "00fac921-64a6-4a69-b954-8fec8e841230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Relinearization-> Right after each multiplication.\n",
      "cMul before relinearization (size 3): <Pyfhel Ciphertext at 0x7f57160c2810, scheme=bfv, size=3/3, noiseBudget=114>\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n Relinearization-> Right after each multiplication.\")\n",
    "print(f\"cMul before relinearization (size {cMul.size()}): {cMul}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "cc87b330-a672-4a3e-b9ce-d70f482566b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE1.relinearize(cMul)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7c60b929-b8eb-42ed-b654-4abe97bc51a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cMul after relinearization (size 2): <Pyfhel Ciphertext at 0x7f57160c2810, scheme=bfv, size=2/3, noiseBudget=114>\n",
      "cPow after 2 mult&relin rounds:  (size 2): <Pyfhel Ciphertext at 0x7f57160c2950, scheme=bfv, size=2/2, noiseBudget=81>\n"
     ]
    }
   ],
   "source": [
    "print(f\"cMul after relinearization (size {cMul.size()}): {cMul}\")\n",
    "print(f\"cPow after 2 mult&relin rounds:  (size {cPow.size()}): {cPow}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "651626b1-01c5-49f3-b8cb-884fe8e73df3",
   "metadata": {},
   "source": [
    "We see that the size has decreased after relinearization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e0c2f93-b4ee-4729-8cbe-9aadafc704b9",
   "metadata": {},
   "source": [
    "Now, its time for decrypting and decoding results. \n",
    "\n",
    "Previously, we encoded and encrypted the integers by using `HE.encode()` and `HE.encrypt()` operations. The process can also be done in a single operation by using `HE.encryptInt()` operation. In order to decode and decrypt the result, we will be using `HE.decryptInt()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5f03ff24-5ae6-4c1e-b56c-11aac2099408",
   "metadata": {},
   "outputs": [],
   "source": [
    "r1     = HE1.decryptInt(ctxt1)\n",
    "r2     = HE1.decryptInt(ctxt2)\n",
    "rccSum = HE1.decryptInt(cSum)\n",
    "rccSub = HE1.decryptInt(cSub)\n",
    "rccMul = HE1.decryptInt(cMul)\n",
    "rcSq   = HE1.decryptInt(cSq  )\n",
    "rcNeg  = HE1.decryptInt(cNeg )\n",
    "rcPow  = HE1.decryptInt(cPow )\n",
    "rcRotR = HE1.decryptInt(cRotR)\n",
    "rcRotL = HE1.decryptInt(cRotL)\n",
    "rcpSum = HE1.decryptInt(cpSum)\n",
    "rcpSub = HE1.decryptInt(cpSub)\n",
    "rcpMul = HE1.decryptInt(cpMul)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9a971731-156e-4787-a994-44ed8fd26529",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Decrypting results\n",
      " Original ciphertexts: \n",
      "   ->\tctxt1 --(decr)-->  [   0    1    2 ... 8189 8190 8191]\n",
      "   ->\tctxt2 --(decr)-->  [-32769     -1     -1 ...      0      0      0]\n",
      " Ciphertext-ciphertext Ops: \n",
      "   ->\tctxt1 + ctxt2 = ccSum --(decr)-->  [-32769      0      1 ...   8189   8190   8191]\n",
      "   ->\tctxt1 - ctxt2 = ccSub --(decr)-->  [32769     2     3 ...  8189  8190  8191]\n",
      "   ->\tctxt1 * ctxt2 = ccMul --(decr)-->  [ 0 -1 -2 ...  0  0  0]\n",
      " Single ciphertext: \n",
      "   ->\tctxt1**2      = cSq   --(decr)-->  [     0      1      4 ... -32824 -16445    -64]\n",
      "   ->\t- ctxt1       = cNeg  --(decr)-->  [    0    -1    -2 ... -8189 -8190 -8191]\n",
      "   ->\tctxt1**3      = cPow  --(decr)-->  [      0       1       8 ... -425556 -499460  507969]\n",
      "   ->\tctxt1 >> 2    = cRotR --(decr)-->  [4094 4095    0 ... 8187 8188 8189]\n",
      "   ->\tctxt1 << 2    = cRotL --(decr)-->  [   2    3    4 ... 8191 4096 4097]\n",
      " Ciphertext-plaintext ops: \n",
      "   ->\tctxt1 + ptxt2 = cpSum --(decr)-->  [-32769      0      1 ...   8189   8190   8191]\n",
      "   ->\tctxt1 - ptxt2 = cpSub --(decr)-->  [32769     2     3 ...  8189  8190  8191]\n",
      "   ->\tctxt1 * ptxt2 = cpMul --(decr)-->  [ 0 -1 -2 ...  0  0  0]\n"
     ]
    }
   ],
   "source": [
    "print(\" Decrypting results\")\n",
    "print(\" Original ciphertexts: \")\n",
    "print(\"   ->\\tctxt1 --(decr)--> \", r1)\n",
    "print(\"   ->\\tctxt2 --(decr)--> \", r2)\n",
    "print(\" Ciphertext-ciphertext Ops: \")\n",
    "print(\"   ->\\tctxt1 + ctxt2 = ccSum --(decr)--> \", rccSum)\n",
    "print(\"   ->\\tctxt1 - ctxt2 = ccSub --(decr)--> \", rccSub)\n",
    "print(\"   ->\\tctxt1 * ctxt2 = ccMul --(decr)--> \", rccMul)\n",
    "print(\" Single ciphertext: \")\n",
    "print(\"   ->\\tctxt1**2      = cSq   --(decr)--> \", rcSq  )\n",
    "print(\"   ->\\t- ctxt1       = cNeg  --(decr)--> \", rcNeg )\n",
    "print(\"   ->\\tctxt1**3      = cPow  --(decr)--> \", rcPow )\n",
    "print(\"   ->\\tctxt1 >> 2    = cRotR --(decr)--> \", rcRotR)\n",
    "print(\"   ->\\tctxt1 << 2    = cRotL --(decr)--> \", rcRotL)\n",
    "print(\" Ciphertext-plaintext ops: \")\n",
    "print(\"   ->\\tctxt1 + ptxt2 = cpSum --(decr)--> \", rcpSum)\n",
    "print(\"   ->\\tctxt1 - ptxt2 = cpSub --(decr)--> \", rcpSub)\n",
    "print(\"   ->\\tctxt1 * ptxt2 = cpMul --(decr)--> \", rcpMul)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08d84bb6-35ba-4eab-aa58-4f159ff6599f",
   "metadata": {},
   "source": [
    "In this case, we encountered different mathematical operations using `bfv` scheme. \n",
    "\n",
    "Note: In case of comparing the two cipher text values, we do not need to decrypt the result since the result is Boolean for ciphertext comparison. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83bb1e70-fb18-4824-93a0-f7687e84798b",
   "metadata": {},
   "source": [
    "## Exploring `Cheon-Kim-Kim-Song (CKKS)` scheme"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f57c4dc4-0feb-4807-a4be-b4f96723f4cb",
   "metadata": {},
   "source": [
    "Lets first define the parameters for `ckks` schemes,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a066dc31-3f9e-4f91-a8be-a7e052912022",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE2 = Pyfhel() # creating an empty Pyfhel object for different scheme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "91d236d7-c126-456f-b8f4-32e4253077e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "ckks_params = {\n",
    "    'scheme': 'CKKS',\n",
    "    'n': 2**14,         \n",
    "    'scale': 2**30,\n",
    "    'qi': [60, 30, 30, 30, 60]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72af93ec-ec9a-4e7d-9e36-207b435df765",
   "metadata": {},
   "source": [
    "where,\n",
    "\n",
    "- scheme : ckks\n",
    "- 'n' : Polynomial modulus degree. For ckks, n/2 values can be encoded in a single cipher text.\n",
    "- 'scale' : All the encodings will use it for float -> fixed point conversion: x_fix = round(x_float * scale). You can use this as a default scale or use a different scale on each operation.\n",
    "- 'qi' : number of bits of each prime in a chain. Intermediatye values should be close to log2(scale) for each operation, to have small rounding errors. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1e362cf-3719-4ca6-a14c-d5e71b4fbfcf",
   "metadata": {},
   "source": [
    "**Generate context**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "fdc706b0-1929-44b4-8d73-74e85f868e9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE2.contextGen(**ckks_params)\n",
    "HE2.keyGen() # generates a pair of public/secret keys\n",
    "HE2.rotateKeyGen()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "822c8c8f-1516-4ad6-accb-3d9caafe1b97",
   "metadata": {},
   "source": [
    "We will define two float arrays, encode and encrypt them,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "59429bce-bac9-439f-b211-7707e83baa2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_x = np.array([0.1,0.2,0.3], dtype=np.float64)\n",
    "arr_y = np.array([-1.5, 2.3, 4.7], dtype = np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a0345594-4f07-42c4-b4c0-e415002db557",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3]\n",
      "[-1.5  2.3  4.7]\n"
     ]
    }
   ],
   "source": [
    "print(arr_x)\n",
    "print(arr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d3c8037c-7834-438e-9045-d7777b522c44",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encoding\n",
    "\n",
    "ptxt_x = HE2.encodeFrac(arr_x) # creates a PyPtxt plain text \n",
    "ptxt_y = HE2.encodeFrac(arr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "83721174-c6b4-443b-862a-d7e1f8f02483",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Pyfhel Plaintext at 0x7f57160cbec0, scheme=ckks, poly=?, is_ntt=Y, mod_level=0>\n",
      "<Pyfhel Plaintext at 0x7f57160cb2c0, scheme=ckks, poly=?, is_ntt=Y, mod_level=0>\n"
     ]
    }
   ],
   "source": [
    "print(ptxt_x)\n",
    "print(ptxt_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "11b1ac18-2f71-4208-bf64-0cdf68dc0d67",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Encrypting\n",
    "\n",
    "ctxt_x = HE2.encryptPtxt(ptxt_x) # Encrypts the plaintext ptxt_x and returns a PyCtxt\n",
    "ctxt_y = HE2.encryptPtxt(ptxt_y) #  Alternatively you can use HE.encryptFrac(arr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1c9c61c5-7e88-46bb-b42c-61a1787d7b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Pyfhel Ciphertext at 0x7f57160c5720, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "<Pyfhel Ciphertext at 0x7f57160c24a0, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n"
     ]
    }
   ],
   "source": [
    "print(ctxt_x)\n",
    "print(ctxt_y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74962098-0c33-4227-9a2d-9927704252f0",
   "metadata": {},
   "source": [
    "### Mathematical Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d8596600-e359-400b-9884-6a457bbee69e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit\n",
    "\n",
    "cSum = ctxt_x + ctxt_y       # Addition\n",
    "\n",
    "cSub = ctxt_x - ctxt_y       # Substraction\n",
    "\n",
    "cMul = ctxt_x * ctxt_y       # Multiplication\n",
    "\n",
    "cSq   = ctxt_x**2            # Square\n",
    "\n",
    "cNeg  = -ctxt_x              # Negate\n",
    "                            \n",
    "#cPow  = ctxt_x**3          # pow Not supported in CKKS, you will get an error when you execute this one.\n",
    "\n",
    "cRotR = ctxt_x >> 2          # Rotation\n",
    "\n",
    "cRotL = ctxt_x << 2          # Rotation Left\n",
    "\n",
    "cCom = ctxt_x == ctxt_x      # Comparison\n",
    "\n",
    "# Ciphetext-plaintext ops\n",
    "cpSum = ctxt_x + ptxt_y       # Addition with Plain text\n",
    "\n",
    "cpSub = ctxt_x - ptxt_y       # Substraction with Plain text\n",
    "\n",
    "cpMul = ctxt_x * ptxt_y       # Product with Plain text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e6c068b1-edb2-4c67-a72c-6b1a9e6d08ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secure operations\n",
      " Ciphertext-ciphertext: \n",
      "->\tctxt_x + ctxt_y = cSum:  <Pyfhel Ciphertext at 0x7f57160caf90, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x - ctxt_y = cSub:  <Pyfhel Ciphertext at 0x7f57160b5770, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x * ctxt_y = cMul:  <Pyfhel Ciphertext at 0x7f57160c2770, scheme=ckks, size=3/3, scale_bits=60, mod_level=1>\n",
      " Single ciphertext: \n",
      "->\tctxt_x**2      = cSq  :  <Pyfhel Ciphertext at 0x7f57160c2810, scheme=ckks, size=3/3, scale_bits=60, mod_level=1>\n",
      "->\t- ctxt_x       = cNeg :  <Pyfhel Ciphertext at 0x7f57160c28b0, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x >> 4    = cRotR:  <Pyfhel Ciphertext at 0x7f57160c2900, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x << 4    = cRotL:  <Pyfhel Ciphertext at 0x7f57160c29a0, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x == ctxt_y = cCom:  True\n",
      " Ciphertext-plaintext: \n",
      "->\tctxt_x + ptxt_y = cpSum:  <Pyfhel Ciphertext at 0x7f57160c29f0, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x - ptxt_y = cpSub:  <Pyfhel Ciphertext at 0x7f57160c2a40, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "->\tctxt_x * ptxt_y = cpMul:  <Pyfhel Ciphertext at 0x7f57160c2a90, scheme=ckks, size=2/2, scale_bits=60, mod_level=1>\n"
     ]
    }
   ],
   "source": [
    "print(\"Secure operations\")\n",
    "print(\" Ciphertext-ciphertext: \")\n",
    "print(\"->\\tctxt_x + ctxt_y = cSum: \", cSum)\n",
    "print(\"->\\tctxt_x - ctxt_y = cSub: \", cSub)\n",
    "print(\"->\\tctxt_x * ctxt_y = cMul: \", cMul)\n",
    "print(\" Single ciphertext: \")\n",
    "print(\"->\\tctxt_x**2      = cSq  : \", cSq  )\n",
    "print(\"->\\t- ctxt_x       = cNeg : \", cNeg )\n",
    "print(\"->\\tctxt_x >> 4    = cRotR: \", cRotR)\n",
    "print(\"->\\tctxt_x << 4    = cRotL: \", cRotL)\n",
    "print(\"->\\tctxt_x == ctxt_y = cCom: \", cCom)\n",
    "\n",
    "print(\" Ciphertext-plaintext: \")\n",
    "print(\"->\\tctxt_x + ptxt_y = cpSum: \", cpSum)\n",
    "print(\"->\\tctxt_x - ptxt_y = cpSub: \", cpSub)\n",
    "print(\"->\\tctxt_x * ptxt_y = cpMul: \", cpMul)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79971a76-9e48-4dc2-aaef-c3736a52b3cc",
   "metadata": {},
   "source": [
    "Like `bfv` scheme, we also do relinearization here in order to reduce the size of the product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "cfb47d73-6e2f-453e-a654-894393f3b709",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Relinearization-> Right after each multiplication.\n",
      "\n",
      "cMul before relinearization (size 3): <Pyfhel Ciphertext at 0x7f57160c2770, scheme=ckks, size=3/3, scale_bits=60, mod_level=1>\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n Relinearization-> Right after each multiplication.\\n\")\n",
    "\n",
    "print(f\"cMul before relinearization (size {cMul.size()}): {cMul}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "5781ea0c-a83d-49a4-a697-c617ced7c9c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "HE2.relinKeyGen()\n",
    "HE2.relinearize(cMul)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ba034745-aedb-4d25-b372-1a513da7ee84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ccMul after relinearization (size 2): <Pyfhel Ciphertext at 0x7f57160c2770, scheme=ckks, size=2/3, scale_bits=60, mod_level=1>\n"
     ]
    }
   ],
   "source": [
    "print(f\"ccMul after relinearization (size {cMul.size()}): {cMul}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f49612-7412-49eb-a3a9-7f363308bb57",
   "metadata": {},
   "source": [
    "### More complex mathematical operations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85a883ef-4697-40e4-b608-d752b8d3ce15",
   "metadata": {},
   "source": [
    "More complex operations with CKKS require keeping track of the CKKS scale. Operating with two CKKS ciphertexts (or a ciphertext or a plain text) requires them to have the same scale and same modulus level.\n",
    "\n",
    "- Scale: Multiplications yield a new scale, which is the product of the scales of the two operands. To scale down a ciphertext, the HE.rescale_to_next(ctxt) function is used, which switches the modulus to the next one in the qi chain and divides the ciphertext by the previous modulus. Since this is the only scale-down operation, it is advised to use `scale_bits` with the same size as the intermediate moduli in HE.qi.\n",
    "\n",
    "- Mod Switching: Switches to the next modulus in the qi chain, but without rescaling. This is achieved by the HE.mod_switch_to_next(ctxt) function. To ease the life of the user, Pyfhel provides `HE.align_mod_n_scale(this, other)`, which automatically does the rescaling and mod switching."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b46b916-83dd-4ddf-8a41-c65f6d111d3c",
   "metadata": {},
   "source": [
    "In the next case, we will compute mean squared error, treating the average of two ciphertexts as the true distribution."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3823fbad-7d0b-48ea-9273-e0beac07acd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Rescaling & Mod Switching.\n",
      "->\tMean:  <Pyfhel Ciphertext at 0x7f57160c3040, scheme=ckks, size=2/2, scale_bits=60, mod_level=1>\n",
      "->\tMSE_1:  <Pyfhel Ciphertext at 0x7f57160c30e0, scheme=ckks, size=2/3, scale_bits=60, mod_level=2>\n",
      "->\tMSE_2:  <Pyfhel Ciphertext at 0x7f57160c31d0, scheme=ckks, size=2/3, scale_bits=60, mod_level=2>\n",
      "->\tMSE:  <Pyfhel Ciphertext at 0x7f57160c3130, scheme=ckks, size=2/3, scale_bits=60, mod_level=3>\n"
     ]
    }
   ],
   "source": [
    "#  1. Mean\n",
    "c_mean = (ctxt_x + ctxt_y) / 2\n",
    "\n",
    "#  2. MSE\n",
    "c_mse_1 = ~((ctxt_x - c_mean)**2)\n",
    "c_mse_2 = (~(ctxt_y - c_mean)**2)\n",
    "c_mse = (c_mse_1 + c_mse_2)/ 3\n",
    "\n",
    "#  3. Cumulative sum\n",
    "c_mse += (c_mse << 1)\n",
    "c_mse += (c_mse << 2)  # element 0 contains the result\n",
    "print(\"\\n Rescaling & Mod Switching.\")\n",
    "print(\"->\\tMean: \", c_mean)\n",
    "print(\"->\\tMSE_1: \", c_mse_1)\n",
    "print(\"->\\tMSE_2: \", c_mse_2)\n",
    "print(\"->\\tMSE: \", c_mse)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcdcd5a0-ed1e-4acd-80bb-d5f56ac5118f",
   "metadata": {},
   "source": [
    "### Decrypting and decoding results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "6e2a1a60-3a40-442c-91af-25dd31bc1367",
   "metadata": {},
   "outputs": [],
   "source": [
    "r_x    = HE2.decryptFrac(ctxt_x)\n",
    "r_y    = HE2.decryptFrac(ctxt_y)\n",
    "rcSum = HE2.decryptFrac(cSum)\n",
    "rcSub = HE2.decryptFrac(cSub)\n",
    "rcMul = HE2.decryptFrac(cMul)\n",
    "rcSq   = HE2.decryptFrac(cSq  )\n",
    "rcNeg  = HE2.decryptFrac(cNeg )\n",
    "rcRotR = HE2.decryptFrac(cRotR)\n",
    "rcRotL = HE2.decryptFrac(cRotL)\n",
    "rcpSum = HE2.decryptFrac(cpSum)\n",
    "rcpSub = HE2.decryptFrac(cpSub)\n",
    "rcpMul = HE2.decryptFrac(cpMul)\n",
    "rmean  = HE2.decryptFrac(c_mean)\n",
    "rmse   = HE2.decryptFrac(c_mse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "8fdcabc1-4e2e-4805-9ee7-0568b9ecf796",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Decrypting results\n",
      " Original ciphertexts: \n",
      "   ->\tctxt_x --(decr)-->  [ 0.1  0.2  0.3 ... -0.   0.   0. ]\n",
      "   ->\tctxt_y --(decr)-->  [-1.5  2.3  4.7 ...  0.  -0.  -0. ]\n",
      " Ciphertext-ciphertext Ops: \n",
      "   ->\tctxt_x + ctxt_y = ccSum --(decr)-->  [-32769      0      1 ...   8189   8190   8191]\n",
      "   ->\tctxt_x - ctxt_y = ccSub --(decr)-->  [32769     2     3 ...  8189  8190  8191]\n",
      "   ->\tctxt_x * ctxt_y = ccMul --(decr)-->  [ 0 -1 -2 ...  0  0  0]\n",
      " Single ciphertext: \n",
      "   ->\tctxt_x**2      = cSq   --(decr)-->  [ 0.01  0.04  0.09 ...  0.   -0.   -0.  ]\n",
      "   ->\t- ctxt_x       = cNeg  --(decr)-->  [-0.1 -0.2 -0.3 ...  0.  -0.  -0. ]\n",
      "   ->\tctxt_x >> 4    = cRotR --(decr)-->  [-0.   0.   0.1 ...  0.  -0.  -0. ]\n",
      "   ->\tctxt_x << 4    = cRotL --(decr)-->  [ 0.297 -0.001  0.    ...  0.     0.1    0.2  ]\n",
      " Ciphertext-plaintext ops: \n",
      "   ->\tctxt_x + ptxt_y = cpSum --(decr)-->  [-1.4  2.5  5.  ... -0.   0.   0. ]\n",
      "   ->\tctxt_x - ptxt_y = cpSub --(decr)-->  [ 1.6 -2.1 -4.4 ... -0.   0.   0. ]\n",
      "   ->\tctxt_x * ptxt_y = cpMul --(decr)-->  [-0.15  0.46  1.41 ...  0.   -0.   -0.  ]\n",
      " Mean Squared error: \n",
      "   ->\tmean(ctxt_x, ctxt_y) = c_mean --(decr)-->  [-0.7  0.  -0.  ... -0.   0.  -0. ]\n",
      "   ->\tmse(ctxt_x, ctxt_y)  = c_mse  --(decr)-->  [ 0.427 -0.    -0.    ...  0.427  0.427  0.427]\n"
     ]
    }
   ],
   "source": [
    "_r = lambda x: np.round(x, decimals=3)\n",
    "print(\" Decrypting results\")\n",
    "print(\" Original ciphertexts: \")\n",
    "print(\"   ->\\tctxt_x --(decr)--> \", _r(r_x))\n",
    "print(\"   ->\\tctxt_y --(decr)--> \", _r(r_y))\n",
    "print(\" Ciphertext-ciphertext Ops: \")\n",
    "print(\"   ->\\tctxt_x + ctxt_y = ccSum --(decr)--> \", _r(rccSum))\n",
    "print(\"   ->\\tctxt_x - ctxt_y = ccSub --(decr)--> \", _r(rccSub))\n",
    "print(\"   ->\\tctxt_x * ctxt_y = ccMul --(decr)--> \", _r(rccMul))\n",
    "print(\" Single ciphertext: \")\n",
    "print(\"   ->\\tctxt_x**2      = cSq   --(decr)--> \", _r(rcSq  ))\n",
    "print(\"   ->\\t- ctxt_x       = cNeg  --(decr)--> \", _r(rcNeg ))\n",
    "print(\"   ->\\tctxt_x >> 4    = cRotR --(decr)--> \", _r(rcRotR))\n",
    "print(\"   ->\\tctxt_x << 4    = cRotL --(decr)--> \", _r(rcRotL))\n",
    "print(\" Ciphertext-plaintext ops: \")\n",
    "print(\"   ->\\tctxt_x + ptxt_y = cpSum --(decr)--> \", _r(rcpSum))\n",
    "print(\"   ->\\tctxt_x - ptxt_y = cpSub --(decr)--> \", _r(rcpSub))\n",
    "print(\"   ->\\tctxt_x * ptxt_y = cpMul --(decr)--> \", _r(rcpMul))\n",
    "print(\" Mean Squared error: \")\n",
    "print(\"   ->\\tmean(ctxt_x, ctxt_y) = c_mean --(decr)--> \", _r(rmean))\n",
    "print(\"   ->\\tmse(ctxt_x, ctxt_y)  = c_mse  --(decr)--> \", _r(rmse))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9be28bd-bccb-41dc-a1e6-1190d7f7a4b6",
   "metadata": {},
   "source": [
    "# Comparison between `bfv` and `ckks` scheme "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98a927ed-2514-40bf-bf54-bf6bd795a62e",
   "metadata": {},
   "source": [
    "CKKS uses approximate arithmetic instead of exact arithmetic, in the sense that once we finish computation we might get a slightly different result than if we did the computation directly. This means that if you encrypt 2 and 3, add their ciphertexts, and decrypt you might get something like 4.99 or 5.01 but not 5. Other schemes such as BFV are exact, which mean they will yield exactly 5. CKKS is more suited for arithmetic on real numbers, where we can have approximate but close results, while BFV is more suited for arithmetic on integers.\n",
    "\n",
    "\n",
    "Now, when we transform a number into ciphertext, each text can be seen as a ploynomial with noise. When you perform encrypted multiplication, the size of the output polynomial grows based on the size of the two multiplicands, which increases its memory footprints and slows down operations. In order to keep cipher text sizes low, it is recommended to relinearize after each multiplication, effectively shrinking the ciphertext back to minimum size. Besides this, the noise budget inside the cipher text grows greatly when multiplying. Each cipher text is given a noise budget when first encrypted, which decreases irreversibly for each multiplication. If the noise budget reaches zero, the result in ciphertext cannot be decrypted correctly anymore. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd109824-9d67-4c78-bdda-91162fc92aa4",
   "metadata": {},
   "source": [
    "**Example for `bfv` scheme**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed0c6441-07d0-4110-8fd6-1e0e7450f530",
   "metadata": {},
   "source": [
    "we have our pyfhel object for `bfv` scheme and the two integer arrays and their corresponding ciphertexts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "329a15a6-7623-49bb-bd63-0016a4150cc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([1,-1,1], dtype = np.int64)\n",
    "arr2 = np.array([1,1,-1], dtype = np.int64)\n",
    "ctxt1 = HE1.encryptInt(arr1)\n",
    "ctxt2 = HE1.encryptInt(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "ab2e5186-4d90-4277-8573-2a1740b45ccc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pyfhel bfv object :  <bfv Pyfhel obj at 0x7f5788395490, [pk:Y, sk:Y, rtk:Y, rlk:Y, contx(n=8192, t=1032193, sec=128, qi=[], scale=1.0, )]>\n",
      "Integer 1 :  [ 1 -1  1]\n",
      "Integer 2 :  [ 1  1 -1]\n",
      "Ciphertext 1 :  <Pyfhel Ciphertext at 0x7f57160a9f40, scheme=bfv, size=2/2, noiseBudget=146>\n",
      "Ciphertext 2 :  <Pyfhel Ciphertext at 0x7f57160acb80, scheme=bfv, size=2/2, noiseBudget=146>\n"
     ]
    }
   ],
   "source": [
    "print(\"Pyfhel bfv object : \",HE1)\n",
    "print(\"Integer 1 : \", arr1[:4])\n",
    "print(\"Integer 2 : \", arr2[:4])\n",
    "print(\"Ciphertext 1 : \", ctxt1)\n",
    "print(\"Ciphertext 2 : \", ctxt2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "379585ac-39f9-4f7b-aca9-a6041b64a723",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Secure Multiplication\n"
     ]
    }
   ],
   "source": [
    "print(\"Secure Multiplication\")\n",
    "step = 0 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bf12b47-0de9-46b2-8352-c3298580c016",
   "metadata": {},
   "source": [
    "To get the noise level, we can measure by using HE1.noise_level(ctxt). We need the private key in order to know the level."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "42258209-e817-4e11-b10f-d3a794c3b66c",
   "metadata": {},
   "outputs": [],
   "source": [
    "lvl = HE1.noise_level(ctxt1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3dd928ce-61f4-435a-911c-7381f657f504",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\tStep 0: noise_lvl 146, res[ 1 -1  1]\n",
      "\tStep 1: noise_lvl 114, res[ 1 -1 -1]\n",
      "\tStep 2: noise_lvl 82, res[ 1 -1  1]\n",
      "\tStep 3: noise_lvl 49, res[ 1 -1 -1]\n",
      "\tStep 4: noise_lvl 16, res[ 1 -1  1]\n",
      "Final Step 5 : noise_lvl 0, res[323575 -11958 -69734]\n"
     ]
    }
   ],
   "source": [
    "while lvl > 0:\n",
    "    print(f\"\\tStep {step}: noise_lvl {lvl}, res{HE1.decryptInt(ctxt1)[:3]}\")\n",
    "    step += 1\n",
    "    ctxt1 *= ctxt2   #Multiply\n",
    "    ctxt1 = ~(ctxt1) #Relinearising after each multiplication\n",
    "    lvl = HE1.noise_level(ctxt1)\n",
    "print(f\"Final Step {step} : noise_lvl {lvl}, res{HE1.decryptInt(ctxt1)[:3]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b67a0cd-cc25-4ba7-9b29-0a73c35f401d",
   "metadata": {},
   "source": [
    "**`ckks` scheme mulplicative depth**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb71364-119a-4766-a7fa-1641159df34a",
   "metadata": {},
   "source": [
    "In this case, we do not have a noise level operation to check the current noise, since the noise is considered as part of the encoding and adds up to a loss in precision of the encoded values. We can precisely control the maximum number of multiplications by setting qi (in parameters for ckks). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8dcb66ec-378a-429b-b741-a86ab9cf9bdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_mults = 10\n",
    "\n",
    "HE2 = Pyfhel(key_gen=True, context_params={\n",
    "    'scheme': 'CKKS',\n",
    "    'n': 2**14,         # For CKKS, n/2 values can be encoded in a single ciphertext. \n",
    "    'scale': 2**30,     # Each multiplication grows the final scale\n",
    "    'qi': [60]+ [30]*n_mults +[60] # Number of bits of each prime in the chain. \n",
    "                        # Intermediate prime sizes should be close to log2(scale).\n",
    "                        # One per multiplication! More/higher qi means bigger \n",
    "                        #  ciphertexts and slower ops.\n",
    "})\n",
    "HE2.relinKeyGen()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "8cecf01f-b938-4a11-a6de-6f89c0ab4f5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_x = np.array([1, -1, 1], dtype=np.float64) \n",
    "arr_y = np.array([1, 1, -1], dtype=np.float64)\n",
    "ctxt_x = HE2.encryptFrac(arr_x)\n",
    "ctxt_y = HE2.encryptFrac(arr_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "2d345eaa-b63d-4279-8e70-c0f021b946b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pyfhel ckks object :  <ckks Pyfhel obj at 0x7f57160ca940, [pk:Y, sk:Y, rtk:-, rlk:Y, contx(n=16384, t=0, sec=128, qi=[60, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 60], scale=1073741824.0, )]>\n",
      "Number 1 :  [ 1. -1.  1.]\n",
      "Number 2 :  [ 1.  1. -1.]\n",
      "Ciphertext 1 :  <Pyfhel Ciphertext at 0x7f57160c3ea0, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n",
      "Ciphertext 2 :  <Pyfhel Ciphertext at 0x7f57160c5720, scheme=ckks, size=2/2, scale_bits=30, mod_level=0>\n"
     ]
    }
   ],
   "source": [
    "print(\"Pyfhel ckks object : \",HE2)\n",
    "print(\"Number 1 : \", arr_x[:4])\n",
    "print(\"Number 2 : \", arr_y[:4])\n",
    "print(\"Ciphertext 1 : \", ctxt_x)\n",
    "print(\"Ciphertext 2 : \", ctxt_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "2838c8f4-f916-4c8c-9ef5-82ff7185cac6",
   "metadata": {},
   "outputs": [],
   "source": [
    "_r = lambda x : np.round(x, decimals=3)[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "9a4fa7f9-a3e0-4dc5-a58f-ba9c5c6b8225",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Securely multiplying 10 times!\n",
      "Step 1: res[ 1. -1. -1.]\n",
      "Step 2: res[ 1. -1.  1.]\n",
      "Step 3: res[ 1. -1. -1.]\n",
      "Step 4: res[ 1.001 -1.001  1.001]\n",
      "Step 5: res[ 1.002 -1.001 -1.001]\n",
      "Step 6: res[ 1.002 -1.002  1.002]\n",
      "Step 7: res[ 1.003 -1.003 -1.003]\n",
      "Step 8: res[ 1.006 -1.006  1.006]\n",
      "Step 9: res[ 1.008 -1.008 -1.008]\n",
      "Step 10: res[ 1.01 -1.01  1.01]\n",
      "If we multiply further we get: scale out of bounds\n"
     ]
    }
   ],
   "source": [
    "print(f\"Securely multiplying {n_mults} times!\")\n",
    "for step in range(1,n_mults+1):\n",
    "    ctxt_x *= ctxt_y  #Multiply\n",
    "    ctxt_x = ~ (ctxt_x) #relinearizing after multiplication!\n",
    "    print(f\"Step {step}: res{_r(HE2.decryptFrac(ctxt_x))}\")\n",
    "try:\n",
    "    ctxt_x *= ctxt_y\n",
    "except ValueError as e:\n",
    "    assert str(e)=='scale out of bounds'\n",
    "    print(f\"If we multiply further we get: {str(e)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1111dd9b-2a00-46ab-b649-fa2a49a5e5ca",
   "metadata": {},
   "source": [
    "# Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "062f3422-95c9-4fa5-822f-27762582fbc1",
   "metadata": {},
   "source": [
    "In this notebook, we explored two different schemes, viz. `bfv` and `ckks` and different mathematical operation they can perform using Pyfhel. We also compared the two schemes, one which is suitable for integer operation (`bfv`) and the other for real number operation (`ckks`) and investigated their multiplication depths. \n",
    "\n",
    "To conclude, we can say Pyfhel is a good tool to explore FHE. It can be used as a good teaching tool. By providing python-native abstraction layer on top of existing FHE implementations, Pyfhel makes working with FHE accessible to a signicantly wider audience.\n",
    "\n",
    "In the next case, we will be exploring the machine learning use cases by taking the cipher text encrypted by using Pyfhel schemes. "
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}