Machine Learning Phase Transitions with a Quantum Processor

TL;DR

This paper introduces a quantum algorithm combining quantum simulation and machine learning to classify phases of matter efficiently, overcoming classical simulation limitations and achieving high accuracy on quantum models.

Contribution

It presents a novel variational quantum classifier using tensor network-inspired states and a quantum neural network, advancing quantum phase classification methods.

Findings

Achieved 99% accuracy on the transverse field Ising model.

Achieved 94% accuracy on the XXZ model.

Proposed tensor network-inspired variational states and a quantum neural network.

Abstract

Machine learning has emerged as a promising approach to study the properties of many-body systems. Recently proposed as a tool to classify phases of matter, the approach relies on classical simulation methods$-$such as Monte Carlo$-$which are known to experience an exponential slowdown when simulating certain quantum systems. To overcome this slowdown while still leveraging machine learning, we propose a variational quantum algorithm which merges quantum simulation and quantum machine learning to classify phases of matter. Our classifier is directly fed labeled states recovered by the variational quantum eigensolver algorithm, thereby avoiding the data reading slowdown experienced in many applications of quantum enhanced machine learning. We propose families of variational ansatz states that are inspired directly by tensor networks. This allows us to use tools from tensor network theory to explain properties of the phase diagrams the presented method recovers. Finally, we propose a nearest-neighbour (checkerboard) quantum neural network. This majority vote quantum classifier is successfully trained to recognize phases of matter with $99\%$ accuracy for the transverse field Ising model and $94\%$ accuracy for the XXZ model. These findings suggest that our merger between quantum simulation and quantum enhanced machine learning offers a fertile ground to develop computational insights into quantum systems.

Equations

$$H=\sum {\mathcal{J}}_{{\alpha }_1{\alpha }_2\dots {\alpha }_n}{\sigma }_{{\alpha }_1}\otimes {\sigma }_{{\alpha }_2}\otimes \cdots \otimes {\sigma }_{{\alpha }_n},$$

$$\begin{gathered} U(\tilde{\mathbf{\theta }})=(R_z({\tilde{\theta }}_5)\otimes R_z({\tilde{\theta }}_4))\circ \\ \circ R_{zz}({\tilde{\theta }}_3)\circ (R_x({\tilde{\theta }}_1)\otimes R_x({\tilde{\theta }}_2)), \end{gathered}$$

$$f=-\sum _{i=1}^{N_{train}}\left(y_i\log p_i+(1-y_i)\log (1-p_i)\right).$$

$$H_{\mathrm{TFIM}}=J\sum _{i=1}^n{\sigma }_i^z{\sigma }_{i+1}^z+h\sum _{i=1}^n{\sigma }_i^x,J>0,h>0,$$

$$H=\sum _{i=1}^n\left[J_{\perp }\left({\sigma }_i^x{\sigma }_{i+1}^x+{\sigma }_i^y{\sigma }_{i+1}^y\right)+J_z{\sigma }_i^z{\sigma }_{i+1}^z\right].$$

$$U_{rot}=(e^{i\frac{\phi }{2}Z}{)}^{\otimes n}.$$

$$X{e}^{i\frac{\theta }{2}Z}=\cos \frac{\theta }{2}X+i\sin \frac{\theta }{2}XZ=(\cos \frac{\theta }{2}\text{mathds}1-i\sin \frac{\theta }{2}Z)X=e^{-i\frac{\theta }{2}Z}X.$$

Full text

Introduction.

The best contemporary algorithms to emulate quantum systems using classical computers suffer from an exponential slowdown in limiting cases. A recent approach is to apply machine learning, which offers new techniques for large-scale data analysis. In particular, machine learning was recently proposed as a tool to recognize phases of matter Carrasquilla and Melko (2017); van Nieuwenburg et al. (2017). These methods still rely on Monte Carlo sampling (or alternative classical simulation methods) which suffers from the an exponential slowdown induced by the so-called sign problem. Independently, quantum algorithms have also been proposed as a platform for machine learning Biamonte et al. (2017); Huggins et al. (2019); Schuld et al. (2018); Schuld and Killoran (2019); Havlíček et al. (2019); Biamonte et al. (2017); Schuld et al. (2015); Duan et al. (2017, 2019); Sheng and Zhou (2017). In addition, unlike classical algorithms, quantum simulators are predicted to simulate quantum systems efficiently Georgescu et al. (2014); Bernien et al. (2017); Barreiro et al. (2011). Here we merge quantum machine learning with quantum simulation, leveraging quantum mechanics to overcome two classical bottlenecks. Namely, we leverage quantum algorithms as a tool to simulate quantum systems by preparing states which are labeled and fed into a quantum classifier. The later removes the data reading slowdown experienced in many applications of quantum enhanced machine learning. While the former utilizes quantum simulators to avoid classical methods with known limitations. We also replace the standard unitary coupled cluster ansatz found in implementations of the variational quantum eigensolver Peruzzo et al. (2014) with families of tensor network ansatz states.

