mipt_spectrum_2D.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09af4d44-0b0b-4d0b-9b9c-36566674fc1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "This notebook demonstrates how to compute spectrum of a random matrix \n",
    "\\Lambda_P=PU^{\\dag}PUP when random unitary U is constructed using \n",
    "finite-depth two-dimensional quantum circuits.\n",
    "These circuits consist of local 2-qubit fSim or random Clifford gates in the \n",
    "brickwall pattern (first over x, then over y direction) \n",
    "as well as (possibly) various single-qubit gates.\n",
    "P is a projector (with a specified rank).\n",
    "Random Clifford gates are generated using Qiskit.\n",
    "No Qiskit is needed if Clifford gates are not used.\n",
    "\n",
    "Packages information:\n",
    "---------------------\n",
    "numpy version = 1.26.4\n",
    "scipy version = 1.13.1\n",
    "qiskit version = 1.2.0\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e1303d2d-b443-4fd9-9981-f09f180f54fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy as sp\n",
    "from scipy.stats import unitary_group\n",
    "from scipy.sparse import csr_matrix\n",
    "from scipy.sparse import identity\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from qiskit.quantum_info import random_clifford"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f600eae3-6488-4c55-8a4e-0c3c32c486e2",
   "metadata": {},
   "source": [
    "### Some helpful fuctions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9af67c88-2803-41f0-a8d0-82280058222a",
   "metadata": {},
   "outputs": [],
   "source": [
    "def int2bits(L, n):\n",
    "    \"\"\"\n",
    "    Converts integer n to a bit string of length L\n",
    "    (with zeros added to the front of the binary string, if needed).\n",
    "    \"\"\"\n",
    "    return format(n,'0{}b'.format(L))\n",
    "\n",
    "\n",
    "def Flip(L, n, i):\n",
    "    \"\"\"\n",
    "    Flips a bit with an index i in a binary representation (of length L) of an\n",
    "    integer n.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    L : int\n",
    "        Length of a binary representation of integer n (with zeros added to the\n",
    "        front of the binary string, if needed).\n",
    "    n : int\n",
    "        Integer, whose binary representation is subjected to bit flipping.\n",
    "    i : int\n",
    "        Index of a bit being flipped.\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    n_bitflipped : int\n",
    "        Integer represeting the binary with the flipped bit.\n",
    "    \"\"\"\n",
    "    n_bitflipped = n^(1<<(L-(i+1)))\n",
    "    return n_bitflipped\n",
    "\n",
    "\n",
    "def embedded_1q_gate(L, U, q):\n",
    "    \"\"\"\n",
    "    Constructs a sparse CSR matrix corresponding to a single-qubit gate U acting on\n",
    "    a qubit with position q in a one-dimensional chain of L qubits.\n",
    "    Standard computational basis is assumed.\n",
    "    The dimensionality of the resulting matrix is 2**L.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    L : int\n",
    "        Length of a qubit chain.\n",
    "    U : np.ndarray\n",
    "        2x2 matrix representing a single-qubit gate.\n",
    "    q : int\n",
    "        Position of the qubit acted on by U within the qubit chain.\n",
    "    \"\"\"\n",
    "    index=[[0,1],[1,0]]\n",
    "    data=[]\n",
    "    row = []\n",
    "    col = []\n",
    "    for n in range(2**L):\n",
    "        for j in range(2):\n",
    "            if int(int2bits(L, n)[q]) == j:\n",
    "                [col.append(n) for k in range(2)]\n",
    "                row.append(n)\n",
    "                row.append(Flip(L, n, q))\n",
    "                [data.append(U[index[j][k],j]) for k in range(2)]\n",
    "    return csr_matrix((data, (row, col)), shape=(2**L, 2**L), dtype=np.complex128)\n",
    "\n",
    "\n",
    "def array_gates(L, U):\n",
    "    \"\"\"\n",
    "    Constructs a list of sparse CSR matrices corresponding to single-qubit gates U\n",
    "    acting on each qubit within the qubit chain of length L.\n",
    "    Dimensionality of each matrix is 2**L.\n",
    "    \"\"\"\n",
    "    gates = []\n",
    "    for q in range(L):\n",
    "        gates.append( embedded_1q_gate(L=L,U=U,q=q) )\n",
    "    return gates\n",
    "\n",
    "\n",
    "def embedded_2q_gate(L, U, q1, q2):\n",
    "    \"\"\"\n",
    "    Constructs a sparse CSR matrix corresponding to a two-qubit gate U acting on\n",
    "    qubits with positions q1 and q2 in a one-dimensional chain of L qubits.\n",
    "    Standard computational basis is assumed.\n",
    "    The dimensionality of the resulting matrix is 2**L.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    L : int\n",
    "        Length of a qubit chain.\n",
    "    U : np.ndarray\n",
    "        2x2 matrix representing a single-qubit gate.\n",
    "    q1 : int\n",
    "        Position of the first qubit acted on by U within the qubit chain.\n",
    "    q2 : int\n",
    "        Position of the second qubit acted on by U within the qubit chain.\n",
    "    \"\"\"\n",
    "    index=[[0,1,2,3],[1,0,3,2],[2,3,0,1],[3,2,1,0]]\n",
    "    data=[]\n",
    "    row = []\n",
    "    col = []\n",
    "    for n in range(2**L):\n",
    "        for j in range(4):\n",
    "            if (int(int2bits(L, n)[q1]) == int(int2bits(2,j)[0]) and \n",
    "                int(int2bits(L, n)[q2])==int(int2bits(2,j)[1]) ):\n",
    "                [col.append(n) for k in range(4)]\n",
    "                row.append(n)\n",
    "                row.append(Flip(L, n, q2))\n",
    "                row.append(Flip(L, n, q1))\n",
    "                row.append(Flip(L, Flip(L, n, q2), q1))\n",
    "                [data.append(U[index[j][k],j]) for k in range(4)]\n",
    "    return csr_matrix((data, (row, col)), shape=(2**L, 2**L), dtype=np.complex128)\n",
    "\n",
    "\n",
    "def fSim_2q_gate(theta, phi, beta):\n",
    "    \"\"\"\n",
    "    Constructs a two-qubit fSim gate (with parameters theta, phi and beta)\n",
    "    as a 4x4 matrix.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    theta : float\n",
    "    phi : float\n",
    "    beta : float\n",
    "    \"\"\"\n",
    "    return np.array(\n",
    "        [[1,0,0,0],\n",
    "         [0,np.cos(theta),1j*np.exp(1j*beta)*np.sin(theta),0],\n",
    "         [0,1j*np.exp(-1j*beta)*np.sin(theta),np.cos(theta),0],\n",
    "         [0,0,0,np.exp(1j*phi)]]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fd20d32-f787-4af7-8451-78190327ac2b",
   "metadata": {},
   "source": [
    "### Generate 1-qubit Pauli matrices and their combinations:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e11fd9b6-26e7-41e1-ad29-28d2ee6e2a90",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_1q = np.array([[0,1],[1,0]])\n",
    "Y_1q = np.array([[0,-1j],[1j,0]])\n",
    "Z_1q = np.array([[1,0],[0,-1]])\n",
    "W_1q = (X_1q+Y_1q)/np.sqrt(2)\n",
    "V_1q = (X_1q-Y_1q)/np.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "261337a5-c0fd-4334-b56a-4be5271d8dcb",
   "metadata": {},
   "source": [
    "### Main class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "167d0bd7-2915-4dce-9bae-fc0d5d2ad2d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class simulation_2D:\n",
    "    \"\"\"\n",
    "    Class to compute the spectrum of \\Lambda_P=PU^{\\dag}PUP, when U is constructed\n",
    "    as a local 2D quantum circuit.\n",
    "    These circuits consist of local 2-qubit fSim or random Clifford gates in the \n",
    "    brickwall pattern (first over x, then over y direction) \n",
    "    as well as (possibly) various single-qubit gates.\n",
    "    For numercial encoding, 2D grid is transformed into a 1D circuit with nonlocal\n",
    "    interactions.\n",
    "    P is a projector (with a specified rank).\n",
    "    \n",
    "    Attributes\n",
    "    ----------\n",
    "    Lx : int\n",
    "        Number of qubits in x-direction of the 2D qubit grid.\n",
    "    Ly : int\n",
    "        Number of qubits in y-direction of the 2D qubit grid.\n",
    "    b : float\n",
    "        Projection dimension. rank[P]=b*n. Requirement that b*2**L is integer.\n",
    "    theta : float\n",
    "        Parameter of the fSim gate (if U is constructed using fSim gates).\n",
    "    phi : float\n",
    "        Parameter of the fSim gate (if U is constructed using fSim gates).\n",
    "    beta : float\n",
    "        Parameter of the fSim gate (if U is constructed using fSim gates).\n",
    "    \"\"\"\n",
    "    def __init__(self, Lx, Ly, b, theta=None, phi=None, beta=None):\n",
    "        self.Lx = Lx\n",
    "        self.Ly = Ly\n",
    "        self.L = Lx*Ly\n",
    "        self.b = b\n",
    "        if theta != None:\n",
    "            self.theta = theta\n",
    "        if phi != None:\n",
    "            self.phi = phi\n",
    "        if beta != None:\n",
    "            self.beta = beta\n",
    "\n",
    "        # constructing square roots of single-qubit gates\n",
    "        self.sqrtX = array_gates(self.L, sp.linalg.sqrtm(X_1q))\n",
    "        self.sqrtY = array_gates(self.L, sp.linalg.sqrtm(Y_1q))\n",
    "        self.sqrtW = array_gates(self.L, sp.linalg.sqrtm(W_1q))\n",
    "        self.sqrtV = array_gates(self.L, sp.linalg.sqrtm(V_1q))\n",
    "\n",
    "        # constructing lists of single-qubit Pauli gates\n",
    "        self.X = array_gates(self.L, X_1q)\n",
    "        self.Y = array_gates(self.L, Y_1q)\n",
    "        self.Z = array_gates(self.L, Z_1q)\n",
    "\n",
    "        # constructing a dictionary of local (nearest-neighbor) fSim gates\n",
    "        # fSim[0] corresponds to the horizontal (x-direction) bonds\n",
    "        # fSim[1] corresponds to the vertical (y-direction) bonds\n",
    "        # periodic BC are assumed\n",
    "        self.fSim = dict()\n",
    "        self.fSim[0] = []\n",
    "        self.fSim[1] = []\n",
    "        for j in range(self.Ly):\n",
    "            for i in range(self.Lx):\n",
    "                self.fSim[0].append(embedded_2q_gate(L=self.L,\n",
    "                                                     U=fSim_2q_gate(theta=self.theta,\n",
    "                                                                    phi=self.phi,\n",
    "                                                                    beta=self.beta),\n",
    "                                                     q1=self.Lx*j+i,\n",
    "                                                     q2=self.Lx*j+(i+1)%self.Lx\n",
    "                                                    )\n",
    "                                   )              \n",
    "        for j in range(self.Ly):\n",
    "            for i in range(self.Lx):\n",
    "                self.fSim[1].append(embedded_2q_gate(L=self.L,\n",
    "                                                     U=fSim_2q_gate(theta=self.theta,\n",
    "                                                                    phi=self.phi,\n",
    "                                                                    beta=self.beta\n",
    "                                                                   ),\n",
    "                                                     q1=self.Lx*j+i,\n",
    "                                                     q2=self.Lx*((j+1)%self.Ly) + i\n",
    "                                                    )\n",
    "                                   )\n",
    "\n",
    "        # constructing projector P\n",
    "        # it is assumed that P is acting on the first k qubits\n",
    "        # k depends on the projection dimension b\n",
    "        # for example, for b=1/2, k=1, while for b=1/4 (or b=3/4), k=2, etc.\n",
    "        data = [1 for i in range(int(self.b*2**self.L))]\n",
    "        row = [i for i in range(int(self.b*2**self.L))]\n",
    "        self.P = csr_matrix((data, (row, row)), shape=(2**self.L, 2**self.L), dtype=np.int8)\n",
    "\n",
    "\n",
    "    def generate_random_1q(self, q, qc_type):\n",
    "        \"\"\"\n",
    "        Generates a sparse CSR matrix of dim=2**L corresponding to a random single-qubit\n",
    "        gate acting on qubit with position q within the 1D chain of L qubits.\n",
    "        (Here 2D grid is transformed into a 1D chain layer by layer).\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        q : int\n",
    "        qc_type : str\n",
    "            Type of a random single-qubit gate.\n",
    "            Possible options: 'sqrt' -- square root of Paulis X, Y or their combinations W, V\n",
    "                              'XYZ' -- Paulis 1, X, Y, or Z\n",
    "                              'RZ' -- Pauli-Z rotation with a random angle\n",
    "        \"\"\"\n",
    "        if qc_type == 'sqrt':\n",
    "            rnd = random.choice([0, 1, 2, 3])\n",
    "            if rnd == 0:\n",
    "                random_1q = self.sqrtX[q]\n",
    "            if rnd == 1:\n",
    "                random_1q = self.sqrtY[q]\n",
    "            if rnd == 2:\n",
    "                random_1q = self.sqrtW[q]\n",
    "            if rnd == 3:\n",
    "                random_1q = self.sqrtV[q]\n",
    "\n",
    "        if qc_type == 'XYZ':\n",
    "            rnd = random.choice([0, 1, 2, 3])\n",
    "            if rnd == 0:\n",
    "                random_1q = identity(2**self.L, dtype='int8')\n",
    "            if rnd == 1:\n",
    "                random_1q = self.X[q]\n",
    "            if rnd == 2:\n",
    "                random_1q = self.Y[q]\n",
    "            if rnd == 3:\n",
    "                random_1q = self.Z[q]\n",
    "        \n",
    "        if qc_type == 'RZ':\n",
    "            angle_rnd = random.uniform(0, 2*np.pi)   \n",
    "            random_1q = embedded_1q_gate(\n",
    "                                    L=L,\n",
    "                                    U=sp.sparse.linalg.expm(-1j*angle_rnd/2*Z_1q),\n",
    "                                    q=q\n",
    "                                    )  \n",
    "        return random_1q\n",
    "\n",
    "    \n",
    "    def generate_Lambda_P_2D(self, depth, qc_type, BC='open'):\n",
    "        \"\"\"\n",
    "        Generates matrix \\Lambda_P=PU^{\\dag}PUP.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        depth : int\n",
    "            Depth (number of layers) of a 2D quantum circuit generating U.\n",
    "        qc_type : str\n",
    "            Type of two-qubit and single-qubit gates.\n",
    "            Possible options: 'clifford' -- random Clifford two-qubit gates, no single-qubit gates\n",
    "                              'no1q' -- fSim two-qubit gates, no single-qubit gates\n",
    "                              'sqrt' -- fSim two-qubit gates, \n",
    "                                        square root of Paulis X, Y or their combinations W, V for single-qubit gates\n",
    "                              'XYZ' -- fSim two-qubit gates,\n",
    "                                       Paulis 1, X, Y, or Z for single-qubit gates\n",
    "                              'RZ' -- fSim two-qubit gates,\n",
    "                                      Pauli-Z rotations with a random angle for single-qubit gates\n",
    "        BC : str\n",
    "            Boundary conditions for the 2D qubit grid.\n",
    "            Possible options: 'periodic', 'open'.\n",
    "\n",
    "        Returns\n",
    "        -------\n",
    "        Lambda_P : scipy.csr_matrix\n",
    "            Matrix Lambda_P.\n",
    "        \"\"\"        \n",
    "        A = self.P\n",
    "        for layer in range(depth):\n",
    "            if BC=='open':\n",
    "                if qc_type == 'clifford':\n",
    "                    if self.Lx%2 == 0:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx):\n",
    "                                if ix % 2 == 0:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+ix+1) @ A   \n",
    "                    if self.Lx%2 == 1:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx-1):\n",
    "                                if ix % 2 == 0:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+ix+1) @ A  \n",
    "\n",
    "                    if self.Lx%2 == 0:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx-1):\n",
    "                                if ix % 2 == 1:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+ix+1) @ A\n",
    "                    if self.Lx%2 == 1:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx):\n",
    "                                if ix % 2 == 1:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+ix+1) @ A\n",
    "\n",
    "                    if self.Ly%2 == 0:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly):\n",
    "                                if iy % 2 == 0:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*(iy+1) + ix) @ A \n",
    "                    if self.Ly%2 == 1:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly-1):\n",
    "                                if iy % 2 == 0:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*(iy+1) + ix) @ A \n",
    "\n",
    "                    if self.Ly%2 == 0:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly-1):\n",
    "                                if iy % 2 == 1:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*(iy+1) + ix) @ A  \n",
    "                    if self.Ly%2 == 1:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly):\n",
    "                                if iy % 2 == 1:\n",
    "                                    rng = np.random.default_rng()\n",
    "                                    U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                    A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*(iy+1) + ix) @ A \n",
    "                else:\n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    if self.Lx%2 == 0:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx):\n",
    "                                if ix % 2 == 0:\n",
    "                                    A = self.fSim[0][ix+self.Lx*iy] @ A   \n",
    "                    if self.Lx%2 == 1:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx-1):\n",
    "                                if ix % 2 == 0:\n",
    "                                    A = self.fSim[0][ix+self.Lx*iy] @ A  \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    if self.Lx%2 == 0:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx-1):\n",
    "                                if ix % 2 == 1:\n",
    "                                    A = self.fSim[0][ix+self.Lx*iy] @ A   \n",
    "                    if self.Lx%2 == 1:\n",
    "                        for iy in range(self.Ly):\n",
    "                            for ix in range(self.Lx):\n",
    "                                if ix % 2 == 1:\n",
    "                                    A = self.fSim[0][ix+self.Lx*iy] @ A  \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    if self.Ly%2 == 0:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly):\n",
    "                                if iy % 2 == 0:\n",
    "                                    A = self.fSim[1][ix+self.Lx*iy] @ A \n",
    "                    if self.Ly%2 == 1:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly-1):\n",
    "                                if iy % 2 == 0:\n",
    "                                    A = self.fSim[1][ix+self.Lx*iy] @ A \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    if self.Ly%2 == 0:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly-1):\n",
    "                                if iy % 2 == 1:\n",
    "                                    A = self.fSim[1][ix+self.Lx*iy] @ A \n",
    "                    if self.Ly%2 == 1:\n",
    "                        for ix in range(self.Lx):\n",
    "                            for iy in range(self.Ly):\n",
    "                                if iy % 2 == 1:\n",
    "                                    A = self.fSim[1][ix+self.Lx*iy] @ A            \n",
    "            if BC=='periodic':\n",
    "                if qc_type == 'clifford':\n",
    "                    for iy in range(self.Ly):\n",
    "                        for ix in range(self.Lx):\n",
    "                            if ix % 2 == 0:\n",
    "                                rng = np.random.default_rng()\n",
    "                                U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+(ix+1)%self.Lx) @ A\n",
    "                    for iy in range(self.Ly):\n",
    "                        for ix in range(self.Lx):\n",
    "                            if ix % 2 == 1:\n",
    "                                rng = np.random.default_rng()\n",
    "                                U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*iy+(ix+1)%self.Lx) @ A                                \n",
    "                    for ix in range(self.Lx):\n",
    "                        for iy in range(self.Ly):\n",
    "                            if iy % 2 == 0:\n",
    "                                rng = np.random.default_rng()\n",
    "                                U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*((iy+1)%self.Ly) + ix) @ A \n",
    "                    for ix in range(self.Lx):\n",
    "                        for iy in range(self.Ly):\n",
    "                            if iy % 2 == 1:\n",
    "                                rng = np.random.default_rng()\n",
    "                                U = random_clifford(num_qubits=2,seed=rng).to_operator().data\n",
    "                                A = embedded_2q_gate(L=self.L,U=U,q1=self.Lx*iy+ix,q2=self.Lx*((iy+1)%self.Ly) + ix) @ A \n",
    "                else:\n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    for iy in range(self.Ly):\n",
    "                        for ix in range(self.Lx):\n",
    "                            if ix % 2 == 0:\n",
    "                                A = self.fSim[0][ix+self.Lx*iy] @ A \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    for iy in range(self.Ly):\n",
    "                        for ix in range(self.Lx):\n",
    "                            if ix % 2 == 1:\n",
    "                                A = self.fSim[0][ix+self.Lx*iy] @ A  \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    for ix in range(self.Lx):\n",
    "                        for iy in range(self.Ly):\n",
    "                            if iy % 2 == 0:\n",
    "                                A = self.fSim[1][ix+self.Lx*iy] @ A   \n",
    "                    if qc_type != 'no1q':\n",
    "                        for i in range(self.L): \n",
    "                            A = self.generate_random_1q(i,qc_type) @ A\n",
    "                    for ix in range(self.Lx):\n",
    "                        for iy in range(self.Ly):\n",
    "                            if iy % 2 == 1:\n",
    "                                A = self.fSim[1][ix+self.Lx*iy] @ A\n",
    "        Lambda_P = csr_matrix.transpose(csr_matrix.conjugate(A)) @ self.P @ A\n",
    "        \n",
    "        return Lambda_P\n",
    "\n",
    "    \n",
    "    def calculate_spectrum(self,depth,qc_type,BC,runs):\n",
    "        \"\"\"\n",
    "        Generates matrix Lambda_P and calculates its eigenvalues.\n",
    "\n",
    "        Parameters\n",
    "        ----------\n",
    "        runs : int\n",
    "            Number of random-matrix realizations over which the averaging is performed.\n",
    "        \"\"\"\n",
    "        eigenvals = []\n",
    "        for i in range(runs):\n",
    "            W = self.generate_Lambda_P_2D(depth=depth,qc_type=qc_type,BC=BC)\n",
    "            eigenvals.append( np.linalg.eigvals(W.toarray()) )\n",
    "        self.eigenvals = np.ndarray.flatten(np.real(eigenvals))\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83615f64-c6e6-4c37-a99f-0e0d719f3b10",
   "metadata": {},
   "source": [
    "## Results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a6c734f3-02e4-4fda-bddb-0d4a979dd3d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.64 s, sys: 216 ms, total: 4.85 s\n",
      "Wall time: 4.84 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "Lx = 3\n",
    "Ly = 3\n",
    "b = 1/4\n",
    "depth = 10\n",
    "qc_type = 'sqrt'\n",
    "BC = 'open'\n",
    "runs = 20\n",
    "theta = np.pi/6\n",
    "phi = 2*np.pi/3\n",
    "# theta = np.pi/4\n",
    "# phi = 0.0\n",
    "\n",
    "Lambda_P = simulation_2D(\n",
    "                Lx=Lx,\n",
    "                Ly=Ly,\n",
    "                b=b,\n",
    "                theta=theta,\n",
    "                phi=phi,\n",
    "                beta=0.0\n",
    "            )\n",
    "\n",
    "Lambda_P.calculate_spectrum(\n",
    "    depth=depth, \n",
    "    qc_type=qc_type, \n",
    "    BC=BC, \n",
    "    runs=runs\n",
    ")\n",
    "    \n",
    "eigenvals_2D = Lambda_P.eigenvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f3222f5d-8ef7-4734-8bdd-80219d6d8b4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "modes_one = round(len([i for i in eigenvals_2D if 0.99<i<1.01])/2**(Lx*Ly),2)/2000\n",
    "plt.hist(eigenvals_2D,\n",
    "         bins=np.linspace(0,1,100),\n",
    "         weights=np.ones_like(eigenvals_2D)/2000,\n",
    "         label='2D, depth=%s, 100 disorder realizations\\n# of modes with $0.99<\\lambda<1.01$ is %s*$2^(Lx*Ly)$' % (depth, modes_one)\n",
    "        )\n",
    "plt.ylim(0,0.1)\n",
    "plt.title('Eigenvalue distribution, Lx=%s, Ly=%s, b=%s' % (Lx,Ly,b))\n",
    "plt.legend()\n",
    "plt.xlabel(r'$\\lambda$')\n",
    "plt.ylabel(r'$P(\\lambda)$')\n",
    "# plt.savefig('depth=%s, b=%s.png' % (depth, b))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f739feef-eb6f-4326-b0da-e6db9aaed4aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.31 s, sys: 187 ms, total: 1.49 s\n",
      "Wall time: 1.4 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "Lx = 3\n",
    "Ly = 3\n",
    "b = 1/4\n",
    "depth = 2\n",
    "qc_type = 'sqrt'\n",
    "BC = 'open'\n",
    "runs = 20\n",
    "theta = np.pi/6\n",
    "phi = 2*np.pi/3\n",
    "# theta = np.pi/4\n",
    "# phi = 0.0\n",
    "\n",
    "Lambda_P = simulation_2D(\n",
    "                Lx=Lx,\n",
    "                Ly=Ly,\n",
    "                b=b,\n",
    "                theta=theta,\n",
    "                phi=phi,\n",
    "                beta=0.0\n",
    "            )\n",
    "\n",
    "Lambda_P.calculate_spectrum(\n",
    "    depth=depth, \n",
    "    qc_type=qc_type, \n",
    "    BC=BC, \n",
    "    runs=runs\n",
    ")\n",
    "    \n",
    "eigenvals_2D = Lambda_P.eigenvals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8cd01ca2-f447-4e9c-9955-7b83eddb10be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "modes_one = round(len([i for i in eigenvals_2D if 0.99<i<1.01])/2**(Lx*Ly),2)/2000\n",
    "plt.hist(eigenvals_2D,\n",
    "         bins=np.linspace(0,1,100),\n",
    "         weights=np.ones_like(eigenvals_2D)/2000,\n",
    "         label='2D, depth=%s, 100 disorder realizations\\n# of modes with $0.99<\\lambda<1.01$ is %s*$2^(Lx*Ly)$' % (depth, modes_one)\n",
    "        )\n",
    "plt.ylim(0,0.1)\n",
    "plt.title('Eigenvalue distribution, Lx=%s, Ly=%s, b=%s' % (Lx,Ly,b))\n",
    "plt.legend()\n",
    "plt.xlabel(r'$\\lambda$')\n",
    "plt.ylabel(r'$P(\\lambda)$')\n",
    "# plt.savefig('depth=%s, b=%s.png' % (depth, b))\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4aa5d1df-0468-43f0-96e9-8032a70f123f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}