scaling_laws_residue.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8f895f46",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pylab import *\n",
    "\n",
    "import time\n",
    "import res_utils as ru\n",
    "import copy\n",
    "%matplotlib inline\n",
    "plt.rcParams.update({'font.size': 14})\n",
    "plt.rcParams.update({'text.usetex': False})\n",
    "\n",
    "plt.rcParams.update({'font.family': 'serif'})\n",
    "plt.rcParams.update({'font.family': 'serif', 'font.serif':['Arial']})\n",
    "\n",
    "np.set_printoptions(precision=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3893472a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def norm_range(v):\n",
    "    return (v-v.min())/(v.max()-v.min())\n",
    "\n",
    "\n",
    "def crvec(N, D=1):\n",
    "    rphase = 2*np.pi * np.random.rand(int(D), int(N))\n",
    "    return np.cos(rphase) + 1.0j * np.sin(rphase)\n",
    "\n",
    "\n",
    "def scvec(N, D, K):\n",
    "    letter_vectors_c = crvec(N, D)\n",
    "\n",
    "    for d in range(D):\n",
    "        ip = np.random.choice(int(N), size=int(N-K), replace=False)\n",
    "        letter_vectors_c[d, ip] = 0\n",
    "\n",
    "    return letter_vectors_c\n",
    "\n",
    "\n",
    "def lccvec(N, D, K):\n",
    "    # N needs to be multiple of K\n",
    "\n",
    "    R = N/K\n",
    "\n",
    "    assert (R == N//K)\n",
    "\n",
    "    letter_vectors_c = 0*crvec(N, D)\n",
    "\n",
    "    for d in range(D):\n",
    "        ip = np.random.choice(int(R), size=int(K), replace=True)\n",
    "\n",
    "        ip += int(R) * np.arange(int(K))\n",
    "\n",
    "        letter_vectors_c[d, ip] = crvec(K, 1)\n",
    "\n",
    "    return letter_vectors_c\n",
    "\n",
    "\n",
    "def cconv(a, b, pa=1, pb=1):\n",
    "    return ifft(fft(a)**pa * fft(b)**pb)\n",
    "\n",
    "\n",
    "def ccinv(a):\n",
    "    return ifft(np.conj(fft(a)))\n",
    "\n",
    "\n",
    "def lccbind(vec1, vec2, Kv, pa=1, pb=1):\n",
    "    Nv = vec1.shape[0]\n",
    "    Rv = Nv/Kv\n",
    "\n",
    "    vec1r = np.reshape(vec1, [int(Kv), int(Rv)])\n",
    "    vec2r = np.reshape(vec2, [int(Kv), int(Rv)])\n",
    "\n",
    "    vec_br = cconv(vec1r, vec2r, pa, pb)\n",
    "\n",
    "    vec_b = vec_br.flatten()\n",
    "\n",
    "    return vec_b\n",
    "\n",
    "\n",
    "def lccperm(vec1, Kv, proll=1):\n",
    "    Nv = vec1.shape[0]\n",
    "    Rv = Nv/Kv\n",
    "\n",
    "    vec1r = np.reshape(vec1, [int(Kv), int(Rv)])\n",
    "\n",
    "    vec_perm = np.roll(vec1r, proll, axis=0)\n",
    "\n",
    "    return vec_perm.flatten()\n",
    "\n",
    "\n",
    "def lccinv(vec1, Kv):\n",
    "    Nv = vec1.shape[0]\n",
    "    Rv = Nv/Kv\n",
    "\n",
    "    vec1r = np.reshape(vec1, [int(Kv), int(Rv)])\n",
    "\n",
    "    vec1_ir = ccinv(vec1r)\n",
    "    vec1_i = vec1_ir.flatten()\n",
    "\n",
    "    return vec1_i\n",
    "\n",
    "\n",
    "def update_resonator_digit_async(codebooks, resonator, scene):\n",
    "    resonator_update = copy.copy(resonator)\n",
    "    for i in range(len(codebooks)):\n",
    "        new_code = scene\n",
    "        for j in range(len(codebooks)):\n",
    "            if i != j:\n",
    "                new_code = new_code*(resonator_update[j, :]**-1)\n",
    "        new_code = np.dot(codebooks[i].T, np.dot(\n",
    "            np.conj(codebooks[i]), new_code.T))\n",
    "#         new_code = np.dot(outer_products[i],new_code.T)\n",
    "        new_code = new_code / np.abs(new_code)\n",
    "        resonator_update[i, :] = new_code\n",
    "    return resonator_update\n",
    "\n",
    "\n",
    "def g(x):\n",
    "    return x / np.abs(x)\n",
    "\n",
    "\n",
    "def gen_res_digit(resonator, codebooks, max_iters, tree):\n",
    "    res_hist = []\n",
    "    res_curr = resonator\n",
    "    for i in range(max_iters):\n",
    "        res_hist.append(copy.copy(res_curr))\n",
    "        res_curr = update_resonator_digit_async(codebooks, res_curr, tree)\n",
    "        if np.mean(np.cos(np.angle(np.ndarray.flatten(res_curr))-np.angle(np.ndarray.flatten(res_hist[-1])))) > 0.99:\n",
    "            break\n",
    "    res_hist.append(copy.copy(res_curr))\n",
    "#         print i\n",
    "    return i+1, res_hist\n",
    "\n",
    "\n",
    "def dot_complex(vec1, vec2):\n",
    "    num = np.dot(np.conj(vec1), vec2)\n",
    "    denom = np.linalg.norm(vec1)*np.linalg.norm(vec2)\n",
    "#     return np.abs(num)/denom)*np.linalg.norm(vec2)\n",
    "    return np.abs(num)/denom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "55943571",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293]\n"
     ]
    }
   ],
   "source": [
    "prime_set = []\n",
    "# for num in range(2,21):\n",
    "for num in range(2, 301):\n",
    "    for i in range(2, num):\n",
    "        if (num % i == 0):\n",
    "            break\n",
    "    else:\n",
    "        prime_set.append(num)\n",
    "print(prime_set)\n",
    "hd_dims = np.round(2**np.arange(1, 12, 0.2)).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b80cb00a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 6 0.35\n",
      "2 6 0.35\n",
      "3 6 0.45\n",
      "3 6 0.6\n",
      "3 6 0.65\n",
      "4 6 0.75\n",
      "5 6 0.85\n",
      "5 6 0.75\n",
      "6 6 1.0\n",
      "6 15 0.85\n",
      "7 15 0.95\n",
      "8 15 0.95\n",
      "9 15 1.0\n",
      "9 35 0.75\n",
      "11 35 0.85\n",
      "12 35 0.75\n",
      "14 35 0.85\n",
      "16 35 1.0\n",
      "16 77 0.55\n",
      "18 77 0.75\n",
      "21 77 0.85\n",
      "24 77 0.95\n",
      "28 77 1.0\n",
      "28 143 0.8\n",
      "32 143 0.9\n",
      "37 143 1.0\n",
      "37 221 0.75\n",
      "42 221 0.95\n",
      "49 221 0.9\n",
      "56 221 1.0\n",
      "56 323 0.95\n",
      "64 323 0.95\n",
      "74 323 1.0\n",
      "74 437 0.9\n",
      "84 437 1.0\n",
      "84 667 0.95\n",
      "97 667 0.95\n",
      "111 667 0.95\n",
      "128 667 0.95\n",
      "147 667 1.0\n",
      "147 899 1.0\n",
      "147 1147 1.0\n",
      "147 1517 0.95\n",
      "169 1517 1.0\n",
      "169 1763 1.0\n",
      "169 2021 1.0\n",
      "169 2491 0.9\n",
      "194 2491 0.95\n",
      "223 2491 1.0\n",
      "223 3127 1.0\n",
      "223 3599 0.95\n",
      "256 3599 1.0\n",
      "256 4087 1.0\n",
      "256 4757 1.0\n",
      "256 5183 0.95\n",
      "294 5183 1.0\n",
      "294 5767 1.0\n",
      "294 6557 0.95\n",
      "338 6557 1.0\n",
      "338 7387 0.9\n",
      "388 7387 1.0\n",
      "388 8633 1.0\n",
      "388 9797 0.95\n",
      "446 9797 1.0\n",
      "446 10403 1.0\n",
      "446 11021 1.0\n",
      "446 11663 1.0\n",
      "446 12317 0.95\n",
      "512 12317 1.0\n",
      "512 14351 1.0\n",
      "512 16637 1.0\n",
      "512 17947 0.9\n",
      "588 17947 1.0\n",
      "588 19043 1.0\n",
      "588 20711 1.0\n",
      "588 22499 0.95\n",
      "676 22499 1.0\n",
      "676 23707 1.0\n",
      "676 25591 1.0\n",
      "676 27221 1.0\n",
      "676 28891 1.0\n",
      "676 30967 1.0\n",
      "676 32399 0.95\n",
      "776 32399 1.0\n",
      "776 34571 0.95\n",
      "891 34571 1.0\n",
      "891 36863 1.0\n",
      "891 38021 0.95\n",
      "1024 38021 1.0\n",
      "1024 39203 1.0\n",
      "1024 41989 1.0\n",
      "1024 47053 1.0\n",
      "1024 50621 0.95\n",
      "1176 50621 0.95\n",
      "1351 50621 1.0\n",
      "1351 51983 1.0\n",
      "1351 53357 1.0\n",
      "1351 55687 1.0\n",
      "1351 57599 1.0\n",
      "1351 60491 1.0\n",
      "1351 64507 1.0\n",
      "1351 67591 1.0\n",
      "1351 70747 1.0\n",
      "1351 72899 1.0\n",
      "1351 75067 0.95\n",
      "1552 75067 1.0\n",
      "1552 77837 1.0\n",
      "1552 79523 1.0\n"
     ]
    }
   ],
   "source": [
    "n_trials = 20\n",
    "\n",
    "acc = np.zeros((len(hd_dims), len(prime_set)-2))\n",
    "breaks = np.zeros((len(prime_set)))\n",
    "# for i in range(len(hd_dims)):\n",
    "#     v_size = hd_dims[i]\n",
    "reset = 0\n",
    "for j in range(len(prime_set)-2):\n",
    "    bases = prime_set[j:j+2]\n",
    "    for i in range(reset, len(hd_dims)):\n",
    "        v_size = hd_dims[i]\n",
    "        for k in range(n_trials):\n",
    "            seed_vecs = []\n",
    "            for m in range(len(bases)):\n",
    "                seed_vecs.append(ru.cvecl(v_size, loopsize=bases[m]))\n",
    "\n",
    "            codebooks = []\n",
    "            for m in range(len(bases)):\n",
    "                samp_code = np.random.normal(0.0, 1.0, size=(\n",
    "                    bases[m], v_size)) + 1j*np.random.normal(0.0, 1.0, size=(bases[m], v_size))\n",
    "                samp_code = samp_code*0\n",
    "                codebooks.append(samp_code)\n",
    "\n",
    "            for m in range(len(bases)):\n",
    "                for n in range(bases[m]):\n",
    "                    codebooks[m][n, :] = np.power(seed_vecs[m], n)\n",
    "\n",
    "            resonator = np.ones((len(bases), v_size), dtype=complex)\n",
    "            for m in range(len(codebooks)):\n",
    "                resonator[m, :] = np.random.normal(0.0, 1.0, size=(\n",
    "                    1, v_size)) + 1j*np.random.normal(0.0, 1.0, size=(1, v_size))\n",
    "                resonator[m, :] = resonator[m, :] / np.abs(resonator[m, :])\n",
    "\n",
    "            num_iters = 50\n",
    "            key = np.random.randint(0, bases[0]*bases[1])\n",
    "\n",
    "            scene = np.ones((v_size,), dtype=complex)\n",
    "            for m in range(len(bases)):\n",
    "                scene *= np.power(seed_vecs[m], key)\n",
    "\n",
    "            n_updates, res_hist = gen_res_digit(\n",
    "                resonator, codebooks, num_iters, scene)\n",
    "\n",
    "            progs = []\n",
    "            for m in range(len(bases)):\n",
    "                c = codebooks[m]\n",
    "                corrs = np.zeros((n_updates, c.shape[0]), dtype=complex)\n",
    "                for n in range(n_updates-1, n_updates):\n",
    "                    for p in range(c.shape[0]):\n",
    "                        # codebooks[m][p,:])\n",
    "                        corrs[n, p] = dot_complex(c[p, :], res_hist[n][m, :])\n",
    "                progs.append(corrs)\n",
    "\n",
    "            acc[i, j] += (np.argmax(progs[0][-1, :]) == key %\n",
    "                          bases[0])*(np.argmax(progs[1][-1, :]) == key % bases[1])\n",
    "\n",
    "        print(hd_dims[i], np.prod(bases), acc[i, j]/n_trials)\n",
    "        if (acc[i, j]/n_trials >= .99):\n",
    "            breaks[j] = i\n",
    "            reset = i\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "101d830f",
   "metadata": {},
   "outputs": [],
   "source": [
    "caps = np.zeros(len(prime_set)-4)\n",
    "critnum = np.zeros(len(prime_set)-4)\n",
    "for i in range(len(prime_set)-4):\n",
    "    caps[i] = prime_set[i]*prime_set[i+1]\n",
    "    critnum[i] = hd_dims[int(breaks[i])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "796a3d65",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('2mods_resultsv2.npz', caps=caps, critnum=critnum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "765d6a3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n"
     ]
    }
   ],
   "source": [
    "prime_set = []\n",
    "# for num in range(2,21):\n",
    "for num in range(2, 51):\n",
    "    for i in range(2, num):\n",
    "        if (num % i == 0):\n",
    "            break\n",
    "    else:\n",
    "        prime_set.append(num)\n",
    "print(prime_set)\n",
    "hd_dims = np.round(np.arange(128, 15001, 128)).astype(int)\n",
    "hd_dims = np.round(2**np.arange(4, 14, 0.2)).astype(int)\n",
    "# print(hd_dims)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "92af0160",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16 30 0.95\n",
      "18 30 0.75\n",
      "21 30 0.9\n",
      "24 30 0.9\n",
      "28 30 0.95\n",
      "32 30 0.85\n",
      "37 30 1.0\n",
      "37 105 0.8\n",
      "42 105 0.9\n",
      "49 105 1.0\n",
      "49 385 0.8\n",
      "56 385 0.8\n",
      "64 385 0.8\n",
      "74 385 0.65\n",
      "84 385 0.75\n",
      "97 385 0.9\n",
      "111 385 0.85\n",
      "128 385 0.95\n",
      "147 385 0.9\n",
      "169 385 1.0\n",
      "169 1001 0.9\n",
      "194 1001 1.0\n",
      "194 2431 0.75\n",
      "223 2431 0.95\n",
      "256 2431 0.8\n",
      "294 2431 0.85\n",
      "338 2431 0.9\n",
      "388 2431 0.95\n",
      "446 2431 0.9\n",
      "512 2431 1.0\n",
      "512 4199 0.7\n",
      "588 4199 0.95\n",
      "676 4199 0.95\n",
      "776 4199 0.95\n",
      "891 4199 1.0\n",
      "891 7429 0.9\n",
      "1024 7429 1.0\n",
      "1024 12673 0.9\n",
      "1176 12673 0.95\n",
      "1351 12673 0.9\n",
      "1552 12673 0.9\n",
      "1783 12673 1.0\n",
      "1783 20677 1.0\n",
      "1783 33263 0.8\n",
      "2048 33263 0.95\n",
      "2353 33263 0.85\n",
      "2702 33263 1.0\n",
      "2702 47027 0.95\n",
      "3104 47027 1.0\n",
      "3104 65231 0.85\n",
      "3566 65231 1.0\n",
      "3566 82861 0.95\n",
      "4096 82861 1.0\n"
     ]
    }
   ],
   "source": [
    "n_trials = 20\n",
    "# n_trials = 200 to fully visualize the trend\n",
    "\n",
    "acc2 = np.zeros((len(hd_dims), len(prime_set)-2))\n",
    "breaks2 = np.zeros((len(hd_dims)))*(n_trials)\n",
    "# for i in range(len(hd_dims)):\n",
    "#     v_size = hd_dims[i]\n",
    "reset = 0\n",
    "for j in range(len(prime_set)-2):\n",
    "    bases = prime_set[j:j+3]\n",
    "    for i in range(reset, len(hd_dims)):\n",
    "        v_size = hd_dims[i]\n",
    "        for k in range(n_trials):\n",
    "            seed_vecs = []\n",
    "            for m in range(len(bases)):\n",
    "                seed_vecs.append(ru.cvecl(v_size, loopsize=bases[m]))\n",
    "\n",
    "            codebooks = []\n",
    "            for m in range(len(bases)):\n",
    "                samp_code = np.random.normal(0.0, 1.0, size=(\n",
    "                    bases[m], v_size)) + 1j*np.random.normal(0.0, 1.0, size=(bases[m], v_size))\n",
    "                samp_code = samp_code*0\n",
    "                codebooks.append(samp_code)\n",
    "\n",
    "            for m in range(len(bases)):\n",
    "                for n in range(bases[m]):\n",
    "                    codebooks[m][n, :] = np.power(seed_vecs[m], n)\n",
    "\n",
    "            resonator = np.ones((len(bases), v_size), dtype=complex)\n",
    "            for m in range(len(codebooks)):\n",
    "                resonator[m, :] = np.random.normal(0.0, 1.0, size=(\n",
    "                    1, v_size)) + 1j*np.random.normal(0.0, 1.0, size=(1, v_size))\n",
    "                resonator[m, :] = resonator[m, :] / np.abs(resonator[m, :])\n",
    "\n",
    "            num_iters = 50\n",
    "            key = np.random.randint(0, bases[0]*bases[1]*bases[2])\n",
    "\n",
    "            scene = np.ones((v_size,), dtype=complex)\n",
    "            for m in range(len(bases)):\n",
    "                scene *= np.power(seed_vecs[m], key)\n",
    "\n",
    "            n_updates, res_hist = gen_res_digit(\n",
    "                resonator, codebooks, num_iters, scene)\n",
    "\n",
    "            progs = []\n",
    "            for m in range(len(bases)):\n",
    "                c = codebooks[m]\n",
    "                corrs = np.zeros((n_updates, c.shape[0]), dtype=complex)\n",
    "                for n in range(n_updates-1, n_updates):\n",
    "                    for p in range(c.shape[0]):\n",
    "                        # codebooks[m][p,:])\n",
    "                        corrs[n, p] = dot_complex(c[p, :], res_hist[n][m, :])\n",
    "                progs.append(corrs)\n",
    "\n",
    "            acc2[i, j] += (np.argmax(progs[0][-1, :]) == key % bases[0])*(np.argmax(\n",
    "                progs[1][-1, :]) == key % bases[1])*(np.argmax(progs[2][-1, :]) == key % bases[2])\n",
    "\n",
    "        print(hd_dims[i], np.prod(bases), acc2[i, j]/n_trials)\n",
    "        if (acc2[i, j]/n_trials >= .99):\n",
    "            breaks2[j] = i\n",
    "            reset = i\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "baedbaa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "caps3 = np.zeros(len(prime_set)-4)\n",
    "critnum3 = np.zeros(len(prime_set)-4)\n",
    "for i in range(len(prime_set)-4):\n",
    "    caps3[i] = prime_set[i]*prime_set[i+1]*prime_set[i+2]\n",
    "    critnum3[i] = hd_dims[int(breaks2[i])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "98ee78ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('3mods_resultsv2.npz', caps3=caps3, critnum3=critnum3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "bd4f2db7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n"
     ]
    }
   ],
   "source": [
    "prime_set = []\n",
    "# for num in range(2,21):\n",
    "for num in range(2, 30):\n",
    "    for i in range(2, num):\n",
    "        if (num % i == 0):\n",
    "            break\n",
    "    else:\n",
    "        prime_set.append(num)\n",
    "print(prime_set)\n",
    "hd_dims = np.round(np.arange(128, 20000.1, 128)).astype(int)\n",
    "hd_dims = np.round(2**np.arange(7, 16, 0.5)).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "f2e6562e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "128 210 0.9\n",
      "181 210 0.9\n",
      "256 210 1.0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "256 1155 0.8\n",
      "362 1155 0.75\n",
      "512 1155 0.8\n",
      "724 1155 0.95\n",
      "1024 1155 1.0\n",
      "1024 5005 0.75\n",
      "1448 5005 0.85\n",
      "2048 5005 1.0\n",
      "2048 17017 0.9\n",
      "2896 17017 0.8\n",
      "4096 17017 0.9\n",
      "5793 17017 0.95\n",
      "8192 17017 1.0\n",
      "8192 46189 0.85\n",
      "11585 46189 0.95\n",
      "16384 46189 1.0\n",
      "16384 96577 0.95\n",
      "23170 96577 1.0\n",
      "23170 215441 0.9\n",
      "32768 215441 0.9\n",
      "46341 215441 1.0\n"
     ]
    }
   ],
   "source": [
    "n_trials = 20\n",
    "\n",
    "acc3 = np.zeros((len(hd_dims), len(prime_set)-3))\n",
    "breaks3 = np.zeros((len(hd_dims)))*(n_trials)\n",
    "\n",
    "reset = 0\n",
    "for j in range(len(prime_set)-3):\n",
    "    bases = prime_set[j:j+4]\n",
    "    for i in range(reset, len(hd_dims)):\n",
    "        v_size = hd_dims[i]\n",
    "        for k in range(n_trials):\n",
    "            seed_vecs = []\n",
    "            for m in range(len(bases)):\n",
    "                seed_vecs.append(ru.cvecl(v_size, loopsize=bases[m]))\n",
    "\n",
    "            codebooks = []\n",
    "            for m in range(len(bases)):\n",
    "                samp_code = np.random.normal(0.0, 1.0, size=(\n",
    "                    bases[m], v_size)) + 1j*np.random.normal(0.0, 1.0, size=(bases[m], v_size))\n",
    "                samp_code = samp_code*0\n",
    "                codebooks.append(samp_code)\n",
    "\n",
    "            for m in range(len(bases)):\n",
    "                for n in range(bases[m]):\n",
    "                    codebooks[m][n, :] = np.power(seed_vecs[m], n)\n",
    "\n",
    "            resonator = np.ones((len(bases), v_size), dtype=complex)\n",
    "            for m in range(len(codebooks)):\n",
    "                resonator[m, :] = np.random.normal(0.0, 1.0, size=(\n",
    "                    1, v_size)) + 1j*np.random.normal(0.0, 1.0, size=(1, v_size))\n",
    "                resonator[m, :] = resonator[m, :] / np.abs(resonator[m, :])\n",
    "\n",
    "            num_iters = 50\n",
    "            key = np.random.randint(0, bases[0]*bases[1]*bases[2]*bases[3])\n",
    "\n",
    "            scene = np.ones((v_size,), dtype=complex)\n",
    "            for m in range(len(bases)):\n",
    "                scene *= np.power(seed_vecs[m], key)\n",
    "\n",
    "            n_updates, res_hist = gen_res_digit(\n",
    "                resonator, codebooks, num_iters, scene)\n",
    "\n",
    "            progs = []\n",
    "            for m in range(len(bases)):\n",
    "                c = codebooks[m]\n",
    "                corrs = np.zeros((n_updates, c.shape[0]), dtype=complex)\n",
    "                for n in range(n_updates-1, n_updates):\n",
    "                    for p in range(c.shape[0]):\n",
    "                        # codebooks[m][p,:])\n",
    "                        corrs[n, p] = dot_complex(c[p, :], res_hist[n][m, :])\n",
    "                progs.append(corrs)\n",
    "\n",
    "            acc3[i, j] += (np.argmax(progs[0][-1, :]) == key % bases[0])*(np.argmax(progs[1][-1, :]) == key %\n",
    "                                                                          bases[1])*(np.argmax(progs[2][-1, :]) == key % bases[2])**(np.argmax(progs[3][-1, :]) == key % bases[3])\n",
    "\n",
    "        print(hd_dims[i], np.prod(bases), acc3[i, j]/n_trials)\n",
    "        if (acc3[i, j]/n_trials >= .99):\n",
    "            breaks3[j] = i\n",
    "            reset = i\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "d6a5febd",
   "metadata": {},
   "outputs": [],
   "source": [
    "caps4 = np.zeros(len(prime_set)-4)\n",
    "critnum4 = np.zeros(len(prime_set)-4)\n",
    "for i in range(len(prime_set)-4):\n",
    "    caps4[i] = prime_set[i]*prime_set[i+1]*prime_set[i+2]*prime_set[i+3]\n",
    "    critnum4[i] = hd_dims[int(breaks3[i])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "5b593796",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('4mods_resultsv2.npz', caps4=caps4, critnum4=critnum4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "dc63a1df",
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = ['darkblue', 'tab:orange', 'darkviolet', 'seagreen']\n",
    "colors = colors[0:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "c95114cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "caps = np.load('2mods_resultsv2.npz')['caps']\n",
    "critnum = np.load('2mods_resultsv2.npz')['critnum']\n",
    "\n",
    "caps3 = np.load('3mods_resultsv2.npz')['caps3']\n",
    "critnum3 = np.load('3mods_resultsv2.npz')['critnum3']\n",
    "\n",
    "caps4 = np.load('4mods_resultsv2.npz')['caps4']\n",
    "critnum4 = np.load('4mods_resultsv2.npz')['critnum4']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "b5258678",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1.742 -1.42 ]\n",
      "[ 1.523 -1.659]\n",
      "[ 1.318 -1.924]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'log(Vector dimension)')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(5, 5), dpi=100)\n",
    "scatter(np.log(critnum), np.log(caps), s=20, c=colors[0])\n",
    "scatter(np.log(critnum3), np.log(caps3), s=20, c=colors[1])\n",
    "scatter(np.log(critnum4), np.log(caps4), s=30, c=colors[2])\n",
    "# scatter(np.log(caps5),np.log(critnum5),s=60)\n",
    "\n",
    "model1 = np.poly1d(np.polyfit(np.log(critnum), np.log(caps), 1))\n",
    "polyline = np.linspace(np.log(np.min(critnum)), np.log(np.max(critnum)), 100)\n",
    "plot(polyline, model1(polyline), '--', lw=2, label='K=2', c=colors[0])\n",
    "print(model1.coeffs)\n",
    "\n",
    "model2 = np.poly1d(np.polyfit(np.log(critnum3), np.log(caps3), 1))\n",
    "polyline2 = np.linspace(np.log(np.min(critnum3)),\n",
    "                        np.log(np.max(critnum3)), 100)\n",
    "plot(polyline2, model2(polyline2), '--', lw=2, label='K=3', c=colors[1])\n",
    "\n",
    "print(model2.coeffs)\n",
    "\n",
    "model3 = np.poly1d(np.polyfit(np.log(critnum4), np.log(caps4), 1))\n",
    "polyline3 = np.linspace(np.log(np.min(critnum4)),\n",
    "                        np.log(np.max(critnum4)), 100)\n",
    "plot(polyline3, model3(polyline3), '--', lw=2, label='K=4', c=colors[2])\n",
    "print(model3.coeffs)\n",
    "\n",
    "plot(np.linspace(0, 12, 100), np.linspace(\n",
    "    0, 12, 100)-3, '-', lw=2, c='black', alpha=0.4)\n",
    "\n",
    "# model5 = np.poly1d(np.polyfit(np.log(caps5),np.log(critnum5), 1))\n",
    "# polyline5 = np.linspace(np.log(np.min(caps5)), np.log(np.max(caps5)), 100)\n",
    "# plot(polyline5, model5(polyline5),'--',lw=2,label='5 factors')\n",
    "# print(model5.coeffs)\n",
    "legend(fontsize=18)\n",
    "# xscale('log')\n",
    "# xlim([2, 12])\n",
    "# ylim([2, 12])\n",
    "\n",
    "ylabel('log(Coding range)', fontsize=24)\n",
    "xlabel('log(Vector dimension)', fontsize=24)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "03ef652d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.8, 2.2)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "figure(figsize=(5, 5), dpi=100)\n",
    "scatter([2, 3, 4], [2, 1.5, 4./3], s=50, color='black')\n",
    "# plot([2,3,4],[0.5,2./3,3./4])\n",
    "bar([2, 3, 4], [model1.coeffs[0], model2.coeffs[0],\n",
    "    model3.coeffs[0]], color=colors, alpha=0.5)\n",
    "x_sp = np.linspace(2, 5, 21)\n",
    "plot(x_sp, (x_sp)/(x_sp-1), '--', color='black')\n",
    "# plot([2,3,4],[0.533,0.595,0.8])\n",
    "xlabel('Number of modules ($\\it{K}$)')\n",
    "ylabel('Scaling coefficient ($\\\\alpha_K$)')\n",
    "xlim(1.5, 4.5)\n",
    "ylim(.8, 2.2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.12.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}