The idea of machine learning is to recognize patterns in data. Using machine learning techniques, one can analyze the phase diagrams of strongly interacting quantum systems and thus directly address system properties. In this approach, Monte Carlo samples of such systems are used as input data and classified using supervised Carrasquilla and Melko (2017); van Nieuwenburg et al. (2017) or unsupervised Wang (2016) learning. This way, spin Hamiltonians of up to a few hundreds of entities can be studied. Nonetheless, for fermionic systems, the use of Monte Carlo methods is drastically restricted by the sign problem, leading to an exponential slowdown.

In the variational quantum circuits approach McClean et al. (2016); Wecker et al. (2015), the quantum computer is required to prepare a sufficiently rich variety of probe states (or circuits, e. g.  if the problem is to approximately compile a certain quantum gate Khatri et al. (2018)). This approach emerged in response to challenges to adopt quantum algorithms for existing hardware. A particular example, the variational quantum eigensolver (VQE), represents an implementation of variational quantum circuits which uses a quantum processor to prepare a family of states characterized by a polynomial number of parameters and minimizes the expectation value of a given Hamiltonian within this family. This approach is widely taken on small- and middle-size quantum computers Peruzzo et al. (2014); O’Malley et al. (2016); Colless et al. (2018).

In this Letter, we propose a way around the sign problem using a quantum computer. To classify the phases of a given quantum Hamiltonian, we first prepare its approximate ground states variationally, and then feed them as an input to a quantum classifier. In this respect, there is no need in sampling of microscopic configurations with Monte Carlo based methods. Instead, the classifier has direct access to the quantum states Havlíček et al. (2019), yielding thus an effective realization of quantum-enhanced machine learning. To make this algorithm realizable on near-term quantum computers, we propose preparing the quantum states using shallow tensor network based circuits. Numerical tests show that this technique allows the quantum classifier to correctly recognize phase transition in transverse field spin models.

Tensor network ansatz states for VQE.

VQE is a hybrid iterative quantum-classical algorithm used to approximate the ground state of a given Hamiltonian Peruzzo et al. (2014). It relies on preparing an ansatz state $|\psi(\boldsymbol{\theta})\rangle$ by applying a sequence of quantum gates $U(\boldsymbol{\theta})$ and sampling the expectation value of a given Hamiltonian relative to this state, followed by a classical optimizer to minimize the energy, $\langle\psi(\boldsymbol{\theta})|H|\psi(\boldsymbol{\theta})\rangle$. Within the VQE method, we approach the ground state of a given Hamiltonian using tensor networks ansatz states.

We proceed with representing the Hamiltonian as a sum of tensor products of Pauli operators:

[TABLE]

where $\alpha_{i}\in\{0,1,2,3\}$ enumerate the Pauli matrices $\{\mathds{1},X,Y,Z\}$. With the decomposition shown in Eq. 1, individual terms of $\langle\psi(\boldsymbol{\theta})|H|\psi(\boldsymbol{\theta})\rangle$ can be estimated and variationally minimized elementwise using a classical-to-quantum process. In each iteration one prepares the state $\ket{\psi(\boldsymbol{\theta})}$ and measures each qubit in the local $X,\ Y$, or $Z$ basis, estimates the energy and updates $\boldsymbol{\theta}$. This method can become scalable only if the number of terms in the Hamiltonian is polynomially bounded in the number of spins and the coefficients $\mathcal{J}_{\alpha_{1}\alpha_{2}\dots\alpha_{n}}$ are defined up to poly($n$) digits.

