betaFeedback

WorksPhysics and Astronomy

Three-flavor supernova neutrino simulation using a hybrid quantum-classical algorithm with qutrits

Abstract

We simulate a self-interacting three-flavor neutrino system within a core-collapse supernova using a hybrid classical-quantum algorithm on a qutrit computer. Based on the Dirac-Frenkel evolution equations, we employ a variation of the quantum-assisted simulator to calculate the system's time evolution operator by performing qutrit Hadamard tests to find expectation values of unitary operators in the Hamiltonian. The time evolution simulation is then done classically. We find that the hybrid algorithm produces results comparable to an exact numerical integration out to times of t≈30 ω0−1t \approx 30 \,ω_0^{-1} with time step δt=0.005 ω0−1δt = 0.005 \,ω_0^{-1}, where ω0ω_0 is the energy scale of the single neutrino vacuum oscillations. We discuss the lessons learned in simulating neutrino systems using this hybrid quantum-classical algorithm, along with the advantages it offers over quantum Trotterization.

Introduction

The realization of low-noise, scalable quantum computers promises to allow the computation of complex problems that classical methods struggle with, either due to processing, memory, or time limitations. These quantum machines are still on the mid- to far-term horizon, however, leaving current research efforts with noisy, intermediate-scale quantum (NISQ) devices. These quantum computers, while useful in solving various types of problems of interest to scientists across fields, struggle with relatively low fidelities on entangling gates, the very operations that give quantum computers their true power over classical methods. Thus, it is advantageous to limit the depth of quantum circuits to minimize the number of entangling gates applied in succession.

One method to achieve this is to actually not use the quantum computer, at least in portions of the calculation that a classical computer can solve efficiently. The quantum computer is used only where it provides some scaling or processing advantage over classical methods, in particular for calculating matrix elements of unitary operators. These hybrid classical-quantum algorithms have been relatively popular in the era of NISQ devices to circumvent their limitations due to poor entangling gate fidelities and issues scaling up the number of qubits [1, 2].

Time evolution of physical systems that easily map onto spin states is a prime candidate for such a hybrid calculation, since classical computers are very good at calculating time-evolved states (through matrix multiplication) and quantum computers are capable of calculating expectation values of spin operators at fairly low circuit depth. Collective neutrino flavor oscillations are such a system. For reviews see [3, 4, 5, 6, 7, 8, 9]. In collective neutrino oscillations a single neutrino in the two-flavor approximation is a realization of SU(2) and thus maps directly onto a qubit state. Therefore, the collective many-body neutrino oscillation phenomenon beyond mean-field limit has been extensively studied with both classical [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25] and quantum simulation methods [8, 26, 27, 28, 29, 30] but mostly under the two-flavor approximation. From experiment, however, we know that there are (at least) three active flavors of neutrinos, and the oscillations among them live in SU(3). Pauli operators are substituted with Gell-Mann matrices, two energy levels become three, and the algebraic structure of the system becomes more complicated [31]. Thus, the natural quantum device for studying three-flavor neutrino states is instead the three-level qutrit [32], which brings complications to the calculation that do not show up in the qubit case [33, 34, 35]. Our goal in this paper is to identify and overcome these obstacles while simulating the time evolution of interacting three-flavor neutrinos in a core-collapse supernova (CCSN) environment.

In the following section, we introduce the mathematical framework that we will use to study supernova neutrino interactions. Then, in Sec. III, we translate our Hamiltonian onto a collection of qutrits, three-level quantum states that match the behavior of three-flavor neutrino oscillations, and describe the process of implementing the Dirac-Frenkel quantum-assisted simulator. We present our results from a Dirac-Frenkel hybrid calculation in Sec. IV, along with a quantification of errors from this approach. We follow with Sec. V, a discussion of the benefits, drawbacks, and future developments of this hybrid algorithm in the context of the current and mid-term quantum computing landscape.

Supernova Neutrinos

Neutrino oscillations have a very important role in determining the dynamics and observables of core-collapse supernovae, as neutrinos are the main source of energy transport both within and out of the collapsing star [36]. They are predicted to dictate nucleosynthesis rates, electron fraction, and protoneutron star mass, among other quantities [37]. Because of their relatively weak interaction with the surrounding matter, neutrinos are the only direct probe of dynamics in the core of the collapsing star. The nature of their flavor oscillations has a nontrivial effect on supernova processes, as only electron neutrinos (and antineutrinos) have charged current interactions with the large mass of electrons in the core and surrounding matter. Further, these flavor oscillations affect the detectability of supernova neutrinos in Earth-based experiments since different detection channels are sensitive to different neutrino flavors [38, 39, 40].

Modeling neutrino interactions within a CCSN is a nontrivial task, as on average a CCSN is predicted to produce around 105310^{53} erg in neutrinos which interact both with themselves and with the surrounding matter [41]. Further, the strength of the neutrino-neutrino interaction depends on the angle of the incoming particles, neutrino energy, and the neutrino density, all of which may be different for every interaction. In order to make this problem more tractable, some averaging is required; commonly, the single-angle approximation and neutrino bulb model are used [42, 43, 44, 45]. The single-angle approximation assumes that the flavor evolution of the neutrinos is independent of their trajectories, which allows us to replace the angle-dependent interaction coupling with one that only depends on the radius, rr. The neutrino bulb model then gives an approximation for this rr dependence, as we expand upon shortly.

The Hamiltonian for neutrino-neutrino interactions at nn evenly-spaced discrete momenta in the single-angle approximation is [31, 46]

H=∑q=1nqB⃗⋅Q⃗q+μ(t)∑q<q′Q⃗q⋅Q⃗q′(1)H = \sum_{q=1}^{n} q\vec{B}\cdot\vec{Q}_{q} + \mu(t)\sum_{q<q'}\vec{Q}_{q}\cdot\vec{Q}_{q'} \tag*{(1)}

where (Qq)i=12∑j,k=13aj†(λi,q)jkak(Q_q)_i = \frac{1}{2}\sum_{j,k=1}^{3} a_{j}^{\dagger}(\lambda_{i,q})_{jk}a_k are the generators of SU(3) in terms of the Gell-Mann matrices λi\lambda_i on the qqth qutrit and B⃗={0,0,ω,0,0,0,0,23Ω}\vec{B} = \{0,0,\omega,0,0,0,0,\frac{2}{\sqrt{3}}\Omega\}, with

ω=−δm22E,Ω=−Δm22E.(2)\omega= -\frac{\delta m^2}{2E}, \qquad\Omega= -\frac{\Delta m^2}{2E}. \tag*{(2)}

Here δm2=∣m22−m12∣\delta m^2 = |m_2^2-m_1^2| and Δm2≈∣m32−m12∣≈∣m32−m22∣\Delta m^2 \approx|m_3^2-m_1^2| \approx|m_3^2-m_2^2| are the mass-squared differences of the neutrino mass states and EE is the average neutrino energy. The time-dependent coupling strength μ(t)\mu(t) is determined by the aforementioned neutrino bulb model:

μ(t)=μ0(1−1−(Rνr(t))2)2;(3)\mu(t)=\mu_0\left(1-\sqrt{1-\left(\frac{R_\nu}{r(t)}\right)^2}\right)^2; \tag*{(3)}

assuming that neutrinos travel at the speed of light, r(t)=r0+ctr(t)=r_0+ct. Here r(t)r(t) is the distance from the center of the neutrinosphere, and RνR_\nu is the radius of the neutrinosphere. Properties of this simplified model such as entanglement, spectral splitting, and flavor oscillation have been extensively studied to date [10, 17, 31, 47, 48].

Our goal is now mathematically simple and quite familiar: given an initial state ∣ψ0⟩|\psi_0\rangle, what is the state at a later time tt, ∣ψ(t)⟩|\psi(t)\rangle? How can we best leverage quantum computing’s strengths to achieve this?

Hybrid Qutrit Algorithm

As mentioned in the introduction, NISQ devices struggle with entangling gate fidelity, forcing researchers to explore ways to limit excessive use of two-qudit gates in algorithms [49, 50, 51, 52]. This effectively leads to circuit depth minimization; we would rather run many short high-fidelity circuits than run a few long circuits that produce untrustworthy results. This decision can be validated in the CCSN neutrino problem. If we want to perform a simple first-order Trotterization for some Hamiltonian HH on a quantum computer, we must find a quantum circuit for the time evolution operator exp⁡[−iHδt]\exp[-iH\delta t]. This could be done with an algorithm such as time evolution block decimation (TEBD), where the diagonalization circuit for each block will require two-qubit gates [53]. The number of blocks (and consequently the number of diagonalization circuits required) increases with the number of neutrinos; even for modestly-sized systems, the required number of entangling gates can be on the order of ten to 100 per time step. With current entangling gate fidelities hovering around 99%, these circuits are untenable [51, 52].

