Context aware quantum simulation of a matrix stored in quantum memory

TL;DR

This paper introduces a quantum circuit design for efficiently simulating block diagonal matrices stored in quantum memory, with applications in molecular Hamiltonian simulations and variational algorithms.

Contribution

It presents a novel context-aware quantum circuit for matrix simulation that requires linear gates and adapts to data, extending to real matrices and improving quantum simulation techniques.

Findings

Circuit requires O(n) quantum gates

Success probability depends on matrix size, being 1/poly(n) for poly(n) matrices

Applicable to variational quantum eigensolvers and molecular Hamiltonian simulations

Abstract

In this paper a storage method and a context-aware circuit simulation idea are presented for the sum of block diagonal matrices. Using the design technique for a generalized circuit for the Hamiltonian dynamics through the truncated series, we generalize the idea to (0-1) matrices and discuss the generalization for the real matrices. The presented circuit requires $O(n)$ number of quantum gates and yields the correct output with the success probability depending on the number of elements: for matrices with $poly(n)$, the success probability is $1/poly(n)$. Since the operations on the circuit are controlled by the data itself, the circuit can be considered as a context aware computing gadget. In addition, it can be used in variational quantum eigensolver and in the simulation of molecular Hamiltonians.

Equations

$$\mathcal{H}=\sum _i{Q}_i$$

$$|g_i⟩=\frac{1}{\eta }\sum _{k=0}^{K-1}|g_{ik}⟩|k⟩,$$

$$Q_i=\left(\begin{array}{ccc}Z& & \\ & X& \\ & & Zero\end{array}\right),$$

$$\begin{array}{r}|g_{i0}⟩=|1⟩,|g_{i1}⟩=|0⟩,\\ |g_{i2}⟩=\left(\begin{array}{c}0\\ ⋮\\ 0\end{array}\right),\text{ and }\eta =\frac{1}{\sqrt{2}}.\end{array}$$

$$\begin{split}\frac{1}{\eta\sqrt{8}}\left|000\right\rangle\sum_{j=0}^{N/2-1}\bigl{(}\beta_{2j}\left|\mathbf{j}\right\rangle_{k}\left|\mathbf{j}0\right\rangle_{system}\\ +\beta_{2j+1}\left|\mathbf{j}\right\rangle_{k}\left|\mathbf{j}1\right\rangle_{system}\bigr{)},\end{split}$$

$$|g⟩=\frac{1}{\zeta }\sum _{i,k}|i⟩|g_{ik}⟩|k⟩|\psi ⟩,$$

$$P_{success}={\Vert \frac{{\sum }_i{Q}_i|\psi ⟩}{C\zeta }\Vert }^2,$$

$$\mathcal{H}={\left(\begin{array}{cccc}{H}_{00}& H_{10}& H_{20}& H_{30}\\ H_{11}& H_{01}& H_{31}& H_{21}\\ H_{22}& H_{32}& H_{02}& H_{12}\\ H_{33}& H_{23}& H_{13}& H_{03}\end{array}\right)}_{8\times 8}.$$

$$\mathcal{H}=\sum _{i=0}^{N/2}{H}_i{P}_i.$$

$$P_i=\left(\underset{j=0}{\overset{n-1}{⨂}}{X}^{b_j}\right)\otimes I.$$

$$\begin{array}{rl}{G}_0=\left(\begin{array}{cc}1& 0\\ 0& 0\end{array}\right)& =\frac{I+Z}{2}\\ G_1=\left(\begin{array}{cc}0& 0\\ 1& 0\end{array}\right)& =\frac{X+XZ}{2}\\ G_2=\left(\begin{array}{cc}0& 1\\ 0& 0\end{array}\right)& =\frac{X+ZX}{2}\\ G_3=\left(\begin{array}{cc}0& 0\\ 0& 1\end{array}\right)& =\frac{I-Z}{2}\\ Zero=\left(\begin{array}{cc}0& 0\\ 0& 0\end{array}\right)& =Zero+Zero\end{array}$$

$$\mathcal{H}=\sum _{i=0}^{N/2-1}\left(Q_{ia}{P}_i+Q_{ib}{P}_i\right).$$

$$\mathcal{H}|\psi ⟩=\sum _{i=0}^{N/2-1}{H}_i{P}_i|\psi ⟩$$