It is therefore not surprising that the performance of VQE crucially depends on the choice of the ansatz state. A common approach is to use the unitary version of the coupled cluster method, the unitary coupled cluster (UCC) ansatz Shen et al. (2017); O’Malley et al. (2016); Hempel et al. (2018); Dumitrescu et al. (2018). For interacting spin problems, the (non)unitary coupled cluster ansatz can be composed out of spin-flip operators McClean et al. (2016); Götze et al. (2011). There is no known classical algorithm to efficiently implement this method, even when the series is truncated to low-order terms Taube and Bartlett (2006). In principle, a quantum computer could efficiently prepare this state, truncated up to some $k$-th order using the Suzuki–Trotter decomposition Lanyon et al. (2010). However, for a system of $n$ qubits it requires $\mathcal{O}(n^{k})$ unitary gates, making this technique out of reach for the available quantum computers. Still, even if UCC is truncated to single and double interactions (UCCSD), it requires $9n^{2}$ operations and necessitates applying some optimization strategy that would remedy this problem Cao et al. (2018).

Instead, we test a number of shorter ansatz states inspired by tensor network states, namely (i) a rank-one circuit; (ii) a tree tensor network circuit (Fig. 2a); and (iii) a family of checkerboard-shaped circuits (Fig. 2b) with varying depth.

In particular, these states differ in the amount of entanglement they can support. In general, quantum states of $n$ qubits can be represented by $n$-index tensors, while quantum circuits are embodied by tensor networks. Each quantum gate is seen as a vertex, and each string is an index running through $\{0,1\}$, while the maximum amount of entanglement is determined by the number of strings one needs to cut to separate the subsystems (see Fig. 1). Each string corresponds to at most one ebit of entanglement. An $n$-qubit state can contain at most $\lfloor n/2\rfloor$ ebits of entanglement. To formalize the latter, suppose there exists a certain bipartition in the system that brings $n_{1}$ qubits to the first subsystem and $n_{2}$ qubits to the second. It is then possible to regroup the tensor state into a $2^{n_{1}}\times 2^{n_{2}}$ matrix. The rank of this matrix provides an upper bound to the amount of entanglement across this bipartition: a rank-$k$ state can support at most $\log_{2}k$ ebits of entanglement, i.e. when it is in the maximally entangled state.

State preparation. We first approximate the ground state of a Hamiltonian by rank-one states. One can prepare any unentangled state using $2n$ gates by subsequently applying $R_{y}$ and $R_{z}$ rotations to each qubit. This ansatz essentially matches the first order truncation of UCC.

Fig. 2a illustrates a circuit implementing a tree tensor network state. This state is prepared using the two-qubit parametric blocks subsequently described in detail. The preparation procedure is easier to explain when the number of qubits is a power of two. A block first entangles qubits number 1 and $(n/2+1)$. Then, in the next layer, two blocks act on qubit pairs $(1,n/4+1)$ and $(n/2+1,n/2+n/4+1)$. Then, for each half of the register, we act in the same way, but now the blocks act on qubit pairs $(1,n/4+1)$ and $(n/2+1,n/2+n/4+1)$. Each half of the register is again divided into two halves. The pattern continues. For systems where the number of qubits is not a power of two, one can do this procedure up until the number of qubits involved is the closest power of two, and then make the last layer of operators incomplete. Such a structure enables long-range correlations but limits the entanglement entropy that a state bipartition can potentially have: any contiguous region can be isolated by $\mathcal{O}(1)$ cuts. It is easy to contract $\bra{\psi_{tree}}A\ket{\psi_{tree}}$ classically with $A$ being a local observable and $\ket{\psi_{tree}}$ being a tree tensor network state.

There is some freedom in choosing the two-qubit blocks that comprise the tree TN. In principle, one can implement any unitary in $SU(4)$ by using three controlled-NOTs and 15 single-qubit rotations Vatan and Williams (2004). However, throughout this work we used two-qubit gates with fewer parameters $\bm{\tilde{\theta}}$ to simplify the optimization (Fig. 3):

[TABLE]

where $R_{z}(\theta)=e^{i\theta Z/2}$, $\ R_{x}(\theta)=e^{i\theta X/2}$, and $R_{zz}(\theta)=e^{i\theta Z\otimes Z/2}$. Thus, a complete ansatz would have five free parameters per two-qubit block. In total the tree tensor network ansatz features $n-1$ blocks, yielding $5n-5$ independent parameters.

