feat: ✨ add Bernstein-Vazirani algorithm explanation, implementation details, and example code

Author: gracefullight

blog/2026/03/30/iqc-006.md

@@ -274,3 +274,179 @@ measure q[n-1] -> c[n-1];
 ```
 
 ## Bernstein-Vazirani Algorithm
+
+- Given $f_s: \{0,1\}^n \to \{0,1\}$ defined as $f_s(x) = s \cdot x \mod 2$
+  - where $s$ is an unknown $n$-bit string and $x$ is the input.
+- The goal is to determine the hidden string $s$ as few queries as possible.
+- Classically: query $f$ with input $e_0 = 00 \cdots 01$, $e_1 = 00 \cdots 10$, ..., $e_{n-1} = 10 \cdots 00$ to get each bit of $s$.
+  - Total $n$ queries.
+- Quantum: use the exact same circuit as Deutsch-Jozsa.
+  - $U_{f_s} \ket{x} = (-1)^{s \cdot x} \ket{x}$.
+    - where we can ignore the output register in the $\ket{-}$ state.
+    - For $n =1$, the state after the oracle before the final $H$ gate is:
+      - $\frac{1}{\sqrt{2}} \left( \ket{0} + (-1)^{s} \ket{1} \right)$
+    - which is $\ket{+}$ if $s=0$ and $\ket{-}$ if $s=1$.
+  - Applying $H$ to this state returns $s$:
+    - $H \frac{1}{\sqrt{2}} \left( \ket{0} + (-1)^{s} \ket{1} \right) = \ket{s}$.
+  - The measurement deterministically reveals $s$.
+
+### n=2 case
+
+- $s = s_1s_0$ and $x = x_1 x_0$
+- $\rightarrow s\cdot x = s_1x_1 + s_0 x_0$
+
+$$ \begin{array}{rrrr}
+\frac{1}{2}\big(&(-1) ^{s_0\cdot  0+s_1\cdot 0} \ket{00} + &(-1) ^{s_0\cdot  1+s_1\cdot 0} \ket{01}+&(-1) ^{s_0\cdot  0+s_1\cdot 1} \ket{10}+&(-1) ^{s_0\cdot 1+s_1\cdot 1} \ket{11}\big)\\
+=\frac1{2}\big(& \ket{00} + &(-1) ^{s_0} \ket{01}+&(-1) ^{s_1} \ket{10}+&(-1) ^{s_1+s_0} \ket{11}\big).
+\end{array}
+$$
+
+this factorized into:
+
+$$\frac{1}{\sqrt{2}}\big(\ket 0 + (-1)^{s_1}\ket 1\big)\otimes \frac{1}{\sqrt{2}}\big(\ket 0 + (-1)^{s_0}\ket 1\big).$$
+
+this reduces the same agument as $n=1$ for each qubit where after the final $H$ gates, the state becomes:
+
+$$
+\ket{s_1}\otimes \ket {s_0} \equiv \ket{s_1 s_0}.
+$$
+
+### Implemnting Bernstein-Vazirani
+
+$$
+U_{f_s} \ket{x} \ket y  = \ket{x} \ket {y\oplus (s\cdot x)}
+$$
+
+$$
+y\oplus (s\cdot x) = y\oplus s_0 x_0 \oplus s_1 x_1 \oplus \cdots \oplus s_{n-1} x_{n-1}
+$$
+
+$$
+U_{f_s} \ket{x} \ket y  = \ket{x} \ket {y\oplus s x}
+$$
+
+- $\mathbb{I}$ if $s = 0$ and $CNOT$ if $s = 1$.
+- To implement $f_{s}(x) = s \cdot x$, we can use a CNOT from qubit $i$ to the scratch qubit if $s_i = 1$.
+
+```py
+import numpy as np
+from qiskit import QuantumCircuit, transpile
+from qiskit_aer import AerSimulator
+
+
+def bv_query(n, secret=None):
+    # Build oracle for f_s(x) = s · x
+    # q[0]..q[n-1] = input register
+    # q[n] = scratch/output qubit
+
+    if secret is None:
+        value = np.random.randint(0, 2 ** n)
+        secret = format(value, f"0{n}b")
+    else:
+        secret = secret.zfill(n)
+
+    oracle = QuantumCircuit(n + 1, name="Uf")
+    for index, bit in enumerate(reversed(secret)):
+        if bit == "1":
+            oracle.cx(index, n)
+
+    return oracle, secret
+
+
+def bernstein_vazirani_circuit(n, secret=None):
+    # Build full Bernstein-Vazirani circuit
+    oracle, secret = bv_query(n, secret)
+
+    qc = QuantumCircuit(n + 1, n)
+
+    # Prepare scratch qubit in |->
+    qc.x(n)
+
+    # Apply Hadamards to all qubits
+    for i in range(n + 1):
+        qc.h(i)
+
+    # Apply oracle
+    qc.compose(oracle, inplace=True)
+
+    # Apply final Hadamards to input register
+    for i in range(n):
+        qc.h(i)
+
+    # Measure input register
+    for i in range(n):
+        qc.measure(i, i)
+
+    return qc, secret
+
+
+def run_bernstein_vazirani(n, secret=None, shots=1):
+    qc, secret = bernstein_vazirani_circuit(n, secret)
+
+    simulator = AerSimulator()
+    compiled = transpile(qc, simulator)
+    result = simulator.run(compiled, shots=shots).result()
+    counts = result.get_counts()
+
+    measured = max(counts, key=counts.get)
+    recovered = measured[::-1]
+
+    return qc, secret, recovered, counts
+
+
+# Example
+qc, secret, recovered, counts = run_bernstein_vazirani(5, "01101")
+print(qc.draw())
+print("Secret   :", secret)
+print("Measured :", recovered)
+print("Counts   :", counts)
+```
+
+```qasm
+OPENQASM 2.0;
+qreg q[6];
+creg c[5];
+
+x q[5];
+h q[0];
+h q[1];
+h q[2];
+h q[3];
+h q[4];
+h q[5];
+
+cx q[0],q[5];
+cx q[2],q[5];
+cx q[3],q[5];
+
+h q[0];
+h q[1];
+h q[2];
+h q[3];
+h q[4];
+
+measure q[0] -> c[0];
+measure q[1] -> c[1];
+measure q[2] -> c[2];
+measure q[3] -> c[3];
+measure q[4] -> c[4];
+```
+
+## Summary
+
+- There are $2^{2^n}$ possible Boolean functions from $\{0,1\}^n$ to $\{0,1\}$.
+- A Boolean function is balanced if it outputs 1 on exactly half of the inputs, that is, on $2^{n-1}$ out of the $2^n$ possible inputs.
+- In Deutsch’s algorithm with $n=1$, only **1 quantum query** is needed to distinguish a constant function from a balanced function.
+- A quantum oracle for $f$ is defined as the unitary
+  $U_f:\ |x\rangle|y\rangle \mapsto |x\rangle|y\oplus f(x)\rangle.$
+- Every XOR-based function of the form $f(x)=x_j\oplus x_k\oplus\cdots$ that depends on at least one input bit is balanced.
+- Using multi-controlled $X$ gates, together with anti-controls when needed, we can implement an oracle for any Boolean function.
+- The phase kickback multiplies the state by the phase factor $(-1)^{f(x)}$, so the phase changes exactly when $f(x)=1$.
+- If these questions were stored in a Python list called `questions`, then the 8th question would be `questions[7]`.
+- Applying Hadamard gates to $n$ qubits initialized in $|0\rangle$ produces an equal superposition over all $2^n$ computational basis states.
+- In Deutsch–Jozsa for $n>1$, measuring all input qubits as 0 means that $f$ is constant.
+- Bernstein–Vazirani solves the hidden-string problem $f(x)=s\cdot x$ with **1 quantum query**.
+- A multi-controlled $X$ gate with 3 controls can be implemented using scratch qubits and **4 Toffoli gates**.
+- Applying $U_{f_1}$ followed by $U_{f_2}$ yields an oracle whose action on the scratch qubit corresponds to $f_1(x)\oplus f_2(x)$.
+- Uncomputation resets scratch qubits to their initial states by applying the inverse of the computation, which means reversing the order of the steps.
+- Multi-controlled gates with more than one control can be decomposed into simpler gates, but in general this requires more than just $CX$ and $X$; single-qubit gates are also needed.