$$P_{success}={\Vert \frac{{\sum }_i{Q}_i|\psi ⟩}{poly(n)}\Vert }^2.$$

$$\text{for }{H}_{ik}=\left(\begin{array}{cc}0& 1\\ 0& 0\end{array}\right),|g_{ik}⟩=\left(\begin{array}{c}0\\ 1\\ 0\\ 0\end{array}\right).$$

$$|g_{ik}⟩=\left(\begin{array}{c}{\alpha }_0\\ {\alpha }_1\\ {\alpha }_2\\ {\alpha }_3\end{array}\right),$$

$$⟨\psi (\theta )|\mathcal{H}|\psi (\theta )⟩=\sum _i⟨\psi (\theta )|c_i{H}_i{P}_i|\psi (\theta )⟩.$$

$$\left(\begin{array}{cccc}{I}^{\otimes 2n-2}\otimes X& & & \\ & I^{\otimes 2n-2}\otimes Z& & \\ & & \ddots & \\ & & & I^{\otimes 2n-2}\otimes I\end{array}\right)$$

$$\left(H^{\otimes 3}\otimes I^{\otimes 2n-1}\right)\left(\underset{j=0}{\overset{N/2}{⨁}}X\oplus \underset{j=0}{\overset{N/2}{⨁}}Z\oplus \underset{j=0}{\overset{N/2}{⨁}}-Z\oplus \cdots \underset{j=0}{\overset{N/2}{⨁}}I\right)$$

$$|g_{i0}⟩|0⟩=|1⟩|0⟩\text{ and }|g_{i1}⟩|1⟩=|3⟩|1⟩.$$

$$|g_i⟩|\psi ⟩=\frac{1}{\sqrt{2}}\left(|1⟩|0⟩|\psi ⟩+|3⟩|1⟩|\psi ⟩\right).$$

$$CG|g_i⟩|\psi ⟩=\frac{1}{\sqrt{2}}\left(|1⟩|0⟩(Z\otimes Z)|\psi ⟩+|3⟩|1⟩(XZ\otimes XZ)|\psi ⟩\right).$$

$$\small\begin{split}\frac{1}{4}\bigg{(}\big{(}\left|000\right\rangle-\left|001\right\rangle+\left|010\right\rangle-\left|011\right\rangle+\left|100\right\rangle-\left|101\right\rangle\\ +\left|110\right\rangle-\left|111\right\rangle\big{)}\left|0\right\rangle(Z\otimes Z)\left|\psi\right\rangle\\ +\big{(}\left|000\right\rangle-\left|001\right\rangle-\left|010\right\rangle+\left|011\right\rangle+\left|100\right\rangle-\left|101\right\rangle\\ -\left|110\right\rangle+\left|111\right\rangle\big{)}\left|1\right\rangle(XZ\otimes XZ)\left|\psi\right\rangle\bigg{)}.\end{split}$$

$$\small\frac{1}{4}\big{(}\left|000\right\rangle\left|0\right\rangle(Z\otimes Z)\left|\psi\right\rangle+\left|000\right\rangle\left|1\right\rangle(XZ\otimes XZ)\left|\psi\right\rangle\big{)}.$$

$$\{|000000⟩,|000001⟩,|000110⟩,|000111⟩\}.$$

$$\mathcal{H}={\left(\begin{array}{cccccccc}{H}_{00}& H_{10}& H_{20}& H_{30}& H_{40}& H_{50}& H_{60}& H_{70}\\ H_{11}& H_{01}& H_{31}& H_{21}& H_{51}& H_{41}& H_{71}& H_{61}\\ H_{22}& H_{32}& H_{02}& H_{12}& H_{62}& H_{72}& H_{42}& H_{52}\\ H_{33}& H_{23}& H_{13}& H_{03}& H_{73}& H_{63}& H_{53}& H_{43}\\ H_{44}& H_{54}& H_{64}& H_{70}& H_{04}& H_{14}& H_{24}& H_{34}\\ H_{55}& H_{45}& H_{75}& H_{61}& H_{15}& H_{05}& H_{35}& H_{25}\\ H_{66}& H_{76}& H_{46}& H_{52}& H_{26}& H_{36}& H_{06}& H_{16}\\ H_{77}& H_{67}& H_{57}& H_{43}& H_{37}& H_{27}& H_{17}& H_{07}\end{array}\right)}_{16\times 16}.$$

Full text