Remarkably, the block shown in Fig. 2 is inspired by the parametrized Hamiltonian approach Santagati et al. (2018) and the unitary operators used in the quantum approximate optimization algotrithm (QAOA) Farhi et al. (2014). Of course, the ansatz with such blocks is weaker than it would be if each block implemented the entire $SU(4)$ group. However, such an ansatz would also have some redundancy as the ansatz gates are applied to a fixed $n$-qubit input state $\ket{0}^{\otimes n}$.

In a checkerboard tensor network, the entangling blocks are positioned in a checkerboard pattern as shown in Fig. 2b. In the following, we impose periodic boundary conditions, meaning that the last qubit is linked to the first. For this ansatz, we also use the two-qubit entangling gate shown in Fig. 3. This way, the ansatz has $5L\lfloor n/2\rfloor$ independent parameters, where $L$ is the number of layers in the circuit.

To isolate a region in a checkerboard tensor network state with $d$ layers, one has to cut at least $\mathcal{O}(d)$ bonds regardless of the region size (if the region is very small, one can also make a “horizontal cut” of $\mathcal{O}(L)$ bonds). Therefore, if we set the number of layers to be equal to $\lfloor\log_{2}(n)\rfloor$, the upper bound on the entanglement scaling is equal to that in critical one-dimensional systems. To implement any maximally entangled state, that is, a state with the maximum possible amount of ebits, one needs to cut $\lfloor\frac{n}{2}\rfloor$ bonds. If the checkerboard ansatz is made with open boundary conditions, it needs at least $2\lfloor\frac{n}{2}\rfloor$ gates to saturate entanglement. Periodic boundary conditions make the ansatz more powerful and lower this bound in half, to $\lfloor\frac{n}{2}\rfloor$ layers.

Quantum classifier.

Not only can the checkerboard tensor network be used as a VQE ansatz but it also functions as a quantum majority vote classifier. Each data point is a VQE solution: the parameters of the unitary gates are optimized in order to get the minimum energy $\bra{\psi(\boldsymbol{\theta})}H(h)\ket{\psi(\boldsymbol{\theta})}$, where $h$ is a parameter which determines the phase of the model. Each VQE solution is labeled with “0” or “1” depending on whether the model parameter is above or below the phase transition point. We then prepare a circuit made of two parts (Fig. 4). The first part takes the blank qubit registry $\ket{000...0}$ and prepares the VQE solution in the form of an ansatz state. The second part takes this state as an input and applies a unitary $U_{\mathrm{class}}(\boldsymbol{\varphi})$. We then measure the output of the circuit in the $Z$-basis. Let $q_{0}$ and $q_{1}$ be the total number of measurements in which more than half of the qubits are in “0” or “1” states respectively. Finally, the classifier returns the predicted probability $p=q_{1}/(q_{0}+q_{1})$ for the state belonging to the class “1” being equal to the probability that the majority of qubits vote “1”, excluding ties. Fig. 9 in the Supplemental material shows the quantum circuit in more detail.

Let $\{(\boldsymbol{\theta}_{i},y_{i})\}_{i=1}^{N_{train}}$ be the set of training data points and their labels, $y_{i}\in\{0,1\}$. Let $p_{i}\in[0,1]$ be the label predicted by the neural network. Then the logarithmic loss function is:

[TABLE]

To minimize $f$, we used the simultaneous perturbation stochastic approximation (SPSA) algorithm Spall (1992). This algorithm estimates the gradient vector by computing a finite difference in random direction, then performs a gradient descent step. We optimized the log loss over 300 epochs, with both finite differences step size and learning rate starting very coarse and decreasing as $1/\sqrt{n_{epoch}}$, where $n_{epoch}$ is the epoch number.

Numerical results.

To compare the performance of various VQE ansatz states, we make numerical simulations of the quantum algorithm. In our simulation, the results of the measurements are given without noise and with perfect accuracy. We apply our quantum circuit of $n=10$ qubits to the transverse field Ising model (TFIM), which being exactly solvable Lieb et al. (1961); Pfeuty (1970) serves for testing purposes. This model is specified by the Hamiltonian

[TABLE]

where $\sigma^{\alpha}_{i}$ is the Pauli matrix $\alpha$ acting on the $i$th spin, and we impose periodic boundary conditions $\sigma_{n+1}^{\alpha}=\sigma_{1}^{\alpha}$.

