random_controlled_unitaries.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "07224e3a-0e51-4de3-9e18-7792855f3dcc",
   "metadata": {},
   "source": [
    "# Random Controlled Unitaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d117f7f1-3129-42af-bfe7-321f942ce292",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───@───────────────────────────────H───\n",
      "          │\n",
      "          ┌                           ┐\n",
      "1: ───────│ 0.297+0.229j -0.86 +0.345j│───────\n",
      "          │-0.455+0.808j  0.189+0.324j│\n",
      "          └                           ┘\n",
      "Control qubit in |0> state:\n",
      "measurements: (no measurements)\n",
      "\n",
      "qubits: (cirq.LineQubit(0), cirq.LineQubit(1))\n",
      "output vector: (0.648+0.115j)|00⟩ + (-0.227+0.404j)|01⟩ + (0.352-0.115j)|10⟩ + (0.227-0.404j)|11⟩\n",
      "\n",
      "phase:\n",
      "output vector: |⟩\n",
      "Control qubit in |1> state:\n",
      "measurements: (no measurements)\n",
      "\n",
      "qubits: (cirq.LineQubit(0), cirq.LineQubit(1))\n",
      "output vector: (-0.43+0.172j)|00⟩ + (0.594+0.162j)|01⟩ + (0.43-0.172j)|10⟩ + (0.406-0.162j)|11⟩\n",
      "\n",
      "phase:\n",
      "output vector: |⟩\n"
     ]
    }
   ],
   "source": [
    "import cirq\n",
    "import numpy as np\n",
    "from scipy.stats import unitary_group\n",
    "\n",
    "# Define a random unitary matrix\n",
    "random_unitary = unitary_group.rvs(2)\n",
    "\n",
    "# Define the circuit with two qubits\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "circuit = cirq.Circuit()\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Apply a controlled-unitary gate\n",
    "circuit.append(cirq.ControlledGate(cirq.MatrixGate(random_unitary)).on(q0, q1))\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit again\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Display the circuit\n",
    "print(circuit)\n",
    "\n",
    "# Simulate the circuit for both control qubit states\n",
    "simulator = cirq.Simulator()\n",
    "result = simulator.simulate(circuit, qubit_order=[q0, q1])\n",
    "\n",
    "print(f\"Control qubit in |0> state:\\n{result}\")\n",
    "print(f\"Control qubit in |1> state:\\n{simulator.simulate(circuit, initial_state=1, qubit_order=[q0, q1])}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef2ff41-75b9-44bd-9052-9ab8da95fc31",
   "metadata": {},
   "source": [
    "We should be able to generalize random controlled unitaries to the case with a control qubit and a target qudit of dimension `n`. Random controlled unitaries allow for modelling more general forms of entanglement than just the standard `CNOT` (or its generalization the `CSHIFT`) gate, or the `CZ` (or its generalization the `CPHASE`) gate. More general forms of entanglement allow us to model perterbations and errors in surface codes and their generalizations. \n",
    "\n",
    "We can calculate distance between a random `CU` and the `CX` gate in the operator norm. Once we have a distance, we can construct edge weights in something like an interaction graph as the reciprocal of the distance. This means interactions are \"stronger\" when they are closer to a `CX` entangling gate. Note, we could also use `CZ` or some other controlled-gate as our reference. Using this, we can develop different models of entanglement and we may find that custom AI-designed CU gates that are built specifically for certain hardware backends are better for performing quantum computation. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7f04a963-30bc-4cfe-9362-d95eaf2f2bdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0: ───H───@───────────────────────────────H───\n",
      "          │\n",
      "          ┌                           ┐\n",
      "1: ───────│ 0.987+0.016j -0.128-0.091j│───────\n",
      "          │-0.156-0.022j -0.726-0.67j │\n",
      "          └                           ┘\n",
      "Distance between the random controlled unitary gate and the CNOT gate: 1.9038557282437243\n"
     ]
    }
   ],
   "source": [
    "import cirq\n",
    "import numpy as np\n",
    "from scipy.stats import unitary_group\n",
    "\n",
    "# Define a random unitary matrix\n",
    "random_unitary = unitary_group.rvs(2)\n",
    "\n",
    "# Define the circuit with two qubits\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "circuit = cirq.Circuit()\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Apply a controlled-unitary gate\n",
    "circuit.append(cirq.ControlledGate(cirq.MatrixGate(random_unitary)).on(q0, q1))\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit again\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Display the circuit\n",
    "print(circuit)\n",
    "\n",
    "# Calculate the matrix representation of the CNOT gate\n",
    "cnot_matrix = np.array([[1, 0, 0, 0],\n",
    "                        [0, 1, 0, 0],\n",
    "                        [0, 0, 0, 1],\n",
    "                        [0, 0, 1, 0]])\n",
    "\n",
    "# Calculate the matrix representation of the random controlled unitary gate\n",
    "cu_matrix = cirq.unitary(circuit)\n",
    "\n",
    "# Calculate the difference matrix\n",
    "diff_matrix = cu_matrix - cnot_matrix\n",
    "\n",
    "# Calculate the operator norm of the difference matrix\n",
    "distance = np.linalg.norm(diff_matrix, ord=2)\n",
    "\n",
    "print(f\"Distance between the random controlled unitary gate and the CNOT gate: {distance}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d761cf23-17ca-4b2e-930f-cdcbef8b9935",
   "metadata": {},
   "source": [
    "We now want to constuct an interaction graph with an edge weight corresponding to `1/distance`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "67b2efe0-5812-470d-bcd4-edf504fbf596",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Adjacency matrix for the interaction graph:\n",
      "[[0.         0.51069633]\n",
      " [0.51069633 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "import cirq\n",
    "import numpy as np\n",
    "from scipy.stats import unitary_group\n",
    "\n",
    "# Define a random unitary matrix\n",
    "random_unitary = unitary_group.rvs(2)\n",
    "\n",
    "# Define the circuit with two qubits\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "circuit = cirq.Circuit()\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Apply a controlled-unitary gate\n",
    "circuit.append(cirq.ControlledGate(cirq.MatrixGate(random_unitary)).on(q0, q1))\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit again\n",
    "circuit.append(cirq.H(q0))\n",
    "\n",
    "# Calculate the matrix representation of the CNOT gate\n",
    "cnot_matrix = np.array([[1, 0, 0, 0],\n",
    "                        [0, 1, 0, 0],\n",
    "                        [0, 0, 0, 1],\n",
    "                        [0, 0, 1, 0]])\n",
    "\n",
    "# Calculate the matrix representation of the random controlled unitary gate\n",
    "cu_matrix = cirq.unitary(circuit)\n",
    "\n",
    "# Calculate the distance between the random controlled unitary gate and the CNOT gate\n",
    "distance = np.linalg.norm(cu_matrix - cnot_matrix, ord=2)\n",
    "\n",
    "# Construct the adjacency matrix for the interaction graph\n",
    "adjacency_matrix = np.zeros((2, 2))\n",
    "if distance != 0:\n",
    "    adjacency_matrix[0, 1] = 1 / distance\n",
    "    adjacency_matrix[1, 0] = 1 / distance\n",
    "\n",
    "print(f\"Adjacency matrix for the interaction graph:\\n{adjacency_matrix}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d2d75f-dd0f-4dc4-8367-541073bae01e",
   "metadata": {},
   "source": [
    "Here's another example with the weighted interaction graph visualized. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0d562a99-8ac6-488e-a63a-9588f25eb413",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import cirq\n",
    "import numpy as np\n",
    "from scipy.stats import unitary_group\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Define a random unitary matrix\n",
    "random_unitary = unitary_group.rvs(2)\n",
    "\n",
    "# Define the circuit with two qubits\n",
    "q0, q1 = cirq.LineQubit.range(2)\n",
    "circuit = cirq.Circuit()\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit\n",
    "# circuit.append(cirq.H(q0))\n",
    "\n",
    "# Apply a controlled-unitary gate\n",
    "circuit.append(cirq.ControlledGate(cirq.MatrixGate(random_unitary)).on(q0, q1))\n",
    "\n",
    "# Apply a Hadamard gate to the control qubit again\n",
    "# circuit.append(cirq.H(q0))\n",
    "\n",
    "# Calculate the matrix representation of the CNOT gate\n",
    "cnot_matrix = np.array([[1, 0, 0, 0],\n",
    "                        [0, 1, 0, 0],\n",
    "                        [0, 0, 0, 1],\n",
    "                        [0, 0, 1, 0]])\n",
    "\n",
    "# Calculate the matrix representation of the random controlled unitary gate\n",
    "cu_matrix = cirq.unitary(circuit)\n",
    "\n",
    "# Calculate the distance between the random controlled unitary gate and the CNOT gate\n",
    "distance = np.linalg.norm(cu_matrix - cnot_matrix, ord=2)\n",
    "\n",
    "# Construct the adjacency matrix for the interaction graph\n",
    "adjacency_matrix = np.zeros((2, 2))\n",
    "if distance != 0:\n",
    "    adjacency_matrix[0, 1] = 1 / distance\n",
    "    adjacency_matrix[1, 0] = 1 / distance\n",
    "\n",
    "# Create the graph\n",
    "G = nx.Graph()\n",
    "\n",
    "# Add nodes\n",
    "G.add_nodes_from([0, 1])\n",
    "\n",
    "# Add edges\n",
    "for i in range(adjacency_matrix.shape[0]):\n",
    "    for j in range(adjacency_matrix.shape[1]):\n",
    "        if adjacency_matrix[i, j] != 0:\n",
    "            G.add_edge(i, j, weight=adjacency_matrix[i, j])\n",
    "\n",
    "# Draw the graph\n",
    "pos = nx.spring_layout(G)\n",
    "nx.draw(G, pos, with_labels=True)\n",
    "labels = nx.get_edge_attributes(G, 'weight')\n",
    "nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d0edeeb-5331-427a-841a-9cf0d8c36b02",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit ('anaconda3': virtualenv)",
   "language": "python",
   "name": "python385jvsc74a57bd0474c67ce7e36ad5731492349411c4ce02ca5c170a680b2d1efe1eb0325e35fe7"
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}