For long time integrations of quantum systems, then, other methods are required in the near term. In this paper, we explore the feasibility of a quantum-assisted simulator (QAS) based on the Dirac-Frenkel variational principle for the time evolution of the supernova neutrino system laid out in Sec. II. As we will show, a QAS has the advantage of performing the time evolution classically, leveraging classical computers’ efficiency at matrix multiplication. This leaves the task of calculating the time evolution operator matrix elements to the quantum computer.

Unitary form of Hamiltonian

To find a quantum circuit for our neutrino Hamiltonian HH in Eq. (1), it is natural to use qutrits, which transform in SU⁡(3)\operatorname{SU}(3) identically to neutrino three-flavor states. Unfortunately, unlike the generators of SU⁡(2)\operatorname{SU}(2) (the Pauli matrices), the Gell-Mann matrices are not unitary and cannot be used as gates on qutrits. We thus need to rewrite the Hamiltonian in terms of unitary matrices. In analogy with SU⁡(2)\operatorname{SU}(2), we can define generalized XX and ZZ gates for qutrits [54, 55, 56]

X=(001100010),Z=(1000β000β2)(4)X=\begin{pmatrix}0&0&1\\1&0&0\\0&1&0\end{pmatrix},\qquad Z=\begin{pmatrix}1&0&0\\0&\beta&0\\0&0&\beta^{2}\end{pmatrix} \tag*{(4)}

where β=exp⁡2πi/3\beta=\exp2\pi i/3 is a third root of unity. The XX gate simply cycles the basis states ∣0⟩→∣1⟩→∣2⟩|0\rangle\to|1\rangle\to|2\rangle, while the ZZ gate adds phases to the ∣1⟩|1\rangle and ∣2⟩|2\rangle states. It is straightforward to show that these matrices are unitary, and, using the identity 1+β+β2=01+\beta+\beta^{2}=0, we see that both are traceless. We can then find a set of operators Σ⃗\vec{\Sigma} composed of products of XX and ZZ that are in one-to-one correspondence with the Gell-Mann matrices:

Σ⃗={X,Z,X2,βXZ,Z2,β2XZ2,X2Z,X2Z2}.\vec{\Sigma}=\{X,Z,X^{2},\beta XZ,Z^{2},\beta^{2}XZ^{2},X^{2}Z,X^{2}Z^{2}\}.

Expressions converting the Gell-Mann matrices to these unitary operators and vice versa can be found in Appendix A.

We can now rewrite the Hamiltonian in terms of matrices in Σ⃗\vec{\Sigma}. Writing H=Hν+μ(t)HννH=H_{\nu}+\mu(t)H_{\nu\nu} and defining ωq=qω\omega_q=q\omega and Ωq=qΩ\Omega_q=q\Omega, with ω\omega and Ω\Omega defined in Eq. (2), we derive

Hν=∑q=1nq(εZq+ε∗Zq2)(5)H_{\nu}=\sum_{q=1}^{n}q\left(\varepsilon Z_q+\varepsilon^{*}Z_q^{2}\right) \tag*{(5)}

where

ε=ω1−β26−Ωβ3.\varepsilon=\omega\frac{1-\beta^{2}}{6}-\Omega\frac{\beta}{3}.

We calculate the interaction term as