The ground state of TFIM is determined by the trade-off between Heisenberg exchange coupling, the first term in Eq. 4, favoring collinear orientation of magnetic moments in $z$ direction, and the Zeeman coupling to the transverse magnetic field, the second term. The latter has the tendency to flip the $z$-component, being thus the source of ‘quantum fluctuations’ in the system. In a magnetically ordered state, a strong magnetic field $h\geq J$ destroys magnetic order even at zero temperature. This induces quantum fluctuations resulting in ground state restructuring, which is manifested by non-analiticity in the ground state energy of the quantum Hamiltonian (Eq. 4).

It is therefore intuitively clear that in the absence of magnetic field, $h=0$, or in the case of high spin polarization, $h=\infty$, the Hamiltonian is dominated by a single interaction, making the ground state disentangled so that even rank-one approximations could provide quantitatively correct results. Meanwhile, this is not the case at criticality, $h=J$, where the competition between the two mechanisms favors the formation of highly entangled ground state.

In our numerical implementation, we use Qiskit Aleksandrowicz et al. (2019) to simulate quantum circuits and the limited Broyden–Fletcher–Goldfarb–Shanno method (L-BFGS-B) to update the parameters during the classical step of the VQE, while all measurements are assumed ideal. We scan the values of $h$ from [math] to $2J$. For $h=0$, the optimization process started from a random point, then each additional point started from the previous solution. To eliminate any obviously sub-optimal solutions, we also ran the scanning in the opposite direction and for each value of the field we keep the better result. Without this “double-sweeping” procedure, spurious solutions appear in the vicinity of the phase transition: the solution for one phase remains a local optimum for some time after the parameter has moved to the other phase (see the Supplement).

All ansatz states show an increase in error near the phase transition point (Fig. 5). With the increasing depth, the checkerboard states show better approximation. It is interesting to point out that the low-depth ansatz states, namely rank-one, tree tensor network and checkerboard states of depth one, all show surprisingly similar results, which is associated with the relative simplicity of the Ising Hamiltonian. To feed the dataset into the classifier we prepare 100 data points using VQE with four-layered checkerboard ansatz states. This data was then shuffled and split into the training set (80%) and the test set (20%). Strikingly, the accuracy of the prediction achieves 99%. The outcome of the quantum classifier is presented in Fig. 6 (left).

Another exactly solved model which we use to test our classifier is the antiferromagnetic $XXZ$ spin chain with the Hamiltonian:

[TABLE]

From a physical perspective, Eq. 5 corresponds to a uniform exchange coupled system with a uniaxial anisotropy specified by $J_{z}$. At $|J_{z}|<J_{\perp}$, this model is in the XY, or planar, phase which is characterized by algebraic decay of equal-time spin-spin correlation functions. In the regime $J_{z}>J_{\perp}$ the Hamiltonian corresponds to the antiferromagnetic Ising state. The system undergoes a Berezinsky–Kosterlitz–Thouless type phase transition at $J_{z}=J_{\perp}$ is Franchini (2017). At the phase transition point, the ground state has the highest nearest-neighbour concurrence and a cusp in nearest-neighbour quantum discord Dillenschneider (2008).

This model has symmetry with respect to rotations in the $xy$ plane, as well as spin-flip symmetry. This fact allows us to augment the training data. Given a VQE approximation, we can create another, equally good approximation by applying a rotation or spin-flip. The structure of the VQE ansatz is conserved in the sense that the new states are produced by the same quantum circuit with different control parameters (see Supplemental Material for more details). In total, we produce 4000 data points.

Despite being more subtle, the phase transition in the XXZ model is also correctly learned by the classifier, yielding correct labels on 94.6 % of test data (Fig. 6, right). In this case, we have added two more layers to the classifier circuit to increase the accuracy. Notably, the plot for the XXZ model looks less uniform than the plot for the Ising model. This is partially connected to the data augmentation procedure described in the Supplement. However, it is unclear why the behavior is abruptly changed at the phase transition point.

Conclusions and discussion.