I Introduction

A quantum algorithm can be described through matrix-vector transformations. The number of two-and single-qubit quantum gates required to implement these transformations as a quantum circuit describes the computational complexity of the algorithm. It is known that an $N\times N$ matrix that depends on $N^{2}$ independent parameters requires $O(N^{2})$ quantum gates nielsen2010quantum . When the matrix is sparse with only $polylog(N)$ nonzero elements, then it is possible to design matrix specific quantum circuits with $polylog(N)$ quantum gates. The common circuit design approach is to write the matrix $\mathcal{H}$ as a sum $\sum_{j}H_{j}$, where $e^{iH_{j}t}$ should be easy to compute for any $H_{j}$, and approximate $exp(i\mathcal{H}t)$ by using the Trotter formula for the exponentiation: i.e. $(\prod_{j}exp(iH_{j}t/r)^{r}$. This idea is used in previous works such as childs2010simulating ; berry2017exponential to find the most efficient circuits for sparse matrices.

Solutions of many problems relate to finding the lowest (or highest) eigenvalue in magnitude and its associated eigenvector. This includes finding the ground state of the Hamiltonian of a quantum system in quantum chemistry kassal2011simulating ; olson2017quantum ; kais_book ; bian2019quantum ; xia2017electronic ; xia2018quantum . Recent methods such as variational quantum eigensolver peruzzo2014variational ; mcclean2016theory and quantum signal processing low2017optimal have proved that the exponential $e^{i\mathcal{H}t}$ is not needed to find the eigenpair of $\mathcal{H}$. For these methods, it is sufficient to find a direct circuit for $\mathcal{H}$ that can generate $\mathcal{H}\left|\psi\right\rangle$ for any quantum state $\left|\psi\right\rangle$ (example circuits daskin2012universal ; daskin2018direct ).

In this paper, we describe a storage method for (0-1) matrices on quantum memory and show an efficient circuit design that loads the data from quantum memory as a superpositioned state and generates the output $\mathcal{H}\left|\psi\right\rangle$ for any $\mathcal{H}$ by using quantum operations that are controlled by the data itself. When a system uses the context to provide relevant information, it may be considered as a context-aware system abowd1999towards . Therefore, we believe this work will pave the way for quantum context-aware computing. In terms of the computational complexity, the circuit uses only $O(n)$ number of quantum gates. The success probability of the method-as expected-scales with the number of elements and is $1/poly(n)$ for the matrices with $poly(n)$ number of nonzero elements.

This paper is organized as follows: We explain the approach for (0-1) block diagonal matrices in Sec.II. In Sec.III, we generalize the idea to matrices with (0-1) elements. In Sec.IV, we analyze the success probability and the storage complexity for sparse matrices with (0-1) elements. Sec.V briefly discusses how the idea generalizes to a matrix in real space, how the circuit can be used with variational quantum eigensolver.

II The approach for (0-1) block diagonal matrices

Assume that we want the circuit implementation of the following $N\times N$ matrix:

[TABLE]

where $Q_{i}$ is a block diagonal matrix defined as the direct sum of quantum gates: For instance, we will assume $Q_{i}=\bigoplus_{k}^{K}\sigma_{k}$ with $\sigma_{k}\in\{X,Z,-Z,XZ,ZX,-I,I,Zero\}$, here $Zero$ represents a 2x2 zero matrix and $\bigoplus$ is used for the direct sum of the matrices (It generates a block diagonal matrix.). We use a quantum state whose elements encode the gate information of the matrices on the diagonal:

[TABLE]

where $\eta$ is the normalization constant and $\left|g_{ik}\right\rangle$ is a vector of size 4 from the standard basis. As an example, if

[TABLE]

then

[TABLE]

Here, $\left|\mathbf{i}\right\rangle$ represents the $i$th vector in the standard basis. The zero vector for $\left|g_{i2}\right\rangle$ means that it is not included in the summation given in (2). Notice that $\left|g_{i}\right\rangle$ involves $n+2$ number of qubits: the last $n-1$ qubits indicate the value $k$ and the first three qubits are for the gate-type $g_{ik}$.

For an arbitrary given $n$-qubit state $\left|\psi\right\rangle$ and $\left|g_{i}\right\rangle$, consider the operation $\left|\beta\right\rangle=Q_{i}\left|\psi\right\rangle$. The circuit in Fig.1 can be used to produce $1/(\eta\sqrt{8})\left|\beta\right\rangle$ on the amplitudes of the following states (see Appendix A for the validation of the circuit):

[TABLE]

where $\left|\mathbf{j}\right\rangle$ represents the $j$th vector in the basis. The coefficient $1/(\eta\sqrt{8})$ comes from (2) and the three Hadamard gates used in the circuit. Therefore, the overall success probability is $||\left|\beta\right\rangle/1(\eta\sqrt{8})||^{2}$.

Now let us generalize this to $\sum_{i}Q_{i}\left|\psi\right\rangle$: First we add one more register to represent $\left|i\right\rangle$, then we give the following initial state to the circuit:

[TABLE]

where ${\zeta}$ is the normalization constant so that all the nonzero elements in $\left|i\right\rangle\left|g_{ik}\right\rangle\left|k\right\rangle$ are equal to $\frac{1}{\zeta}$. To get the sum, we apply Hadamard gates to the register representing $\left|i\right\rangle$. The resulting circuit is drawn in Fig.2 (see Appendix B for the validation). If $\left|g_{ik}\right\rangle$s are stored in the quantum memory, the circuit takes only $O(n)$ time. This complexity does not change much if we change the size of the basis to add more gates to the set. In this case, the size of the first register $\left|i\right\rangle$ determines the number of Hadamard gates and the success probability. We can define the success probability in this general case as:

[TABLE]

where $C$ is the coefficient determined by the number of Hadamard gates on the circuit. If the number of Hadamards is close to $n$, then we obtain $\approx\frac{1}{N}$ which is exponentially small in the number of qubits. However, in the sparse case one can expect the number of Hadamards to be much smaller than $n$ as shown in Sec.IV.

III General $\mathcal{H}$ with 0-1 elements

In daskin2018general , a method is presented to write a general matrix as a sum of unitary matrices. In this method, first without changing the location of any element, two indices $i$ and $k$ are assigned to all $2\times 2$ submatrices inside the matrix. For instance,

[TABLE]

Then for $i=0,\dots,N/2$, the block diagonal matrix $H_{i}=\bigoplus_{k=0}^{N/2}H_{ik}$ is constructed. Here, $H_{i}$ includes one submatrix from each row and $k$ corresponds to the row index of the submatrix (a larger matrix given in (26), notice the symmetries.). $\mathcal{H}$ is expressed as a sum of $H_{i}$s in the following form:

[TABLE]

Here $P_{i}$ is a permutation matrix described by using the binary form $i=(b_{0}...b_{n-1})_{2}$ as:

[TABLE]

That means an $X$ gate is put on qubit $j$ if there is 1 in the binary representation of $i$. This results in at most $n-1$ single $X$ gates on the circuit. Here note that while $H_{i}$ may not be a symmetric matrix, $H_{i}P_{i}$ is one.

As in the previous section, we would like to have a circuit where based on the data elements of $H_{i}$, a control register can choose the set of quantum gates. We will consider sparse matrices with 0-1 elements and assume that any $H_{ik}$ is in the following form (Note that since the following matrices form a basis, it automatically generalizes to any $H_{ik}$ with 0-1 elements. ):

[TABLE]

Using the above assumption, $H_{i}$ can be defined as a sum of two block diagonal matrices similarly to $Q_{i}$ in (3): $H_{i}=\left(Q_{ia}+Q_{ib}\right)$. Then we rewrite $\mathcal{H}$ as:

[TABLE]

For simplicity, we will again assume $Q_{ia}$ and $Q_{ib}$ consist only the gates from the set $\{X,Z,-Z,XZ,ZX,-I,I,Zero\}$ and use the same encoding as in (4). Applying $\mathcal{H}$ to a general quantum state $\left|\psi\right\rangle$ leads to a superpositioned state:

[TABLE]

We can construct this superposition state by using a similar circuit to Fig.2, but in this case we have to control the X gates that implement $P_{i}$ by the first register representing $\left|i\right\rangle$. The resulting circuit is shown in Fig.3.

IV Sparse $\mathcal{H}$ with $poly(n)$ number of elements

For $\mathcal{H}$ with $poly(n)$ number of 1s, the following two observations can be made:

The number of $H_{i}$s with only 0-1 elements cannot be more than $poly(n)$. Otherwise, the matrix has more than $poly(n)$ elements or has elements with values different than 0-1s. Therefore, we load only nonzero $H_{i}$s and adjust the control bits of the $X$ gates that implements $P_{i}$s. This requires only $poly(log(n))$ number of qubits for representing $\left|i\right\rangle$ and Hadamard gates. 2. 2.

$\zeta$ cannot be more than $poly(n)$. Otherwise, the matrix has more than $poly(n)$ number of nonzero elements.

Combining these two observations, we can conclude that

[TABLE]

Therefore, if $\left\lVert\sum_{i}Q_{i}\left|\psi\right\rangle\right\rVert$ is not too small, the circuit in Fig.3 with $O(n)$ number of quantum operations is able to simulate any sparse matrix with $poly(n)$ number of 1s with $O(1/poly(n))$ success probability.

IV.1 Storing in quantum memory

We assume that matrices on the diagonal of $H_{i}$ are stored as a vector and we can load the superposition of them to the quantum register. That means we store the vectorized form of $H_{ik}$:

[TABLE]

The size of $\left|g_{ik}\right\rangle$ depends on the number of quantum gates. Here, it is important to note that if $H_{ik}$ does not have any nonzero element, it is not stored or loaded. When $\mathcal{H}$ has $poly(n)$ number of nonzero elements, most of the $H_{i}$s must be zero. If $H_{i}$ does not have any nonzero $H_{ik}$, it is also not stored or loaded.

V Discussion

V.1 Generalization for $\mathcal{H}\in R$

Suppose we have

[TABLE]

where $\alpha$s are the real valued elements of a $H_{ik}$. The quantum gates $G_{0}\dots G_{3}$s given in (11) form a computational basis. That means for $\left|g_{ik}\right\rangle$ above, it applies the superpositioned of the quantum gates with the probabilities defined by the elements of $\left|g_{ik}\right\rangle$. Therefore, after the Hadamard gates on the chosen state, the correct normalized output $\mathcal{H}\left|\psi\right\rangle$ can still be obtained from Fig. 3 with the probability given in (7).

V.2 Use in variational quantum eigensolver

Variational quantum eigensolver peruzzo2014variational ; mcclean2016theory is generally applied to the quantum chemistry problems that are represented by the electronic Hamiltonian in the second quantization by transforming the Hamiltonian to the sum of Pauli operators, which are the products of the Pauli spin matrices(e.g. o2016scalable ; kandala2017hardware ; bian2019quantum ). Assume the electronic Hamiltonian is $\mathcal{H}=\sum_{i}h_{i}\mathcal{H}_{i}$, where $\mathcal{H}_{i}$ is a Pauli operator and $h_{i}$ is the corresponding coefficient. The algorithm starts with a state $\left|\psi(\mathbf{\theta})\right\rangle$ defined by the vector of parameters $\mathbf{\theta}$ and tries to optimize these parameters by minimizing the outcome $\left\langle\psi(\mathbf{\theta})\right|\mathcal{H}\left|\psi(\mathbf{\theta})\right\rangle=\sum_{i}\left\langle\psi(\mathbf{\theta})\right|h_{i}\mathcal{H}_{i}\left|\psi(\mathbf{\theta})\right\rangle$. Since each $\mathcal{H}_{i}$ is assumed to be a product of the Pauli spin matrices, they are implemented by a separate quantum module efficiently. Therefore, the algorithm involves a quantum part which computes the outcome and a classical part responsible for the optimization by computing the sum of individual outcomes and updating the parameters that forms $\left|\psi\right\rangle$. The circuit we describe here can be directly used in the quantum part of the algorithm. Since each operator $h_{i}\mathcal{H}_{i}$ can be written as $c_{i}H_{i}P_{i}$, where $c_{i}$ is $h_{i}$ or $-h_{i}$ based on the form of $\mathcal{H}_{i}$, $H_{i}$ is a block diagonal matrix and $P_{i}$ is the permutation matrix. In that case, we can simply get:

[TABLE]

This outcome of the circuit can be used in the classical optimization routine to update the parameters of the input state. One can also run each $\left\langle\psi(\mathbf{\theta})\right|c_{i}H_{i}P_{i}\left|\psi(\mathbf{\theta})\right\rangle$ on separate modules and sum the outcomes in the classical subroutine as done in the original quantum eigensolver.

As an example to show how to implement the modified VQE, we will take $h_{i}\mathcal{H}_{i}=h_{i}XYYZ$. Since $h_{i}XYYZ$ can be rewritten as $c_{i}H_{i}P_{i}$, in which $P_{i}=XXXI$, $H_{i}=IZZZ$ and $c_{i}=-h_{i}$. Thus $\left\langle\psi(\theta)\right|h_{i}XYYZ\left|\psi(\theta)\right\rangle=c_{i}\left\langle\psi(\theta)\right|H_{i}P_{i}\left|\psi(\theta)\right\rangle$. We can first apply $X$ gates to specific qubits to obtain $P_{i}\left|\psi(\theta)\right\rangle$. Then the context aware algorithm will implement the block diagonal matrix $H_{i}$, and output the state $H_{i}P_{i}\left|\psi(\theta)\right\rangle$. By preparing another $\left|\psi(\theta)\right\rangle$ and doing quantum fingerprintingbuhrman2001quantum using swap gate, we obtain $\left\langle\psi(\theta)\right|H_{i}P_{i}\left|\psi(\theta)\right\rangle$. Summing all the terms with coefficients $c_{i}$ gives us the energy of state $\left|\psi(\theta)\right\rangle$. Then we can use classical optimization methods to update $\theta$ and finally get the minimum energy of the system. FiG. 4 shows the ground state energy curve of H2 obtained by the simulation based on this modified VQE. In the simulation, the 4-qubit Hamiltonian of H2 is calculated by openfermion packagemcclean2017openfermion using STO-3G basis set, and the hardware-efficient ansatz is prepared by 3-layer pairwise design in bian2019quantum .

VI Conclusion

In this paper, we have described a general storage method for matrices and shown circuits that execute quantum gates based on the data information. Since the gates are controlled by the data itself, this idea can be used for context aware quantum computing. We have also discussed how the circuit can be used with variational quantum eigensolver for any matrix related problems and for the simulation of molecular Hamiltonians. As an example, we have shown how the method can be used to calculate the ground state energy curve for the molecule H2, which is in a complete agreement with the exact diagonalization results. Since any arbitrary real matrix can be decomposed into block diagonal matrices, this method may provide a new way to evolve quantum state by unitary/non-unitary operators through quantum circuits.

VII Acknowledgement

One of us, S.K would like to acknowledge the partial support from Purdue Integrative Data Science Initiative and the U.S. Department of Energy, Office of Basic Energy Sciences, under Award Number DE-SC0019215.

Appendix A Validation of the circuit in Fig.1

The controlled gate set in the circuit has the following matrix form:

[TABLE]

We can represent the whole circuit more concisely by using the direct sum of matrices:

[TABLE]

To illustrate the action of the circuit, we will use the example matrix $Q_{i}=Z\oplus XZ$ which leads to the following $\left|g_{ik}\right\rangle\left|k\right\rangle$s:

[TABLE]

Then we form the following 6-qubit initial state:

[TABLE]

After applying the controlled gates ($CG$) to the initial state, we obtain:

[TABLE]

Applying the Hadamard gates to the first three qubits produces the following final state:

[TABLE]

Here, the states where the first three qubits are in $\left|000\right\rangle$ includes the expected output which are:

[TABLE]

The equivalent of $Q_{i}\left|\psi\right\rangle$ is produced on the amplitudes of the states:

[TABLE]

Appendix B Validations of the circuits in Fig.2 and Fig.3

In the circuit in Fig.2, we have the superpositioned input state $\left|g\right\rangle$. Before the Hadamard gates on the first register of the circuit, for different $\left|i\right\rangle$ on the output we have normalized $Q_{i}\left|\psi\right\rangle$ on the same states as given in (24) and (25). That means for $\left|\mathbf{0}\right\rangle$ on the first register we have normalized $Q_{0}\left|\psi\right\rangle$ on the chosen states, and for $\left|\mathbf{1}\right\rangle$ we have $Q_{1}\left|\psi\right\rangle$, and so on. By applying the Hadamard gates to the first register, for $\left|i\right\rangle=\left|\mathbf{0}\right\rangle$, we generate the normalized summation $\sum_{i}Q_{i}\left|\psi\right\rangle$ on the same chosen states.

Fig.3 is just the generalization of Fig.2 and acts the same way.

Appendix C A larger Hamiltonian divided into submatrices

[TABLE]