[Feature]: cluster states from undirected graph states

[Fe-r-oz]

Is your feature request related to a problem? Please describe.

Why use cluster states? The primary hurdle to achieving practical quantum computation is scaling, a difficulty significantly exacerbated by the substantial overhead required for quantum error correction. This paper Fault-tolerant qubit from a constant number of components suggests a fault-tolerant quantum computing method that can be constructed from a minimal set of experimental components, potentially simplifying the engineering complexities involved in creating a large-scale fault-tolerant quantum computer. It involves fault-tolerantly generating $3D$ cluster states from bcc lattice (see algorithm 2, protocol A and B of paper using a single actively controlled qubit and two delay lines.

The cluster state $\ket{\psi_G}$ corresponding to an undirected graph $G = (V, E)$ is defined as [1]

$$\begin{equation} \ket{\psi_G} := \left[\prod_{(i,j) \in E} Z_{i,j}\right] \bigotimes_{i' \in V} \ket{+}_{i'}, \end{equation}$$

where each vertex $i \in V$ is identified with a qubit, and $Z_{a,b}$ denotes the controlled-Z gate on qubits $a$ and $b$. The stabilizers of $\ket{\psi_G}$ are generated by ${S_i : i \in V}$, [2] where $X_{a}$ and $Z_{a}$ denote Pauli $X$ and $Z$ on qubit $a$.

$$\begin{equation} S_i := X_i \prod_{j : (i,j) \in E} Z_j. \end{equation}$$

Describe the solution you’d like
To start with, please check out the implementation of graph stabilizer states and its plotting methods --graph stabilizer states

Then, Implement the following algorithm $1$ from this paper Fault-tolerant qubit from a constant number of components. In summary, algorithm $1$ creates progressively larger cluster states associated with the subgraphs of $G = (V, E)$ by incorporating one qubit at a time. To elaborate, let $n := |V|$ represent the total number of data qubits, and establish a sequence for the qubits by labeling them from $1$ to $n$. According to this sequence, the qubit labeled $1$ is added initially, then the qubit labeled $2$, and this process continues sequentially.

Algorithm $1$: Prepare the cluster state $\ket{\psi_G}$ given a graph $G = (V, E)$ with $V = [n]$. (page $5$ of the paper)

Describe alternatives you’ve considered

The traditional method for creating cluster states involves initializing each qubit in the $\ket{+}$ state and applying controlled $Z$ gates as specified in first equation. Since a controlled $Z$ gate is needed for every pair of qubits $(a, b)$ in $E$, this method requires $|E|$ distinct gates. Each of these gates must be precisely calibrated and implemented, making the experimental execution of this protocol quite challenging.

In contrast, algorithm $1$ and algorithm $2$ protocols $A$, $B$ eliminate the need to calibrate and implement numerous distinct operations, allowing for simpler experimental implementations. Their algorithm uses a single ancilla qubit $Q$ that interacts sequentially with the data qubits, which correspond to the vertices $V$ of $G$. The ancilla $Q$ is actively controlled, while the data qubits passively interact with $Q$. The data qubits do not need to interact with each other. Thus, one can simply adjust a constant number of interactions between the controllable qubit and the physical system representing the data qubits to calibrate all gates.

Important thing to consider is to also plot these states given the pkgs used to plot graph stabilizer states.

Additional context

The paper mentioned above uses the already established bcc lattice from this paper A fault-tolerant one-way quantum computer, and describes two protocols $A$, $B$ to make cluster states from it. This is described as Algorithm $2$. Please see the appendix section 2, page 23 which has describes correctness of algorithms which can be useful when implementing correctness tests.

[Fe-r-oz]

Check out the python source code of the aforementioned paper: https://github.com/noajshu/clusterstates