We proposed a method of classifying phases of matter using a quantum machine learning algorithm paired with quantum simulation. In our numerical tests we achieved 99% accuracy for the transverse field Ising model with a 4-layered classifier and 94% accuracy for the XXZ model with a 6-layered classifier. The quantum classifier works intrinsically with quantum data, providing advantage over the classical methods based on Monte-Carlo sampling. Manipulating quantum states explicitly on a classical computer would require an exponential amount of memory in the worst case. However, it would be interesting to compare our model with a classical model that would work with efficiently contractible states like matrix product states (MPS) or multiscale entanglement renormalization ansatz (MERA) states Vidal (2007).

It is a nontrivial fact that the Ising model required fewer layers than the XXZ model. In the transverse field Ising model, the magnetization $\sum\langle\sigma_{x}^{(i)}\rangle$ as a function of magnetic field clearly points at the location of the phase transition points. This implies that the phases of the model are “easy” to classify. In the XXZ model, the transition at $J_{z}=1$ is a transition between a paramagnetic and an antiferromagnetic phase Franchini (2017). Neither of these phases shows spontaneous magnetic moment in absence of an external field, making it somewhat harder to discern the two phases.

The number of layers that can be used both for VQE and for the classifier is limited by several factors. Firstly, too long a circuit would be hard to implement in near-term quantum hardware. Second, the runtime of the classical optimization grows with the number of parameters in the cost function, which is $O(nL)$ for the checkerboard ansatz. Finally, McClean et al. pointed out that a long random parametrized quantum circuit can resemble a Haar-random unitary map. Under such conditions, the typical value of the gradient of the cost function decreases exponentially with the number of qubits for any reasonable cost function. This finding is important for the design of any variational quantum algorithms.

The proposed classification technique can be applied to any model that can be expressed as a spin model (e.g. fermion problems can be mapped to spin problems by using Jordan–Wigner transformation or Bravyi–Kitaev transformation).

For the reported study, we tested three different ansatz circuits for VQE, but only one of them was used for classification. In principle, one could also try to use the other two ansätze for classification. Indeed, the rank-one ansatz would be a simple classifier that only uses local spin measurements. One could also use the tree tensor network, however it would have to be flipped compared to the VQE ansatz: the tree classifier would take $n$ qubits as input, and output only one or two qubits. However, as these two ansätze show poorer results for VQE, we do not believe they would admit improved results in their role as classification circuits. For a particular example, a rank-one classifier would work for the transverse field Ising model, because the alignment of spins along the X axis changes across the phase transition, as we mentioned before. For the XXZ model, however, this does not happen, and hence using the rank-one classifier would be pointless. Finally, the tree tensor network can be efficiently contracted on a classical machine, therefore the proposed classifier would not offer any computational advantage if it used the TTN as a classifier.

We simulated quantum machine learning for binary classification. Such a protocol can be extended to more classes. For example, for four classes, we could treat “0000000000” as a label of class 1, “0000011111” as a label of class 2, “1111100000” as that of class 3, and finally “1111111111” as that of class 4. Other possibilities would then be labeled according to which of the four strings is closest in terms of Hamming distance.

Since we have VQE solutions as the data points with assigned labels, $\{\ket{\psi(\boldsymbol{\theta}_{i})},y_{i}\}^{N_{train}}_{i=1}$, we could in principle use the $k$-nearest neighbors method Hastie et al. (2017) for classifying a state $\ket{\rho}$. That is, for the simplest case with $k=1$, we would calculate all the $N_{train}$ overlaps $\mathcal{O}_{i}=|\langle\psi(\boldsymbol{\theta}_{i})|\rho\rangle|^{2}$, find the the state $\ket{\psi(\boldsymbol{\theta}_{m})}$ which gives the maximal overlap $\mathcal{O}_{m}$ and assign the label $y_{m}$ from the pair $\{\ket{\psi(\boldsymbol{\theta}_{m})},y_{m}\}$ to the state $\ket{\rho}$. If $\ket{\psi(\boldsymbol{\theta}_{i})}=U(\boldsymbol{\theta}_{i})\ket{\boldsymbol{0}}$ and $\ket{\rho}=V\ket{\boldsymbol{0}}$, then the overlap $\mathcal{O}_{i}$ can be calculated with a quantum computer by preparing the state $V^{\dagger}U(\boldsymbol{\theta}_{i})\ket{\boldsymbol{0}}$ and measuring it in the computational basis. The probability to obtain only zeros in the measurement result will be exactly the overlap $\mathcal{O}_{i}$. The main drawback of this approach is that in order to classify a state $\ket{\rho}$, one needs to estimate $N_{train}$ overlaps $\mathcal{O}$. In contrast, in the method we propose, once the classifier circuit $U_{\mathrm{class}}$ is trained, it requires only a single series of measurements to classify an input state.