Hνν≡∑q<q′λ⃗q⋅λ⃗q′=∑q<q′∑i=18λi,q⊗λi,q′=∑q<q′23[Xq⊗Xq′2+Xq2⊗Xq′+Zq⊗Zq′2+Zq2⊗Zq′+β(XqZq2⊗Xq′2Zq′+Xq2Zq⊗Xq′Zq′2)+β2(XqZq⊗Xq′2Zq′2+Xq2Zq2⊗Xq′Zq′)].(6)H_{\nu\nu}\equiv\sum_{q<q'}\vec{\lambda}_q\cdot\vec{\lambda}_{q'}=\sum_{q<q'}\sum_{i=1}^{8}\lambda_{i,q}\otimes\lambda_{i,q'} =\sum_{q<q'}\frac{2}{3}\left[X_q\otimes X_{q'}^{2}+X_q^{2}\otimes X_{q'}+Z_q\otimes Z_{q'}^{2}+Z_q^{2}\otimes Z_{q'}+\beta\left(X_qZ_q^{2}\otimes X_{q'}^{2}Z_{q'}+X_q^{2}Z_q\otimes X_{q'}Z_{q'}^{2}\right)+\beta^{2}\left(X_qZ_q\otimes X_{q'}^{2}Z_{q'}^{2}+X_q^{2}Z_q^{2}\otimes X_{q'}Z_{q'}\right)\right]. \tag*{(6)}

where Xq,ZqX_q,Z_q act on the qqth neutrino and the tensor products are assumed to also contain identity operators for all other momentum states k≠q,q′k\ne q,q'. It is not immediate that HννH_{\nu\nu} is Hermitian, but using the relations XZ=β2ZXXZ=\beta^{2}ZX and β∗=β2\beta^{*}=\beta^{2} this can be verified. For nn neutrinos, there will be 8⋅n(n−1)2=4n(n−1)8\cdot\frac{n(n-1)}{2}=4n(n-1) unitary operators in HννH_{\nu\nu}. These operators also have trivial circuits composed only of single-qutrit gates (e.g., X⊗X2=(X⊗I)⋅(I⊗X2)X\otimes X^{2}=(X\otimes I)\cdot(I\otimes X^{2})), simplifying the forthcoming calculations.

Dirac-Frenkel time evolution

Time evolution of our neutrino system on a quantum computer would normally follow some form of Trotterization, where the state vector is updated over some time step δt\delta t by the application of a time evolution operator circuit, e−iHδte^{-iH\delta t}. This often leads to very deep circuits with many entangling gates for even modest numbers of neutrinos and time steps [34, 57]. We employ a different method to avoid this problem, instead using a quantum-assisted simulator based on the Dirac and Frenkel variational principle [2]. Below we provide a short explanation of the procedure; for a lengthier discussion, see Ref. [29, 58].

Given a state of our system at time tt, ∣ψ(t)⟩|\psi(t)\rangle, we wish to calculate the state at some later t+δtt+\delta t. We first introduce an ansatz basis of states {∣ϕi⟩}i\{|\phi_i\rangle\}_i and corresponding variational parameters {αi(t)∈C}i\{\alpha_i(t)\in\mathbb{C}\}_i that accurately represent the state ∣ψ(t)⟩|\psi(t)\rangle:

∣ψ(t)⟩=∑iαi(t)∣ϕi⟩≡∣ϕ(t)⟩.(7)|\psi(t)\rangle=\sum_i\alpha_i(t)|\phi_i\rangle\equiv|\phi(t)\rangle. \tag*{(7)}

The time-evolved state ∣ψ(t+δt)⟩|\psi(t+\delta t)\rangle may not in general be in the vector space of the ansatz basis states, but for small δt\delta t the approximation is good:

∣ψ(t+δt)⟩≈∣ϕ(t+δt)⟩≈∣ϕ(t)⟩−iδtH∣ϕ(t)⟩.(8)|\psi(t+\delta t)\rangle\approx|\phi(t+\delta t)\rangle\approx|\phi(t)\rangle-i\delta tH|\phi(t)\rangle. \tag*{(8)}

On the other hand, we can expand ∣ϕ(t+δt)⟩|\phi(t+\delta t)\rangle in powers of δαi\delta\alpha_i to obtain

∣ϕ(t+δt)⟩≈∣ϕ(t)⟩+∑i∂∣ϕ(t)⟩∂αiδαi=∣ϕ(t)⟩+∑iδαi(t)∣ϕi⟩.(9)|\phi(t+\delta t)\rangle\approx|\phi(t)\rangle+\sum_i \frac{\partial|\phi(t)\rangle}{\partial\alpha_i}\delta\alpha_i =|\phi(t)\rangle+\sum_i\delta\alpha_i(t)|\phi_i\rangle. \tag*{(9)}

Thus, we need to equate −iδt H∣ϕ(t)⟩-i\delta t\,H|\phi(t)\rangle and ∑iδαi(t)∣ϕi⟩\sum_i\delta\alpha_i(t)|\phi_i\rangle, which can be achieved by projecting directly onto the ansatz space:

(∑iδαi∗(t)⟨ϕi∣)(ddt+iH)∣ϕ(t)⟩=0.(10)\left(\sum_i\delta\alpha_i^*(t)\langle\phi_i|\right)\left(\frac{d}{dt}+iH\right)|\phi(t)\rangle=0 . \tag*{(10)}

This leads to a matrix equation for the time derivatives of the αi\alpha_i parameters:

Eα⃗˙(t)=−iDα⃗(t),(11)\mathcal{E}\dot{\vec{\alpha}}(t)=-i\mathcal{D}\vec{\alpha}(t), \tag*{(11)}

where α⃗={αi}i\vec{\alpha}=\{\alpha_i\}_i and

Eij=⟨ϕi∣ϕj⟩,Dij=⟨ϕi∣H∣ϕj⟩,\mathcal{E}_{ij}=\langle\phi_i|\phi_j\rangle,\qquad\mathcal{D}_{ij}=\langle\phi_i|H|\phi_j\rangle,

along with the unitarity condition α⃗†Eα⃗=1\vec{\alpha}^{\dagger}\mathcal{E}\vec{\alpha}=1. Thus, our dynamical variables are now the variational parameters αi(t)\alpha_i(t), and the resulting differential equation can be easily solved classically. Of course, we are left with the tasks of choosing an ansatz basis and finding the matrix elements of E\mathcal{E} and D\mathcal{D}; we achieve the latter by performing Hadamard tests on a quantum computer.

Qutrit Hadamard test

We can decompose the matrix elements of D\mathcal{D} by noticing that the terms in our Hamiltonian given in Eqs. (5) and (6) are sums of unitary operators, i.e. HH is of the form

H=∑kβkUk+μ(t)∑lγlVl.(12)H=\sum_k\beta_kU_k+\mu(t)\sum_l\gamma_lV_l . \tag*{(12)}

Thus, we can write D\mathcal{D} as time-independent and time-dependent parts, D=DI+μ(t)DD\mathcal{D}=\mathcal{D}^{I}+\mu(t)\mathcal{D}^{D} with

DijI=∑kβk⟨ϕi∣Uk∣ϕj⟩,DijD=∑lγl⟨ϕi∣Vl∣ϕj⟩.(13)\mathcal{D}_{ij}^{I}=\sum_k\beta_k\langle\phi_i|U_k|\phi_j\rangle,\qquad \mathcal{D}_{ij}^{D}=\sum_l\gamma_l\langle\phi_i|V_l|\phi_j\rangle. \tag*{(13)}

In order to calculate both E\mathcal{E} and D\mathcal{D}, we must calculate expectation values of the form ⟨ϕi∣U∣ϕj⟩\langle\phi_i|U|\phi_j\rangle for some unitary operator UU (in the case of E\mathcal{E}, the operator is simply the identity matrix). This can be achieved using the well-known Hadamard test, which calculates expectation values of unitary gates ⟨ψ∣U∣ψ⟩\langle\psi|U|\psi\rangle, but for qutrits instead of qubits [59]. Figure 1 shows the qutrit circuit to calculate the real part of the expectation value using the qutrit Hadamard gate,

Qutrit Hadamard test circuit for calculating the real part of an expectation value

Figure 1. Qutrit Hadamard test to calculate Re⁡⟨ψ∣U∣ψ⟩\operatorname{Re}\langle\psi|U|\psi\rangle. The expectation value is derived from the measurement probabilities on the ancillary qutrit; see text for the exact equation. Note that the qutrit Hadamard gate is not Hermitian (H≠H†H \ne H^\dagger).

H=13(1111ββ21β2β).H=\frac{1}{\sqrt{3}} \begin{pmatrix} 1 & 1 & 1\\ 1 & \beta& \beta^2\\ 1 & \beta^2 & \beta \end{pmatrix}.

of the expectation value using the qutrit Hadamard gate,

H=13(1111ββ21β2β).H=\frac{1}{\sqrt{3}} \begin{pmatrix} 1 & 1 & 1\\ 1 & \beta& \beta^2\\ 1 & \beta^2 & \beta \end{pmatrix}.

Re⁡⟨ψ∣U∣ψ⟩\operatorname{Re}\langle\psi|U|\psi\rangle is derived from the probability of measuring the three computational basis states of the ancillary qutrit:

P(0)=19[5+2⟨ψ∣(U†+U)∣ψ⟩],P(0)=\frac{1}{9}\left[5+2\langle\psi|(U^\dagger+U)|\psi\rangle\right],
P(1)=19[2−⟨ψ∣(U†+U)∣ψ⟩],P(1)=\frac{1}{9}\left[2-\langle\psi|(U^\dagger+U)|\psi\rangle\right],
P(2)=P(1).P(2)=P(1).

Thus,

Re⁡⟨ψ∣U∣ψ⟩=12⟨ψ∣(U†+U)∣ψ⟩=P(0)−54(P(1)+P(2)).(14)\operatorname{Re}\langle\psi|U|\psi\rangle =\frac{1}{2}\langle\psi|(U^\dagger+U)|\psi\rangle =P(0)-\frac{5}{4}\left(P(1)+P(2)\right). \tag*{(14)}

The imaginary part of ⟨ψ∣U∣ψ⟩\langle\psi|U|\psi\rangle can be calculated with a similar circuit, shown in Figure 2. This circuit uses the Hermitian conjugate of the qutrit S gate,

Qutrit Hadamard test circuit for calculating the imaginary part of an expectation value

Figure 2. Qutrit Hadamard test to calculate Im⁡⟨ψ∣U∣ψ⟩\operatorname{Im}\langle\psi|U|\psi\rangle.

S=(10000β00β).S= \begin{pmatrix} 1 & 0 & 0\\ 0 & 0 & \sqrt{\beta}\\ 0 & 0 & \beta \end{pmatrix}.

It can be shown straightforwardly that

Im⁡⟨ψ∣U∣ψ⟩=334[P(0)−P(2)].(15)\operatorname{Im}\langle\psi|U|\psi\rangle=\frac{3\sqrt{3}}{4}\left[P(0)-P(2)\right]. \tag*{(15)}

Now, we are almost ready to use the Hadamard test circuits to calculate E\mathcal{E}, DI\mathcal{D}^{I}, and DD\mathcal{D}^{D}. We notice, however, that the Hadamard tests assume the same state sandwiching the unitary operator, while our matrices’ off-diagonal elements contain different ⟨ϕi∣\langle\phi_i| and ∣ϕj⟩|\phi_j\rangle. Thus, we must express the ∣ϕi⟩|\phi_i\rangle in terms of a common state, i.e. ∣ϕi⟩=Ai∣ϕ0⟩|\phi_i\rangle=A_i|\phi_0\rangle for some unitary matrix AiA_i and state ∣ϕ0⟩|\phi_0\rangle. Then, to calculate ⟨ϕi∣U∣ϕj⟩=⟨ϕ0∣Ai†UAj∣ϕ0⟩\langle\phi_i|U|\phi_j\rangle=\langle\phi_0|A_i^\dagger U A_j|\phi_0\rangle, we replace the unitary operator UU in the Hadamard test with Ai†UAjA_i^\dagger U A_j. Luckily, our procedure for building the ansatz basis states gives us these AiA_i directly.

Ansatz basis

The central idea behind building the ansatz basis for the quantum-assisted simulator is to find states that are likely to strongly overlap with the ”true” wavefunction ∣ψ(t)⟩|\psi(t)\rangle, given an initial state ∣ψ(0)⟩|\psi(0)\rangle. For a time-dependent Hamiltonian such as ours in

Eq. (1), the time evolution operator e−iHδte^{-iH\delta t} can be written as a sum of commutators of the Hamiltonian with itself (e.g., in a Magnus expansion [60]). Thus, our initial state ∣ψ(0)⟩|\psi(0)\rangle will be acted on by unitary matrices contained in such operators, so it would be advantageous for our ansatz to be comprised of states of the form

∣ϕi⟩=Ai∣ψ(0)⟩,|\phi_i\rangle= A_i|\psi(0)\rangle,
Ai∈{U∈U(3):U∈∑kckCk, ck∈C},A_i \in\left\{ U \in U(3): U \in\sum_k c_k C_k,\ c_k \in\mathbb{C} \right\},
Ck∈{I,Hν,[Hν,Hνν],[Hν,[Hν,Hνν]],…}.C_k \in\{I,H_\nu,[H_\nu,H_{\nu\nu}],[H_\nu,[H_\nu,H_{\nu\nu}]],\ldots\}.

Here, U(3)U(3) denotes the group of 3×33 \times3 unitary matrices. That is, we want the AiA_i to be unitary operators that are contained somewhere in the time evolution operator. We set A0=IA_0=I so that ∣ϕ0⟩=∣ψ(0)⟩|\phi_0\rangle=|\psi(0)\rangle; it will be this state that will be the initial prepared state in the Hadamard tests discussed in the previous section.

While this procedure produces a set of states that can be whittled down to a useable basis {Ai}\{A_i\}, we still need to find quantum circuits for each AiA_i to calculate E\mathcal{E} and D\mathcal{D}. This is achievable given that all the AiA_i are some combination of commutators of unitary matrices in the Hamiltonian, but procedurally generating them for any number of neutrinos is

ω0\omega_0 (eV)μ0(ω0)\mu_0(\omega_0)Rν(ω0−1)R_\nu(\omega_0^{-1})r0(ω0−1)r_0(\omega_0^{-1})EE (MeV)
10−1010^{-10}3.62×1043.62 \times10^432.232.2210.64210.641010
θ12\theta_{12} (deg)θ23\theta_{23} (deg)θ13\theta_{13} (deg)δm2\delta m^2 (eV2^2)Δm2\Delta m^2 (eV2^2)
33.4133.4149.149.18.548.547.4×10−57.4 \times10^{-5}2.51×10−32.51 \times10^{-3}
ω0\omega_0 (eV)μ0(ω0)\mu_0(\omega_0)Rν(ω0−1)R_\nu(\omega_0^{-1})r0(ω0−1)r_0(\omega_0^{-1})EE (MeV)
10−1010^{-10}3.62×1043.62 \times10^432.232.2210.64210.641010
θ12\theta_{12} (deg)θ23\theta_{23} (deg)θ13\theta_{13} (deg)δm2\delta m^2 (eV2^2)Δm2\Delta m^2 (eV2^2)
33.4133.4149.149.18.548.547.4×10−57.4 \times10^{-5}2.51×10−32.51 \times10^{-3}

Table 1. Values of quantities used in this analysis. We assume natural units c=ℏ=1c=\hbar=1, and units are shown in parentheses.

nontrivial. To simplify this, we choose to define our ansatz basis such that the AiA_i are easily translated into quantum circuits.

Defining the set X={I,X,X2}\mathcal{X}=\{I,X,X^2\}, we build the AiA_i by taking every possible tensor product combination of the elements of X\mathcal{X} for nn neutrinos. Thus, Ai=Xi1⊗Xi2⊗…⊗XinA_i=X^{i_1}\otimes X^{i_2}\otimes\ldots\otimes X^{i_n}, with the exponents ij∈{0,1,2}i_j\in\{0,1,2\}, j=1,…,nj=1,\ldots,n. Again, using this procedure A0=IA_0=I (ij=0 ∀ji_j=0\ \forall j). Further, this choice of basis makes the circuits for the AiA_i trivial (simply applications of XX and X2X^2 gates on requisite qutrits). From our testing, we find this choice of basis does not produce appreciable errors, at least compared to other sources of errors. We also looked at different definitions of X\mathcal{X}, for example using powers of XZXZ instead of XX, and found no significant difference in performance. We note that this ansatz basis is not orthogonal, which is not a particular problem since the Dirac–Frenkel method does not require orthogonality as any overlap in states is taken into account in the Eij=⟨ϕi∣ϕj⟩\mathcal{E}_{ij}=\langle\phi_i|\phi_j\rangle matrix. However, this does mean that our 3n3^n states do not fully span the entire Hilbert space; by building the basis with XX gates applied to our initial state, it is expected that the basis states will have high overlap with the state at time tt, ∣ψ(t)⟩=e−iHt∣ψ(0)⟩|\psi(t)\rangle=e^{-iHt}|\psi(0)\rangle, given that the time evolution operator contains a sum of commutators of the Hamiltonian with itself (the terms in CkC_k above).

Results

We considered a four neutrino system with three flavors described by Eq. (1) in the initial state ∣eeμτ⟩|ee\mu\tau\rangle, with the first neutrino having the lowest energy (in this case, the first νe\nu_e). In the following analysis, we use the variable ω0=10−10\omega_0=10^{-10} eV as the energy scale of the neutrino vacuum oscillations and redefined dimensionful quantities in terms of this scale. We calculated the E\mathcal{E}, D\mathcal{D}, and DD\mathcal{D}^D matrices by simulating quantum Hadamard test circuits for each matrix element as described in Sec. III C. We simulated each Hadamard circuit 2,000,000 times using the QuForge[61] qudit simulation package to obtain estimates of the measurement probabilities on the ancillary qutrit, and each matrix element was independently calculated 65 times. Then, for each run, we simulated the time evolution of the α⃗(t)\vec{\alpha}(t) (Eq. (11)) classically with time step δt=0.005 ω0−1\delta t=0.005\,\omega_0^{-1} out to final time tf=5000 ω0−1t_f=5000\,\omega_0^{-1} using the scipy.integrate.solve_ivp method with the DOP853 eighth-order Runge–Kutta method [62]. This time step δt\delta t was chosen to be small enough to fully resolve the flavor oscillations, and we chose tft_f such that the mass state probability and entropy reach constant, asymptotic values for each neutrino. We also solved the Schrödinger equation explicitly, again using scipy.integrate.solve_ivp to find ∣ψ(t)⟩|\psi(t)\rangle in the interval [0,tf][0,t_f]. In the following text and figures, the Dirac-Frenkel method is referred to as “DF” and/or drawn in solid lines, while the numerical Schrödinger equation solution is called “ODE” or “Exact ODE” and/or drawn in dashed lines.

Figure 3 shows the survival probability of our initial ∣eeμτ⟩|ee\mu\tau\rangle state, defined as P(surv.)=∣⟨eeμτ∣ψ(t)⟩∣2P(\mathrm{surv.})=\lvert\langle ee\mu\tau|\psi(t)\rangle\rvert^2, at early times (left) and late times (right) calculated with the DF hybrid algorithm. We see that the median of the hybrid algorithm runs (shown in black) matches the numerical solution (red dotted line) fairly well, although as the integration continues, the amplitude of the oscillations becomes damped. This damping is caused by slight variations in the time evolution matrices E\mathcal{E} and D\mathcal{D} of the 65 runs that are being averaged over, and taken to late times causes a complete loss of any signal. However, each individual run still has nontrivial oscillations in the survival probability, as highlighted by the wide range of hybrid algorithm data (blue band in the figure), even at late times.

Figure 3. Survival probability of an initial ∣eeμτ⟩|ee\mu\tau\rangle state, calculated with the Dirac-Frenkel quantum-assisted simulator (median in black and total range in blue), first-order simulated Trotterization (green dotted), and a numerical integration (red dashed). Each Hadamard test in the hybrid simulator used nshots=2000000n_{\mathrm{shots}}=2000000 shots, and the simulation was repeated nruns=65n_{\mathrm{runs}}=65 times. The Trotter circuit was calculated with δt=0.005ω0\delta t=0.005\omega_0. At late times, the hybrid algorithm loses any resemblance to the exact calculation.

Figure 4 shows the probability of finding each neutrino qq from the initial ∣eeμτ⟩|ee\mu\tau\rangle state in the ithi^{\mathrm{th}} mass state ∣νi⟩|\nu_i\rangle over time, defined as Pmi,q(t)=tr⁡[ρq(t)Πi,q]P_{m_i,q}(t)=\operatorname{tr}[\rho_q(t)\Pi_{i,q}] where Πi,q=(⨂k≠q1k)∣νi⟩⟨νi∣q\Pi_{i,q}=\left(\bigotimes_{k\ne q}\mathbb{1}_k\right)|\nu_i\rangle\langle\nu_i|_q and ρq\rho_q is the reduced density matrix for the qthq^{\mathrm{th}} neutrino. We see a similar phenomenon occurring here as in Figure 3, where the hybrid algorithm slowly deviates from the exact solution (dotted lines) due to small deviations in the time evolution matrices. By the time we reach the asymptotic region, the data from the various hybrid algorithm runs have been smoothed out and no longer resembles the expected behavior.

Figure 4. Mass state probability of each particle from an initial ∣eeμτ⟩|ee\mu\tau\rangle state, calculated with the Dirac-Frenkel quantum-assisted simulator (solid lines) and a numerical integration (dotted lines). Data from the same run as in Figure 3.

We again find a similar story in Figure 5, which shows the von Neumann entropy of the four neutrinos as a function of time. The von Neumann entropy for the ithi^{\mathrm{th}} neutrino is defined as

Figure 5. Von Neumann entropy of each particle from an initial ∣eeμτ⟩|ee\mu\tau\rangle state, calculated with the Dirac-Frenkel quantum-assisted simulator (solid lines) and a classical numerical integration (dotted lines). Data from the same run as in Figure 3.

SVN,i(t)=−tr⁡(ρiln⁡ρi),S_{VN,i}(t)=-\operatorname{tr}(\rho_i\ln\rho_i),

where ρi\rho_i is the reduced density matrix for the ithi^{\mathrm{th}} neutrino. The oscillations in entropy become damped over time such that at late times the asymptotic values deviate from the exact solution.

Error Analysis

Despite the deviations from the exact numerical integration results that we saw in the previous section, the Dirac-Frenkel quantum variational method is still useful to avoid common pitfalls in current noisy quantum time evolution simulations. Circuit depth that scales with the number of time steps and Trotterization errors from building circuits for the time evolution operator e−iH^δte^{-i\hat{H}\delta t} are two barriers that limit quantum computers’ effectiveness in the near-term, and the hybrid algorithm avoids both. However, the hybrid algorithm, like any numerical computation, has its own limitations. The dimension of the E\mathcal{E} and D\mathcal{D} matrices still scales as 3n3^n, and the number of unitary operators in the Hamiltonian increases with the system size as well. Thus, the number of Hadamard tests that need to be performed increases faster than 3n3^n, requiring much more quantum computing time for larger systems.

Another issue that arose during our study was the error of E\mathcal{E} and D\mathcal{D} matrix elements due to the probabilistic nature of quantum measurement. The α\alpha-norm is defined as α⃗†Eα⃗\vec{\alpha}^{\dagger}\mathcal{E}\vec{\alpha} is equal to one assuming E\mathcal{E} and D\mathcal{D} are Hermitian. To quantify the effect of matrix errors on the simulation results, we performed the following analysis: (1) the α⃗\vec{\alpha}-vector was calculated exactly using a classical numerical method, denoted α⃗cl\vec{\alpha}_{\mathrm{cl}}; (2) “noisy” E\mathcal{E} and D\mathcal{D} matrices were produced by injecting random complex-valued Gaussian noise into each matrix element of the classically-calculated matrices for multiple different magnitudes of noise; (3) α⃗(t)\vec{\alpha}(t) was calculated using the noisy evolution matrices by the same numerical integration used from the Dirac-Frenkel method in the main analysis of this paper; (4) the overlap α⃗cl†Eclα⃗(t)\vec{\alpha}_{\mathrm{cl}}^{\dagger}\mathcal{E}_{\mathrm{cl}}\vec{\alpha}(t) was calculated, where Ecl\mathcal{E}_{\mathrm{cl}} is the E\mathcal{E} with no injected noise. Crucially, we maintain the Hermiticity of the noisy E\mathcal{E} and D\mathcal{D} matrices by producing random noise only for the upper triangular portion of the matrix and adding the complex conjugate of that noise to the lower triangular part. This matches how we calculate these matrices in the Dirac-Frenkel method, where we assume the matrices are Hermitian and thus only perform Hadamard tests for the upper triangular part of the matrices. (As an example, for two ansatz basis states ∣ϕi⟩|\phi_i\rangle and ∣ϕj⟩|\phi_j\rangle, (Dij)†=(⟨ϕi∣H∣ϕj⟩)†=⟨ϕj∣H∣ϕi⟩=Dji(D_{ij})^\dagger= (\langle\phi_i|H|\phi_j\rangle)^\dagger= \langle\phi_j|H|\phi_i\rangle= D_{ji}).

The deviation of the noisy values α⃗(t)\vec{\alpha}(t) from the noiseless α⃗cl\vec{\alpha}_{\mathrm{cl}} can be quantified with the measure 1−α⃗cl†Eclα⃗(t)1-\vec{\alpha}_{\mathrm{cl}}^{\dagger}\mathcal{E}_{\mathrm{cl}}\vec{\alpha}(t). In Figure 6, we plot the absolute value of this measure as a function of integration time for different magnitudes of injected matrix error. Not surprisingly, the larger the error in the evolution matrices, the larger the deviation from the numerical results. Also, this deviation increases with time, setting an effective maximum time limit for the simulation.

Figure 6. Error in the norm α⃗clTEα⃗\vec{\alpha}_{cl}^{T}\mathcal{E}\vec{\alpha} as a function of integration time for different evolution matrix error scales, where α⃗cl\vec{\alpha}_{cl} is the α\alpha vectors computed with classically-calculated evolution matrices (as opposed to Hadamard test circuits as done in the main analysis). We take the initial state of the system to be ∣eeμτ⟩|ee\mu\tau\rangle as in the main analysis. As the error in the matrix elements and integration time increase, so too does the deviation from the classical result.

We see that below a matrix error of ∼10−2\sim10^{-2}, the error in the α\alpha-norm remains below 1% out to time t≈20ω0−1t\approx20\omega_0^{-1}, while errors 10−210^{-2} and larger quickly deviate from the classical values (over 10% by t=20ω0−1t=20\omega_0^{-1}). Thus, in order to achieve satisfactory results from the Dirac-Frenkel hybrid algorithm, errors in the time evolution matrices must be kept very small.

The simplest method to decrease these matrix errors is to simply run more shots in the Hadamard tests that calculate the time evolution matrix elements. In our calculations of the four neutrino system above, we achieved matrix errors averaging about 10−210^{-2} with 2×1062\times10^{6} shots; this produced results reasonably close to the classical calculation out to times on the order of 10−30ω0−110-30\omega_0^{-1}. The addition of gate noise would of course build upon the shot noise from the measurement of the Hadamard circuits. Our analysis here is agnostic to the source of the noise, so we can determine an estimate for the accuracy of a particular simulation given the number of shots per Hadamard test and gate fidelity. For example, a two-qutrit gate fidelity of 99.9% in the Hadamard tests would introduce to the time evolution matrices an error of ∼1%\sim1\%, which according to Figure 6 would still keep the simulation accurate to ∼1%\sim1\% level out to t=20ω0−1t=20\omega_0^{-1} (assuming no shot noise). See § 2 for further discussion of the impact of two-qutrit (entangling) gate fidelity on the performance of the Hadamard tests in the Dirac-Frenkel method.

Discussion

The Dirac-Frenkel quantum-assisted simulator, in the current context of quantum computing, provides a workaround for current NISQ quantum devices: instead of attempting to evaluate a long, deep time evolution circuit, we can perform many short Hadamard test circuits to calculate the time evolution operator which is used for classical time integration.

Nevertheless, there are many algorithmic and computational hurdles that still exist for the Dirac-Frenkel hybrid simulator, some of which we have highlighted here in this study. Most glaringly, the results from this method depend strongly on how accurately the time evolution matrix elements are calculated by the quantum Hadamard tests. Increased accuracy will allow for longer time integrations, but determining this required accuracy for a given time interval is a nontrivial task. Because of the probabilistic nature of measuring Hadamard tests, better accuracy can be achieved simply by running more shots per circuit, as in the limit nshots→∞n_{shots} \to\infty the matrix elements should approach the classically calculated values. Thus, unlike errors in other quantum time evolution algorithms such as Trotterization, there is a very clear path to mitigating these matrix element errors–throw more computing time at the problem.

The Dirac-Frenkel hybrid algorithm also does not solve the issue of classically simulating a Hilbert space that scales exponentially with the number of neutrinos. As mentioned in the previous section on error analysis, the number of degrees of freedom of the system scales as 3n3^n which still needs to be time-evolved on a classical computer. The Dirac-Frenkel equations comprise a system of coupled first-order ordinary differential equations, which, while certainly easy to solve in the grand scheme of differential equations, still require considerable compute time and memory as the number of equations increases. For a 20 neutrino system, the matrix dimension would already be over three billion. One way to mitigate this exponential scaling is to cull the size of the ansatz basis to keep only states with amplitudes over some threshold within the first few time steps. Indeed, this is perhaps the greatest strength of this type of algorithm: we are free to choose our ansatz basis as we please, as long as that choice preserves the data of the system up to some tolerance. For our small four neutrino state, we chose not to decrease the size of the basis; as the number of neutrinos increases, it seems almost mandatory to do so to make the problem tractable. We leave the study of strategies for ansatz basis culling to a later date.

Comparison to Trotterization

As mentioned in the error analysis subsection above, the more pressing scaling issue with this hybrid algorithm is the exponential increase in the number of Hadamard tests required in order to calculate the time evolution matrices E\mathcal{E} and D\mathcal{D}. The number of Hadamard tests needed is equal to ntests=nU⋅nbasis⋅nshots⋅nrunsn_{tests}=n_U \cdot n_{basis} \cdot n_{shots} \cdot n_{runs}, where nUn_U is the number of unitary operators in the Hamiltonian, nbasisn_{basis} is the size of the ansatz basis, nshotsn_{shots} is the number of shots per circuit, and nrunsn_{runs} is the number of independent runs of the system to average over. In our study, with four neutrinos, nU=56n_U=56, nshots=2×106n_{shots}=2 \times10^6, and nruns=65n_{runs}=65, we had to take ∼5.8×1011\sim5.8 \times10^{11} measurements of Hadamard circuits. Of course, simulating these tests on a classical computer allows for some parallelization, but applying this method to quantum hardware does not benefit from this speedup.

Despite these drawbacks, the Dirac-Frenkel hybrid algorithm offers an improvement in time evolution calculations over Trotterization on NISQ devices for several reasons. First, there is no requirement to build a circuit for the time evolution operator exp⁡(−iHδt)\exp(-iH\delta t), which in general is a matrix sum of nested commutators of the Hamiltonian with itself. This almost always requires some form of approximation, for example in time evolution block decimation (TEBD), which introduces errors that scale polynomially with the time step. Second, the hybrid algorithm avoids deep Trotterization circuits that are plagued by unsatisfactory fidelities on entangling gates. While it is true that the Hadamard test also contains entangling gates (since the Hamiltonian unitary operator and ansatz basis operators needs to be controlled by the ancilla qutrit), the number of these gates stays relatively small.

Quantitatively, for our particular system, the maximum number of entangling gates for a Hadamard test of Dij⊃⟨ϕi∣U∣ϕj⟩=⟨ϕ0∣Ai†UAj∣ϕ0⟩D_{ij} \supset\langle\phi_i|U|\phi_j\rangle= \langle\phi_0|A_i^\dagger U A_j|\phi_0\rangle is 12: four each for the Ai†A_i^\dagger and AjA_j circuits (which are at most four XX or X2X^2 gates) and four from one of the unitary operators in the interaction Hamiltonian HννH_{\nu\nu}. In contrast, a first-order Trotterization circuit representing e−iHδte^{-iH\delta t} also requires 12 entangling gates. The crucial difference is that any Trotterization error continues to accumulate with each time step, while the Hadamard tests are all independent, short calculations. Also importantly, the size and depth of the Hadamard tests increase linearly with the number of neutrinos (due to the application of the ansatz basis operators Ai†A_i^\dagger and AjA_j), since our Hamiltonian only contains unitary operations between at most two neutrinos. In contrast, for a first-order Trotter circuit of the neutrino collective oscillation Hamiltonian, the number of entangling gates required goes as n(n−1)n(n-1) per time step, and Trotter error still scales as O(δt2)O(\delta t^2). To reiterate, however, the Dirac-Frenkel method achieves this better scaling by requiring many more (shorter) circuits to be run, although these circuits contain very basic gates such as controlled-X and controlled-Z gates.

Summary & Conclusions

We performed a hybrid quantum-classical time evolution simulation based on the Dirac-Frenkel variational principle for a core-collapse supernova neutrino system. We found that for our initial four neutrino coherent flavor state the hybrid algorithm matches the exact numerical result out to times of around t≈20−30ω0−1t \approx20 - 30\omega_0^{-1} with time step δt=0.005ω0−1\delta t = 0.005\omega_0^{-1}, where ω0\omega_0 is the energy scale of the single neutrino vacuum oscillations. This time resolution over this integration time is currently impossible using a Trotterization circuit on NISQ devices given the state of entangling gate fidelities.

While the Dirac-Frenkel hybrid algorithm has its own drawbacks and exponential scaling issues, it offers a usable and easily-implementable method to study physical systems on current quantum hardware. Further improvements to the results shown in this paper can be achieved by increasing the computation time theoretically to any precision, as the error in the quantum-calculated time evolution matrices goes to zero as the number of measurement shots goes to infinity. While we hope and expect quantum computers will become more reliable and capable of longer computations in the future, the Dirac-Frenkel hybrid algorithm and quantum-assisted simulators like it are one of the best choices for leveraging quantum hardware today to study physical systems.

Acknowledgments

This material is based upon work supported in part by the U.S. Department of Energy, Office of Science, Office of Nuclear Physics, under the FRIB Theory Alliance award DE-SC0013617. It was also supported in part by the U.S. National Science Foundation Award PHY-2411495.

ZX matrices from Gell-Mann matrices

The operator basis for the ZXZX algebra is

Σ⃗={1,X,Z,X2,βXZ,Z2,β2XZ2,X2Z,X2Z2}.(16)\vec{\Sigma} = \{1, X, Z, X^2, \beta XZ, Z^2, \beta^2 XZ^2, X^2Z, X^2Z^2\}. \tag*{(16)}

The basis elements can be written as linear combinations of the Gell-Mann matrices (including an “identity” Gell-Mann matrix λ0\lambda_0):

1=λ0,1 = \lambda_0,
X=12[(λ1−iλ2)+(λ4+iλ5)+(λ6−iλ7)],X = \frac{1}{2}\left[(\lambda_1-i\lambda_2)+(\lambda_4+i\lambda_5)+(\lambda_6-i\lambda_7)\right],
Z=12(1−β)(λ3+iλ8),Z = \frac{1}{2}(1-\beta)(\lambda_3+i\lambda_8),
X2=12[(λ1+iλ2)+(λ4−iλ5)+(λ6+iλ7)],X^2 = \frac{1}{2}\left[(\lambda_1+i\lambda_2)+(\lambda_4-i\lambda_5)+(\lambda_6+i\lambda_7)\right],
βXZ=12[β(λ1−iλ2)+(λ4+iλ5)+β2(λ6−iλ7)],\beta XZ = \frac{1}{2}\left[\beta(\lambda_1-i\lambda_2)+(\lambda_4+i\lambda_5)+\beta^2(\lambda_6-i\lambda_7)\right],
Z2=12(1−β2)(λ3−iλ8),Z^2 = \frac{1}{2}(1-\beta^2)(\lambda_3-i\lambda_8),
β2XZ2=12[β2(λ1−iλ2)+(λ4+iλ5)+β(λ6−iλ7)],\beta^2XZ^2 = \frac{1}{2}\left[\beta^2(\lambda_1-i\lambda_2)+(\lambda_4+i\lambda_5)+\beta(\lambda_6-i\lambda_7)\right],
X2Z=12[β(λ1+iλ2)+(λ4−iλ5)+β2(λ6+iλ7)],X^2Z = \frac{1}{2}\left[\beta(\lambda_1+i\lambda_2)+(\lambda_4-i\lambda_5)+\beta^2(\lambda_6+i\lambda_7)\right],
X2Z2=12[β2(λ1+iλ2)+(λ4−iλ5)+β(λ6+iλ7)].X^2Z^2 = \frac{1}{2}\left[\beta^2(\lambda_1+i\lambda_2)+(\lambda_4-i\lambda_5)+\beta(\lambda_6+i\lambda_7)\right].

Note that these operators can also be written in terms of the su(2)\mathfrak{su}(2) subalgebra raising and lowering operators I±=λ1±iλ2I^{\pm} = \lambda_1 \pm i\lambda_2, U±=λ4±iλ5U^{\pm} = \lambda_4 \pm i\lambda_5, and V±=λ6±λ7V^{\pm} = \lambda_6 \pm\lambda_7 and two “number operators” N±=λ3±iλ8N^{\pm} = \lambda_3 \pm i\lambda_8. It is easy to check that, while these matrices are not Hermitian, they are unitary.

The inverse relations to those above are:

λ0=1,\lambda_0 = 1 ,
λ1=13[X(1+Z+Z2)+X2(1+β2Z+βZ2)],\lambda_1 = \frac{1}{3}\left[X(1+Z+Z^2)+X^2(1+\beta^2 Z+\beta Z^2)\right] ,
λ2=i3[X(1+Z+Z2)−X2(1+β2Z+βZ2)],\lambda_2 = \frac{i}{3}\left[X(1+Z+Z^2)-X^2(1+\beta^2 Z+\beta Z^2)\right] ,
λ3=13[(1−β2)Z+(1−β)Z2],\lambda_3 = \frac{1}{3}\left[(1-\beta^2)Z+(1-\beta)Z^2\right] ,
λ4=13[X(1+βZ+β2Z2)+X2(1+Z+Z2)],\lambda_4 = \frac{1}{3}\left[X(1+\beta Z+\beta^2 Z^2)+X^2(1+Z+Z^2)\right] ,
λ5=−i3[X(1+βZ+β2Z2)−X2(1+Z+Z2)],\lambda_5 = \frac{-i}{3}\left[X(1+\beta Z+\beta^2 Z^2)-X^2(1+Z+Z^2)\right] ,
λ6=13[X(1+β2Z+βZ2)+X2(1+βZ+β2Z2)],\lambda_6 = \frac{1}{3}\left[X(1+\beta^2 Z+\beta Z^2)+X^2(1+\beta Z+\beta^2 Z^2)\right] ,
λ7=i3[X(1+β2Z+βZ2)−X2(1+βZ+β2Z2)],\lambda_7 = \frac{i}{3}\left[X(1+\beta^2 Z+\beta Z^2)-X^2(1+\beta Z+\beta^2 Z^2)\right] ,
λ8=−13(βZ+β2Z2).\lambda_8 = \frac{-1}{\sqrt{3}}\left(\beta Z+\beta^2 Z^2\right) .

These can be easily verified using the definitions of XX and ZZ and the relation 1+β+β2=01+\beta+\beta^2=0. Further, the translation matrix UU satisfying Σ⃗=Uλ⃗\vec{\Sigma}=U\vec{\lambda}, where Σ⃗\vec{\Sigma} and λ⃗\vec{\lambda} are 8-vectors of the ZX basis matrices and Gell-Mann matrices (excluding 1\mathbb{1} and λ0\lambda_0), respectively, is given by

Uij=12Tr⁡(Σiλj).(17)U_{ij}=\frac{1}{2}\operatorname{Tr}(\Sigma_i\lambda_j) . \tag*{(17)}

References

References

  1. [1]M. Cerezo, K. Sharma, A. Arrasmith, and P. J. Coles, Variational quantum state eigensolver, npj Quantum Information 8, 113 (2022).DOI
  2. [2]X. Yuan, S. Endo, Q. Zhao, Y. Li, and S. C. Benjamin, Theory of variational quantum simulation, Quantum 3, 191 (2019).DOI
  3. [3]H. Duan, G. M. Fuller, and Y.-Z. Qian, Collective Neutrino Oscillations, Ann. Rev. Nucl. Part. Sci. 60, 569 (2010), arXiv:1001.2799 [hep-ph].DOI
  4. [4]S. Chakraborty, R. Hansen, I. Izaguirre, and G. Raffelt, Collective neutrino flavor conversion: Recent developments, Nucl. Phys. B 908, 366 (2016), arXiv:1602.02766 [hep-ph].DOI
  5. [5]A. B. Balantekin, Symmetries and Algebraic Methods in Neutrino Physics, J. Phys. G 45, 113001 (2018), arXiv:1809.02539 [hep-ph].arxiv.org/abs/1809.02539
  6. [6]I. Tamborra and S. Shalgar, New Developments in Flavor Evolution of a Dense Neutrino Gas, Ann. Rev. Nucl. Part. Sci. 71, 165 (2021), arXiv:2011.01948 [astro-ph.HE].DOI
  7. [7]M. C. Volpe, Neutrinos from dense environments: Flavor mechanisms, theoretical approaches, observations, and new directions, Rev. Mod. Phys. 96, 025004 (2024), arXiv:2301.11814 [hep-ph].
  8. [8]A. B. Balantekin, M. J. Cervia, A. V. Patwardhan, E. Rapaj, and P. Siwach, Quantum information and quantum simulation of neutrino physics, Eur. Phys. J. A 59, 186 (2023), arXiv:2305.01150 [nucl-th].DOI
  9. [9]L. Johns, S. Richers, and M.-R. Wu, Neutrino Oscillations in Core-Collapse Supernovae and Neutron Star Mergers, Ann. Rev. Nucl. Part. Sci. 75, 399 (2025), arXiv:2503.05959 [astro-ph.HE].DOI
  10. [10]M. J. Cervia, A. V. Patwardhan, A. B. Balantekin, S. N. Coppersmith, and C. W. Johnson, Entanglement and collective flavor oscillations in a dense neutrino gas, Phys. Rev. D 100, 083001 (2019).DOI
  11. [11]M. J. Cervia, P. Siwach, A. V. Patwardhan, A. B. Balantekin, S. N. Coppersmith, and C. W. Johnson, Collective neutrino oscillations with tensor networks using a time-dependent variational principle, Phys. Rev. D 105, 123025 (2022), arXiv:2202.01865 [hep-ph].
  12. [12]D. Lacroix, A. B. Balantekin, M. J. Cervia, A. V. Patwardhan, and P. Siwach, Role of non-gaussian quantum fluctuations in neutrino entanglement, Phys. Rev. D 106, 123006 (2022).DOI
  13. [13]A. V. Patwardhan, M. J. Cervia, E. Rapaj, P. Si- wach, and A. B. Balantekin, Many-Body Collective Neutrino Oscillations: Recent Developments, in Handbook of Nuclear Physics, edited by I. Tanihata, H. Toki, and T. Kajino (2023) pp. 1–16, arXiv:2301.00342 [hep-ph].
  14. [14]M. Illa and M. J. Savage, Multi-Neutrino Entanglement and Correlations in Dense Neutrino Systems, Phys. Rev. Lett. 130, 221003 (2023), arXiv:2210.08656 [nucl-th].DOI
  15. [15]J. D. Martin, D. Neill, A. Roggero, H. Duan, and J. Carlson, Equilibration of Quantum many-body fast neutrino flavor oscillations, Phys. Rev. D 108, 123010 (2023), arXiv:2307.16793 [hep-ph].arxiv.org/abs/2307.16793
  16. [16]J. D. Martin, A. Roggero, H. Duan, J. Carlson, and V. Cirigliano, Classical and quantum evolution in a simple coherent neutrino problem, Phys. Rev. D 105, 083020 (2022), arXiv:2112.12686 [hep-ph].DOI
  17. [17]J. D. Martin, A. Roggero, H. Duan, and J. Carlson, Many-body neutrino flavor entanglement in a simple dynamic model, arXiv:2301.07049 [hep-ph] (2023).arxiv.org/abs/2301.07049
  18. [18]D. Lacroix, A. Bauge, B. Yilmaz, M. Mangin-Brinet, A. Roggero, and A. B. Balantekin, Phase-space methods for neutrino oscillations: Extension to multibeams, Phys. Rev. D 110, 103027 (2024), arXiv:2409.20215 [hep-ph].arxiv.org/abs/2409.20215
  19. [19]J. Carlson, A. Roggero, and D. Neill, Neutrino Flavor Evolution in High Flux Astrophysical Environments, arXiv:2603.12192 [hep-ph] (2026).arxiv.org/abs/2603.12192
  20. [20]D. Neill, H. Liu, J. Martin, and A. Roggero, Scattering neutrinos, spin models, and permutations, Phys. Rev. Res. 7, 023157 (2025), arXiv:2406.18677 [hep-ph].arxiv.org/abs/2406.18677
  21. [21]I. Chernyshev, C. E. P. Robin, and M. J. Savage, Quantum magic and computational complexity in the neutrino sector, Phys. Rev. Res. 7, 023228 (2025), arXiv:2411.04203 [quant-ph].arxiv.org/abs/2411.04203
  22. [22]R. Bhaskar, A. Roggero, and M. J. Savage, Timescales in many-body fast-neutrino-flavor conversion, Phys. Rev. C 110, 045801 (2024).
  23. [23]O. Kiss, I. Tavernelli, F. Tacchino, D. Lacroix, and A. Roggero, Neutrino thermalization via randomization on a quantum processor, arXiv:2510.24841 [quant-ph] (2025).DOI
  24. [24]Z. Laraib and S. Richers, Many-body simulations of the fast flavor instability, Phys. Rev. D 112, L101304 (2025), arXiv:2507.02040 [astro-ph.HE].DOI
  25. [25]Z. Laraib and S. Richers, Two-beam multiparticle many-body simulations of inhomogeneous fast flavor instabilities, Phys. Rev. D 112, 123045 (2025), arXiv:2511.16506 [astro-ph.HE].DOI
  26. [26]K. Yeter-Aydeniz, S. Bangar, G. Siopsis, and R. C. Pooser, Collective neutrino oscillations on a quantum computer, Quant. Inf. Proc. 21, 84 (2022), arXiv:2104.03273 [quant-ph].
  27. [27]V. Amitrano, A. Roggero, P. Luchi, F. Turro, L. Vespucci, and F. Pedreiva, Trapped-ion quantum simulation of collective neutrino oscillations, Phys. Rev. D 107, 023007 (2023).
  28. [28]B. Hall, A. Roggero, A. Baroni, and J. Carlson, Simulation of collective neutrino oscillations on a quantum computer, Phys. Rev. D 104, 063009 (2021), arXiv:2102.12556 [quant-ph].DOI
  29. [29]P. Siwach, K. Harrison, and A. B. Balantekin, Collective neutrino oscillations on a quantum computer with hybrid quantum-classical algorithm, Phys. Rev. D 108, 083039 (2023), arXiv:2308.09123 [quant-ph].arxiv.org/abs/2308.09123
  30. [30]F. Turro, I. A. Chernyshev, R. Bhaskar, and M. Illa, Qutrit and qubit circuits for three-flavor collective neutrino oscillations, Phys. Rev. D 111, 043038 (2025), arXiv:2407.13914 [quant-ph].DOI
  31. [31]P. Siwach, A. M. Suliga, and A. B. Balantekin, Entanglement in three-flavor collective neutrino oscillations, Phys. Rev. D 107, 023019 (2023).DOI
  32. [32]A. B. Balantekin and A. M. Suliga, On the properties of qudits, Eur. Phys. J. A 60, 124 (2024), arXiv:2405.13862 [quant-ph].DOI
  33. [33]M. Mangin-Brinet, A. Bauge, and D. Lacroix, Three-flavor neutrino oscillations using the phase space approach, Phys. Rev. D 113, 036026 (2026).
  34. [34]L. Spagnoli, N. Goss, A. Roggero, E. Rrapaj, M. J. Cervia, A. V. Patwardhan, R. K. Naik, A. B. Balantekin, E. Younis, D. I. Santiago, I. Siddiqi, and S. Aldaihan, Collective neutrino oscillations in three flavors on qubit and qutrit processors, Phys. Rev. D 111, 103054 (2025).DOI
  35. [35]I. Chernyshev, C. E. P. Robin, and M. J. Savage, Quantum magic and computational complexity in the neutrino sector, Phys. Rev. Res. 7, 023228 (2025).
  36. [36]G. Martínez-Pinedo, T. Fischer, K. Langanke, A. Lohs, A. Sieverding, and M.-R. Wu, Neutrinos and their impact on core-collapse supernova nucleosynthesis, in Handbook of Supernovae, edited by A. W. Alsabti and P. Murdin (Springer International Publishing, 2017) pp. 1805–1841.
  37. [37]A. B. Balantekin, M. J. Cervia, A. V. Patwardhan, R. Surman, and X. Wang, Collective Neutrino Oscillations and Heavy-element Nucleosynthesis in Supernovae: Exploring Potential Effects of Many-body Neutrino Correlations, Astrophys. J. 967, 146 (2024), arXiv:2311.02562 [astro-ph.HE].DOI
  38. [38]L. Choi, A. Burrows, and D. Vartanyan, Predicted neutrino signal features of core-collapse supernovae (2025), arXiv:2503.07531 [astro-ph.HE].arxiv.org/abs/2503.07531
  39. [39]A. Mirizzi, I. Tamborra, H.-T. Janka, N. Saviano, K. Scholberg, R. Bollig, L. Hudepohl, and S. Chakraborty, Supernova Neutrinos: Production, Oscillations and Detection, Riv. Nuovo Cim. 39, 1 (2016), arXiv:1508.00785 [astro-ph.HE].DOI
  40. [40]T. Pitik, D. J. Hemsworth, A. M. Suliga, and A. B. Balantekin, Exploiting stellar explosion induced by the qcd phase transition in large-scale neutrino detectors, Phys. Rev. D 106, 103007 (2022).DOI
  41. [41]G. M. Fuller and W. C. Haxton, Neutrinos in Stellar Astrophysics, arXiv:2208.08050 [nucl-th] (2022).arxiv.org/abs/2208.08050
  42. [42]H. Duan, G. M. Fuller, J. Carlson, and Y.-Z. Qian, Simulation of Coherent Non-Linear Neutrino Flavor Transformation in the Supernova Environment. 1. Correlated Neutrino Trajectories, Phys. Rev. D 74, 105014 (2006), arXiv:astro-ph/0606616.
  43. [43]Y. Z. Qian and G. M. Fuller, Neutrino-neutrino scat- tering and matter enhanced neutrino flavor transformation in Supernovae, Phys. Rev. D 51, 1479 (1995), arXiv:astro-ph/9406073.
  44. [44]N. F. Bell, A. A. Rawlinson, and R. F. Sawyer, Speedup through entanglement: Many body effects in neutrino processes, Phys. Rev. Lett. B 573, 86 (2003), arXiv:hep-ph/0304082.DOI
  45. [45]A. Friedland, B. H. J. McKellar, and I. Okuniewicz, Construction and analysis of a simplified many-body neutrino model, Phys. Rev. D 73, 093002 (2006), arXiv:hep-ph/0602016.DOI
  46. [46]Y. Pehlivan, A. B. Balantekin, and T. Kajino, Neutrino Magnetic Moment, CP Violation and Flavor Oscillations in Matter, Phys. Rev. D 90, 065011 (2014), arXiv:1406.5489 [hep-ph].DOI
  47. [47]S. Birol, Y. Pehlivan, A. B. Balantekin, and T. Kajino, Neutrino Spectral Split in the Exact Many Body Formalism, Phys. Rev. D 98, 083002 (2018), arXiv:1805.11767 [astro-ph.HE].DOI
  48. [48]P. Siwach, A. B. Balantekin, A. V. Patwardhan, and A. M. Suliga, Exploring entanglement and spectral split correlations in three-flavor collective neutrino oscillations, Phys. Rev. D 111, 063038 (2025).DOI
  49. [49]D. C. McKay, C. J. Wood, S. Sheldon, J. M. Chow, and J. M. Gambetta, Efficient Z gates for quantum computing, Phys. Rev. A 96, 022330 (2017), arXiv:1612.00858 [quant-ph].DOI
  50. [50]T. Tiwari, S. K. Sahu, G. Ribeill, M. Senatore, M. D. LaHaye, R. W. Simmonds, D. L. Campbell, A. Kamal, and L. Ranzani, High-fidelity iSWAP gate with Double Transmon Coupler (2026), arXiv:2604.27080 [quant-ph].arxiv.org/abs/2604.27080
  51. [51]W. Huang, C. H. Yang, K. W. Chan, T. Tanttu, B. Hensen, R. C. C. Leon, M. A. Fogarty, J. C. C. Hwang, F. E. Hudson, K. M. Itoh, A. Morello, A. Laucht, and A. S. Dzurak, Fidelity benchmarks for two-qubit gates in silicon, Nature 569, 532 (2019).
  52. [52]F. Pfeiffer et al., A high-fidelity two-qubit gate for multimode superconducting P-mon qubits, arXiv:2606.24772 [quant-ph] (2026).arxiv.org/abs/2606.24772
  53. [53]G. Vidal, Efficient classical simulation of slightly entangled quantum computations, Phys. Rev. Lett. 91, 147902 (2003).DOI
  54. [54]M. Howard, E. Brennan, and J. Vala, Quantum contextuality with stabilizer states, Entropy 15, 2340 (2013).DOI
  55. [55]S. X. Cui and Z. Wang, Universal quantum computation with metaplectic anyons, J. Math. Phys. 56, 032202 (2015).DOI
  56. [56]Q. Wang, Qutrit zx-calculus is complete for stabilizer quantum mechanics, Electronic Proceedings in Theoretical Computer Science 266, 58–70 (2018).DOI
  57. [57]F. Turro, I. A. Chernyshev, R. Bhaskar, and M. Illa, Qutrit and qubit circuits for three-flavor collective neutrino oscillations, Phys. Rev. D 111, 043038 (2025).DOI
  58. [58]K. Bharti and T. Haug, Quantum-assisted simulator, Phys. Rev. A 104, 042418 (2021).DOI
  59. [59]A. Luongo, Quantum algorithms for data analysis, https://quantumalgorithms.org/, 24 June, 2026.
  60. [60]W. Magnus, On the exponential solution of differential equations for a linear operator, Communications on Pure and Applied Mathematics 7, 649 (1954), https://onlinelibrary.wiley.com/doi/pdf/10.1002/cpa.3160070404.DOI
  61. [61]T. de Souza Farias, L. Friedrich, and J. Maziero, QuForge: A library for qudits simulation, Computer Physics Communications 314, 109687 (2025).
  62. [62]P. Virtanen, R. Gommers, T. E. Oliphant, M. Haberland, T. Reddy, D. Cournapeau, E. Burovski, P. Peterson, W. Weckesser, J. Bright, S. J. van der Walt, M. Brett, J. Wilson, K. J. Millman, N. Mayorov, A. R. J. Nelson, E. Jones, R. Kern, E. Larson, C. J. Carey, Í. Polat, Y. Feng, E. W. Moore, J. VanderPlas, J. Laxalde, J. Perktold, C. C. R. Harris, A. M. Archibald, A. H. Ribeiro, F. Pedregosa, P. van Mulbregt, and SciPy 1.0 Contributors, SciPy 1.0: Fundamental Algorithms for Scientific Computing in Python, Nature Methods 17, 261 (2020).

Paper details

vlnc:W_msb6k2k2
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 10

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents