Cp/qml basis (#3895)

Fixes #3805 . Corrects some descriptions of basis encoding in QML.

---------

Co-authored-by: abbycross <[email protected]>

Author: christopherporter1

learning/courses/quantum-machine-learning/data-encoding.ipynb

@@ -107,26 +107,29 @@
     "\n",
     "Basis encoding encodes a classical $P$-bit string into a computational basis state of a $P$-qubit system. Take for example $\\vec{x}^{(1)}_3 = 5 = 0(2^3)+1(2^2)+0(2^1)+1(2^0).$ This can be represented as a $4$-bit string as $(0101)$, and by a $4$-qubit system as the quantum state $|0101\\rangle$. More generally, for a $P$-bit string: $\\vec{x}^{(j)}_k = (b_1, b_2, ... , b_P)$, the corresponding $P$-qubit state is $|x^{(j)}_k\\rangle = | b_1, b_2, ... , b_P \\rangle$ with $b_n \\in \\{0,1\\}$ for $n = 1 , \\dots , P$. Note that this is just for a single feature.\n",
     "\n",
-    "If each feature of this data vector is mapped to a quantum state $|x^{(j)}_k\\rangle$, then we can describe a data vector from our set as a superposition of all the computational basis states describing the features of that vector:\n",
+    "Basis encoding in quantum computing represents each classical bit as a separate qubit, mapping the binary representation of data directly onto quantum states in the computational basis. When multiple features need to be encoded, each feature is first converted to its binary form and then assigned to a distinct group of qubits — one group per feature — where each qubit reflects a bit in the binary representation of that feature.\n",
     "\n",
-    "$$\n",
-    "|x^{(j)} \\rangle = \\frac{1}{\\sqrt{N}}\\sum_{k=1}^{N}|x^{(j)}_k \\rangle\n",
-    "$$\n",
+    "As an example, let us encode the vector (5, 7, 0).\n",
+    "\n",
+    "Suppose all features are stored in four bits (more than we need, but enough to represent any integer that is single-digit in base 10):\n",
     "\n",
-    "In Qiskit, once we calculate what state will encode our data point, we can use the `initialize` function to prepare it. Consider the 4th data vector in our dataset $\\vec{x}^{(4)} = (5,7,0)$. We have $x^{(4)}_1=101, x^{(4)}_2=111$, and $x^{(4)}_3 = 000$. This is encoded as the state $|x^{(4)}\\rangle= \\frac{1}{\\sqrt{3}}(|101\\rangle+|111\\rangle+|000\\rangle)$.\n",
+    "    5 → binary 0101\n",
     "\n",
-    "We can generate a circuit that will prepare this state using `initialize`. For this specific case, we will use three qubits. The space of all $2^3$ measurable states of these three qubits is spanned by\n",
+    "    7 → binary 0111\n",
     "\n",
+    "    0 → binary 0000\n",
+    "\n",
+    "These bit strings are assigned to three sets of four qubits, so the overall 12-qubit basis state is:\n",
     "$$\n",
-    "\\vert 000\\rangle, \\vert 001\\rangle, \\vert 010\\rangle, \\vert 011\\rangle, \\vert 100\\rangle, \\vert 101\\rangle, \\vert 110\\rangle, \\vert 111\\rangle\n",
+    "∣0101 0111 0000⟩\n",
     "$$\n",
     "\n",
-    "When specifying the desired state of our 3-qubit system, we specify the amplitude of each of these $2^3$ basis states, in this order. Thus, our desired state will have $1 /\\sqrt{3}$ in the $1^\\text{st}$, $6^\\text{th}$, and $8^\\text{th}$ entries, and zeros everywhere else."
+    "Here, the first four qubits represent the first feature, the next four qubits the second feature, and the last four qubits the third feature. The code below converts the data vector (5,7,0) to a quantum state, and is generalized to do so for other single-digit features."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 1,
    "id": "85ee995f-1e50-4860-a24c-16bbc8b5c8b0",
    "metadata": {},
    "outputs": [
@@ -136,29 +139,36 @@
        "<Image src=\"/learning/images/courses/quantum-machine-learning/data-encoding/extracted-outputs/85ee995f-1e50-4860-a24c-16bbc8b5c8b0-0.avif\" alt=\"Output of the previous code cell\" />"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "import math\n",
-    "import numpy as np\n",
     "from qiskit import QuantumCircuit\n",
     "\n",
-    "desired_state = [1 / math.sqrt(3), 0, 0, 0, 0, 1 / math.sqrt(3), 0, 1 / math.sqrt(3)]\n",
+    "# Data point to encode\n",
+    "x = 5  # binary: 0101\n",
+    "y = 7  # binary: 0111\n",
+    "z = 0  # binary: 0000\n",
     "\n",
-    "qc = QuantumCircuit(3)\n",
-    "qc.initialize(desired_state, [0, 1, 2])\n",
-    "qc.decompose(reps=8).draw(output=\"mpl\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b96f0bfc-a892-4f68-84a6-1859381f099d",
-   "metadata": {},
-   "source": [
-    "This example illustrates a couple of disadvantages of basis encoding. While it is simple to understand, the state vectors can become quite sparse, and schemes to implement it are usually not efficient."
+    "# Convert each to 4-bit binary list\n",
+    "x_bits = [int(b) for b in format(x, \"04b\")]  # [0,1,0,1]\n",
+    "y_bits = [int(b) for b in format(y, \"04b\")]  # [0,1,1,1]\n",
+    "z_bits = [int(b) for b in format(z, \"04b\")]  # [0,0,0,0]\n",
+    "\n",
+    "# Combine all bits\n",
+    "all_bits = x_bits + y_bits + z_bits  # [0,1,0,1,0,1,1,1,0,0,0,0]\n",
+    "\n",
+    "# Initialize a 12-qubit quantum circuit\n",
+    "qc = QuantumCircuit(12)\n",
+    "\n",
+    "# Apply x-gates where the bit is 1\n",
+    "for idx, bit in enumerate(all_bits):\n",
+    "    if bit == 1:\n",
+    "        qc.x(idx)\n",
+    "\n",
+    "qc.draw(\"mpl\")"
    ]
   },
   {
@@ -187,35 +197,29 @@
     "import math\n",
     "from qiskit import QuantumCircuit\n",
     "\n",
-    "desired_state = [\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    1 / math.sqrt(3),\n",
-    "    1 / math.sqrt(3),\n",
-    "    0,\n",
-    "    0,\n",
-    "    1 / math.sqrt(3),\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "    0,\n",
-    "]\n",
+    "# Data point to encode\n",
+    "x = 4  # binary: 0100\n",
+    "y = 8  # binary: 1000\n",
+    "z = 5  # binary: 0101\n",
     "\n",
-    "print(desired_state)\n",
+    "# Convert each to 4-bit binary list\n",
+    "x_bits = [int(b) for b in format(x, '04b')]  # [0,1,0,0]\n",
+    "y_bits = [int(b) for b in format(y, '04b')]  # [1,0,0,0]\n",
+    "z_bits = [int(b) for b in format(z, '04b')]  # [0,1,0,1]\n",
     "\n",
-    "qc = QuantumCircuit(4)\n",
-    "qc.initialize(desired_state, [0, 1, 2, 3])\n",
-    "qc.decompose(reps=7).draw(output=\"mpl\")\n",
-    "```\n",
+    "# Combine all bits\n",
+    "all_bits = x_bits + y_bits + z_bits  # [0,1,0,0,1,0,0,0,0,1,0,1]\n",
     "\n",
-    "[0, 0, 0, 0, 0.5773502691896258, 0.5773502691896258, 0, 0, 0.5773502691896258, 0, 0, 0, 0, 0, 0, 0]\n",
+    "# Initialize a 12-qubit quantum circuit\n",
+    "qc = QuantumCircuit(12)\n",
     "\n",
-    "![\"Output of the previous code cell\"](/learning/images/courses/quantum-machine-learning/data-encoding/checkin1.avif)\n",
+    "# Apply x-gates where the bit is 1\n",
+    "for idx, bit in enumerate(all_bits):\n",
+    "    if bit == 1:\n",
+    "        qc.x(idx)\n",
+    "\n",
+    "qc.draw('mpl')\n",
+    "```\n",
     "\n",
     "</details>"
    ]
@@ -269,7 +273,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "id": "19810c6d-8d60-49ee-bd6f-6f6fbd5e7363",
    "metadata": {},
    "outputs": [
@@ -285,6 +289,8 @@
     }
    ],
    "source": [
+    "import math\n",
+    "\n",
     "desired_state = [\n",
     "    1 / math.sqrt(105) * 4,\n",
     "    1 / math.sqrt(105) * 8,\n",
@@ -521,7 +527,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "id": "666700f7-7798-43ce-a8ca-d91e48adda4f",
    "metadata": {},
    "outputs": [
@@ -536,6 +542,7 @@
     }
    ],
    "source": [
+    "import numpy as np\n",
     "from qiskit.visualization.bloch import Bloch\n",
     "from qiskit.visualization.state_visualization import _bloch_multivector_data\n",
     "\n",