Numerical Methods.

The quantum circuits designed in the study were simulated using Qiskit Aleksandrowicz et al. (2019). Figures 5, 6 were prepared using Matplotlib Hunter (2007). The source code for the study is available at github.com/Quantum-Machine-Learning-Initiative/

learning-phases.

Appendix A Supplemental Material

A.1 Data augmentation for the XXZ model

The XXZ Hamiltonian is symmetric with respect to spin flips and $xy$ plane rotations. Despite the fact that its ground state is non-degenerate, applying these symmetries to a VQE state produces a different state with the same energy, which is an equally valid data point. Thankfully, these actions can be easily performed on the checkerboard states without changing their structure.

Let us start considering rotation symmetry. This rotation is implementing by applying a $Z$ rotation to each qubit:

[TABLE]

In the ansatz we deloped, the two-qubit blocks precede $Z$ rotations. So, applying this symmetry amounts to changing the angles in the Z rotations of the last checkerboard layer by $\varphi$.

Somewhat more complicated is the application of spin flips. We consider spin flips as applying one of $X,Y,$ or $Z$ operations to all spin simultaneously. The Z spin flip is a special case of the $Z$ rotation(s). The $Y$ flip can be composed out of $X$ and $Z$ flips, so we only need consider the $X$ flip. Consider the quantum circuit in Fig. 7.

Let us use the fact that $X$ and $Z$ Pauli matrices anticommute and push the $X$ gates to the front:

[TABLE]

Thus, if we push the $X$ gates to the left and invert the angles of the $Z$ rotations, the circuit remains invariant. Now, the next gate is the $Z\otimes Z$ rotation. $[X\otimes X,Z\otimes Z]=0$, therefore the $X$ gates can go through the $R_{ZZ}$ gate without any changes. Finally, the $X$ gates merge with the $X$ rotations by incrementing the angle by $\pi/2$. Thus, to augment the data with the spin-flipped states, one inverts the angles of the $Z$ rotations in the last layer, and increase the angles of the $X$ rotations in the last layer by $\pi/2$.

A.2 Testing the processor on a model without structure

As was pointed in the main text, simpler toy models may have simple classification criteria which do not require application of machine learning. In this section, we classify the solutions of a randomized model: $H(\alpha)=(1-\alpha)H_{1}+\alpha H_{2},\ \alpha\in[0,1]$, where $H_{1}$ and $H_{2}$ are random Hermitian matrices pulled from a Gaussian unitary ensemble. We split the solutions in two classes: (i) $\alpha<0.5$ and (ii) $\alpha>0.5$. Then we run the optimization routine to train the learning circuit to discern between the two classes.

The approach was tested for 6 qubits, $n=100$, where $n_{train}=70,\ n_{test}=30$. The depth of the VQE circuit and the classifier circuit were both set to four layers.

The results are shown in Fig. 8 . For this configuration, the accuracy of 93 % was reached. This shows that the algorithm works even for such a low-structured problem, although the factors affecting the performance still require further investigation.

A.3 A detailed depiction of the quantum circuit

Figure 9 shows the classifier circuit (4 layers) in full detail for 10 qubits. A full circuit (VQE + classifier) can be obtained by concatenating two copies of that circuit.

A.4 On convergence of VQE with warm starts

To save time on VQE computations we used the previously found solution for $H(h)$ as a starting point for the VQE process on the next Hamiltonian $H(h+\Delta_{h})$ (this approach is also known as adiabatic-assisted VQE [41]). Since the Hamiltonian is deformed only slightly, the previous point is a good guess for the new minimum. Unfortunately, if during the deformation of the Hamiltonian this local minimum stops being a global one, the solver gets stuck in the wrong solution for a while. This is exactly what happens in the vicinity of the phase transition. Fig. 10 demonstrates the behavior of the VQE solution for the XXZ model. We ran VQE in two sweeps: $J_{z}$ swept from 0 to 2 in the “up” sweep and from 2 to 0 in the “down” sweep. As a result, VQE shows a hysteresis.