WorksPhysics and Astronomy
Self-learning Emulators and Eigenvector Continuation
Abstract
Emulators that can bypass computationally expensive scientific calculations with high accuracy and speed can enable new studies of fundamental science as well as more potential applications. In this work we discuss solving a system of constraint equations efficiently using a self-learning emulator. A self-learning emulator is an active learning protocol that can be used with any emulator that faithfully reproduces the exact solution at selected training points. The key ingredient is a fast estimate of the emulator error that becomes progressively more accurate as the emulator is improved, and the accuracy of the error estimate can be corrected using machine learning. We illustrate with three examples. The first uses cubic spline interpolation to find the solution of a transcendental equation with variable coefficients. The second example compares a spline emulator and a reduced basis method emulator to find solutions of a parameterized differential equation. The third example uses eigenvector continuation to find the eigenvectors and eigenvalues of a large Hamiltonian matrix that depends on several control parameters.
Introduction
The frontiers of scientific discovery often reside just beyond the limits of computability. This explains the great interest across many scientific disciplines in using machine learning tools to build efficient emulators that predict scientific processes beyond what is possible with direct calculations [4] [1, 2, 3]. However, a problem arises in that large amounts of training data for such an emulator are not possible since the required computations are difficult and expensive. In this work, we provide a potential solution to this problem when the objective is to solve a system of constraint equations over some domain of control parameters. We introduce a method called self-learning emulation, an active learning protocol [5, 6, 7] that relies on a fast estimate of the emulator error and a greedy local optimization algorithm that becomes progressively more accurate as the emulator improves. Provided that the emulator faithfully reproduces the exact solution at the training points, the error will decrease with the number of training points as either a power law for piecewise continuous emulators or exponentially fast for smooth function emulators. The resulting acceleration is typically several orders of magnitude or more, and the gain in computational speed is achieved by using the emulator itself to estimate the error. As we will show, self-learning emulators are highly efficient algorithms that offer both high speed and accuracy as well as a reliable estimate of the error. We note that the self-learning emulators we discuss here are qualitatively different from other machine learning algorithms that model the solutions using gradient descent optimization of some chosen loss function. While these gradient descent optimization methods are highly parallelizable and very fast, they usually suffer from critical slowing down with respect to error and cannot achieve arbitrarily high accuracy in polynomial computing time. Sometimes scientific discovery requires seeing very small but important new phenomena that might otherwise be absent in approximate machine learning models.
We will demonstrate several contrasting examples of self-learning emulators. The first uses a cubic spline emulator to find the solution of a transcendental equation with variable coefficients. The second example uses the spline emulator and a reduced basis method emulator to find solutions of a parameterized differential equation. The third example is our primary example for quantum many body calculations. It uses eigenvector continuation to find the eigenvectors and eigenvalues of a large Hamiltonian matrix that depends on several control parameters. See Ref. [8, 9] for an introduction to eigenvector continuation and Ref. [10, 11] for applications to the quantum many body problem.
Constraint equations and error estimates We consider a general set of simultaneous constraint equations that we solve for variables as a function of control parameters over some domain . Let us denote the exact solutions as . We assume that we have an emulator which can take the exact solutions for some set of training points and construct an approximate solution for all . Let us define the error or loss function as the norm of the residual . The objective is to train the emulator to minimize the peak value of the error function over the domain using as few additional training points as possible.
Since the error function will vary over many orders of magnitude, it is more convenient to work with the natural logarithm of the error function, . The emulator will reproduce the exact solution at the training points . Therefore, the logarithm of the error function will become a rapidly varying function of as we include more training points.
Let us consider the case where is small enough that we can accurately expand the constraint equations as
If the number of degrees of freedom is small, we can solve the linear inversion problem for and provide a fast estimate for the logarithm of the error. This estimate is nothing more than the multivariate form of the Newton-Raphson method.
Fast error estimates For most cases of interest, however, there will be many degrees of freedom and the matrix inversion required to solve for will be too slow for our self-learning emulator training process. We therefore choose another non-negative functional as a surrogate for . The only essential requirement we impose on is that it is linearly proportional to in the limit . This allows us to write the logarithm of the error as
where is a constant and the average of over the domain is zero. Since is linearly proportional to in the limit , the function will have the same steep hills and valleys as the function as we include more training points. In the limit of large number of training points, we can neglect the much smaller variation of over the domain . We can therefore approximate the logarithm of the error as . We note that the unknown constant is irrelevant for comparing the logarithm of the error for different points . Nevertheless, we can also quickly estimate simply by taking several random samples of and computing the average value of the difference between and . We can refine this estimate further using machine learning to approximate the function . In several of our examples we show the improvement resulting from these additional steps.
The self-learning emulator training program is a greedy algorithm where we search to find the point where the logarithm of the error is greatest. We then add this point to the training set and repeat the whole process. In this manner we have constructed a fast emulator that becomes more and more accurate as more training points are added and provides a reliable estimate of the emulator error. It should be emphasized that the self-learning emulation is just an algorithm to learn the best training points for the emulator, and it does not change the process of emulation itself. Thus it can be used with any emulator that faithfully reproduces the exact solution at the training points. This could be a simple method such as polynomial interpolation or a Gaussian process, or a more involved method such as neural networks or eigenvector continuation. We retain all the beneficial properties of the emulator such as its computational speed advantage, parallelizability, ease of application, etc. It can be applied to any system of constraints such as solutions of algebraic or transcendental equations, linear and nonlinear differential equations, and linear and nonlinear eigenvalue problems.
Model 1 For the first example, Model 1, we use a natural cubic spline emulator to find the lowest real solution of a transcendental equation. We consider the solution to the equation
where all the coefficients are real. We fix coefficients , and we vary the coefficient . We are interested in the lowest real that satisfies Eq. (3). We know that a real solution for always exist for real , however the dependence of the solution on is not trivial and has discontinuities with respect to parameter .
We start with three training points for , two on the boundary and one in the interior, and use natural cubic splines to define the cubic spline approximation for all values of . The logarithm of the error function is then where . We can estimate using the Newton-Raphson method,
where we have included a small regulator to avoid divergences when the derivative vanishes. We use the right-hand side of Eq. (4) for our error estimate with .
In Figure 1 we show results for the logarithm of the error estimate and actual error, spanning the interval from to with 23 training points. The fact that more training points are needed near shows that the training process is not simply adding more training points at random, but is instead uniformly improving the emulator performance across the entire domain. As shown in the Supplemental Material, there is a discontinuity at , and we need a higher density of training points near the discontinuity. Figure 1 shows that our error estimates are matching well with the actual error. Therefore both and as defined in Eq. (2) are negligible for Model 1.

Figure 1. Logarithm of the actual error and error estimate for the cubic spline self-learning emulator in Model 1 after 20 iterations.
In the limit of large number of training points, , the error for the spline interpolation for a smooth function scales as [12]. For the case of Model 1, however, the exact solution has a jump discontinuity, and so the power law scaling is slower. Numerically, we find that the error is approximately . See the Supplemental Material for details on the error scaling versus number of training points as well as the dependence on the choice of initial training points. On a single Intel i7-9750H processor, evaluating the exact solution using standard root finding methods for one value of requires about s of computational time. In contrast, it takes about s for spline interpolation for 23 training points. The raw emulator speedup factor is therefore . Let be the number of evaluations of needed and be the number of emulator training points needed to achieve error tolerance . The overall computational speedup factor for the self-learning emulator can then be estimated by the minimum of and . If the fast error estimate were not used, then would be replaced by the number of evaluations needed to train the emulator to the desired error tolerance , which is generally much larger than .
Model 2 In our next example, Model 2, we will emulate the solution of an ordinary differential equation with one variable and one control parameter . We consider a family of differential equations , where
and is a real parameter. Our boundary conditions are and for all . We consider the region , and . The exact solution is . We consider two different emulators. The first is the natural spline emulator, which we use to perform interpolations and extrapolations in for each value of . The second emulator is a reduced basis emulator, which uses high-fidelity solutions of the differential equation for several training values of and solves the constraint equations approximately using subspace projection. Reduced basis (RB) emulators have proven useful for solving computationally-intensive parameterized partial differential equations [13, 14, 15, 16, 17].
For our fast error estimate , we need some function that is linearly proportional to the actual error in the limit . There are many good choices one can make, and here we choose
where we have again included a small regulator to avoid divergences. Here we are using the norm, which is the integral over of the absolute value.
We initialize with two training points at the boundaries and one in the interior. For the spline emulator, the error scales approximately as for up to 300 training points. Meanwhile, the error for the RB emulators scales exponentially fast in . We have therefore extended the domain to the wider interval in order to show more details of the performance before reaching the limits of machine precision. Over this interval, the RB emulator error scales approximately as , for above 10 training points. Figure 2 shows the actual error and estimated error after 20 iterations of the self-learning spline emulator. Figure 3 shows the actual error and estimated error after 10 iterations of the self-learning RB algorithm. In both cases the difference between the actual error and estimate error is a slowly-varying function of as predicted. We note that the exact solution oscillates more rapidly with increasing , and the emulators therefore need more training points for larger .

Figure 2. Logarithm of the actual error, error estimate, and corrected error estimate for the natural spline emulator with self-learning in Model 2 after 20 iterations.

Figure 3. Logarithm of the actual error, error estimate, and corrected error estimate for the reduced basis emulator with self-learning in Model 2 after 10 iterations.
We can estimate the difference between the error estimate and the actual error by constructing a Gaussian Process (GP) emulator for the difference function . We train the GP by computing at the midpoints in between the emulator training points. We have performed this correction for both the spline and RB emulators, and the results are shown in Figure 2 and Figure 3. We see that the corrected error estimate is in excellent agreement with the actual error.
On a single Intel i7-9750H processor, numerically solving the differential equation for one value of takes about . In contrast the spline emulator requires about for 23 training points, and the RB emulator takes about for 13 training points. Therefore the spline emulator has a raw speedup factor of , while the RB emulator has a raw speedup factor of . Given the somewhat comparable values for and the exponential scaling of the error for the RB emulator, we conclude that the RB emulator significantly outperforms the spline emulator for this example.
Model 3 For our final example, Model 3, we will use eigenvector continuation as the emulator. Eigenvector continuation (EC) belongs to the family of RB methods [13, 14], however the applications may involve extremely large vector spaces where general vector operators may not be possible [8]. EC consists of projecting the Hamiltonian onto a subspace spanned by a set of exact eigenvectors of the Hamiltonian for selected training points and then solving the resulting generalized eigenvalue problem. While it may not be possible to represent general vectors in extremely large vector spaces, the inner products and matrix elements of eigenvectors can be computed using Monte Carlo simulations [8, 9], coupled cluster calculations [11], or some other many body method in order to solve the generalized eigenvalue problem. EC has been used to deal with Monte Carlo sign oscillations [9], a resummation method for perturbation theory [18, 19], and an accurate emulator for quantum systems [10]. More recently there have been a number of new developments, applications, and connections to other methods [11, 13, 14, 20, 21, 22, 23, 24, 25]. The implementation of EC within an active learning framework was first discussed in Ref. [26]. However, one faces a computational bottleneck for large systems if the training process requires many repeated calculations of eigenvectors. Here we instead use a fast estimate of the error function based upon the variance of the Hamiltonian.
Let be a manifold of Hamiltonians where the dependence on the control parameters is smooth. Let be the corresponding eigenvector of interest and be the corresponding energy eigenvalue. The EC approximation consists of projecting onto the subspace spanned by the training eigenvectors . By solving the generalized eigenvalue, we obtain the EC approximation to the eigenvector . Throughout our discussion, we assume that all eigenvectors are unit normalized. The corresponding approximate energy is equal to the expectation value .
The logarithm of the error is , where . Computing the error directly will be computationally too expensive for large systems, and so we will instead work with , where is proportional to the square root of the variance of the Hamiltonian,
We note that will be linearly proportional to in the limit . Therefore can be used as a surrogate for the logarithm of the error.
For Model 3 we consider the ground state of a system of four distinguishable particles with equal masses on a three-dimensional lattice with zero-range interactions. We will work in lattice units where physical quantities are multiplied by the corresponding power of the lattice spacing to make dimensional combinations. Furthermore, we set the particles masses to equal 1 in lattice units. We label the particles as 1, 2, 3, 4 and take the control parameters to be the six possible pairwise interactions, , with . The lattice volume is a periodic cube of size , and the corresponding Hamiltonian is a linear space with 262, 144 dimensions. The details of the Hamiltonian can be found in the Supplemental Material. This model can be viewed as a generalization of the four two-component fermions with zero-range interactions considered in Ref. [23, 27] or the Bose-Hubbard model considered in Ref. [8].
We would like to study the appearance of interesting structures such as particle clustering [28, 29] in the ground state wave function as a function of the six coupling parameters . Some simple indicators of particle clustering are discussed in the Supplemental Material. Such detailed multi-parameter studies are very difficult due to the number of repeated calculations necessary. However, we now show that self-learning emulation with eigenvector continuation can make such studies fairly straightforward.
Since it is difficult to visualize data for all six parameters, we present results corresponding to one two-dimensional slice. We set and use EC as an emulator for the ground state as a function of and over a square domain where each coefficient ranges from to . We initialize the self-learning emulator with one random training point for and . When searching for new training points, we use the method of simulated annealing [30] with an energy functional given by .
In Figure 4 we show the logarithm of the error obtained after 40 iterations. In panel (a) we show the logarithm of the actual error, and in panel (b) we show the logarithm of the estimated error. As predicted in Eq. (2), we see that the two plots are approximately the same up to a constant offset , with . The peak value of the actual error is . From the figure we see that the local maxima of the error reside along an approximately flat horizontal surface. The flatness of this surface indicates that our self-learning emulator is performing as intended, with the training algorithm removing the peak error at each iteration. We note that the distribution of training points is far from uniform. The region near the line has a higher density of training points, indicating that the ground state wave function has a more complicated dependence on and in that location.

Figure 4. Logarithm of the error in Model 3 after 40 iterations using self-learning EC. In panel (a) we show the logarithm of the actual error (red), and in panel (b) we show the logarithm of the estimated error (blue).
The error scaling is exponential in the number of training points, . On a single Intel i7-9750H processor, direct calculation of the eigenvector and eigenvalue requires about 1.95 s, whereas EC emulation with 41 training points can be done in 0.013 s. This corresponds to a raw speedup factor of . Using the self-learning emulator, we can now measure particle clustering and short-range correlations between pairs of particle in the ground state wave function for all values of and . In Figure 4 we show the short-range correlations for pairs of particles 1 with 2, and 1 with 3. The correlation function measures the probability that particles 1 and 2 occupy the same lattice site, and the correlation function measures the probability that particles 1 and 3 occupy the same lattice site. We see that is close to zero when is positive and rises to a peak of 1 when is negative and increasing in magnitude. Similarly, is close to zero when is positive and rises to a peak of 1 when is negative and increasing in magnitude. The change in structure is most prominent near the line , consistent with our emulator data on the selection of training points. We have also studied the performance of the self-learning EC emulator when we vary all six control parameters over the range from to 0. After 80 iterations, the peak value of the error over the entire six-dimensional parameter space is .

Figure 5. Plot of the two-particle clustering and short-range correlations in Model 3. (red) measures the probability that particles 1 and 3 occupy the same lattice site, and the correlation function (blue) measures the probability that particles 2 and 3 occupy the same lattice site.
Summary Self-learning emulation is a general approach that can be implemented with any emulator that faithfully reproduces the exact solution at selected training points. They use a fast estimate for the error in the training process and perform full calculations only for the chosen new training points. If needed, the difference between the estimated error and exact error can be corrected using machine learning. If many evaluations are required, the computational advantage can grow as large as the raw speedup factor of the emulator, , which can be several orders of magnitude or more. Self-learning emulators are a highly efficient class of algorithms that offer both high speed and accuracy as well as a reliable estimate of the error.
Acknowledgement We are grateful for discussions with E. Bonilla, J. Bonitati, R. Furnstahl, G. Given, P. Giuliani, K. Godbey, C. Hicks, M. Hjorth-Jensen, Da. Lee, J. Melendez, W. Nazarewicz, E. Ng, Z. Qian, J. Vary, J. Watkins, S. Wild, C. Yang, and X. Zhang. We gratefully acknowledge funding by the U.S. Department of Energy (DE-SC0013365 and DE-SC0021152) and the Nuclear Computational Low-Energy Initiative (NUCLEI) SciDAC-4 project (DE-SC0018083) as well as computational resources provided the Oak Ridge Leadership Computing Facility through the INCITE award “Ab-initio nuclear structure and nuclear reactions”, the Gauss Centre for Supercomputing e.V. (www.gauss-centre.eu) for computing time on the GCS Supercomputer JUWELS at Jülich Supercomputing Centre (JSC), and Michigan State University.
References
Supplemental Material
Model 1
In Model 1, we want the solution to the equation
where all the coefficients are real. We fix coefficients , and we vary the coefficient . With these choices, the lowest solution to the equation is shown in Figure S1. We notice that the dependence of the solution on variable is non-trivial, and there is a discontinuity at . As a result, the self-learning emulator needs to take significantly more training points near the discontinuity.

Figure S1. Plot of the lowest real solution to Eq. (8) versus . The self-learning emulator needs to take significantly more training points near the discontinuity at .
Dependence on initial training points
In this section we examine the performance of the self-learning emulator for Model 1 when starting from a poor choice of initial training points. In Figure S2, we show the logarithm of the actual error and error estimate for the cubic spline self-learning emulator in Model 1 after 20 iterations when starting from training points , , . In Figure S3, we show the logarithm of the actual error and error estimate for the cubic spline self-learning emulator in Model 1 after 20 iterations when starting from training points , , . We see that in both cases there is almost no loss of performance in comparison with Figure 1 of the main text despite the poor choice of initial starting points.

Figure S2. Logarithm of the actual error and error estimate for the cubic spline self-learning emulator in Model 1 after 20 iterations when starting from training points , , .

Figure S3. Logarithm of the actual error and error estimate for the cubic spline self-learning emulator in Model 1 after 20 iterations when starting from training points , , .
Error scaling
If the solution is smoothly varying, we expect error scaling for our self-learning natural spline emulator. This is because the error of the cubic interpolation scales as the fourth power of the interval between training points. However, this holds true only when the function is smooth and in the limit that is large. For Model 1, however, the exact solution has a jump discontinuity, and so the power law scaling is slower. Numerically, we find that the error is approximately . We see this in Figure S4, where the slope of the graph is .

Figure S4. Natural spline emulator error scaling for Model 1. We plot the logarithm of the error versus the logarithm of the number of iterations.
In Model 2, the solution is smoothly varying function. However it seems that have not yet reached the asymptotic scaling large limit, and the error scaling is approximately . This can be seen from the slope in Figure S5. In contrast, the reduced basis emulator has exponentially fast error scaling. This is because the reduced basis emulator is itself a smooth function. We can view the addition of training points as matching more derivatives of the smooth emulator to derivatives of the smooth exact solution. The error scaling is therefore similar to the error scaling of a convergent power series. In Figure S6 we show the error scaling for the reduced basis emulator for Model 2. We see that the error scaling is .

Figure S5. Natural spline emulator error scaling for Model 2. We plot the logarithm of the error versus the logarithm of the number of iterations.

Figure S6. Reduced basis method error scaling for Model 2. We plot the logarithm of the error versus the number of iterations.
For the eigenvector continuation emulator in Model 3, we again expect exponential error scaling because both the emulator and exact solution are both smoothly varying functions. In Figure S7 we show the error scaling for the eigenvector continuation emulator in Model 3. We see that the error scaling is .

Figure S7. Eigenvector continuation emulator error scaling for Model 3. We plot the logarithm of the error versus the number of iterations.
Geometrical picture of eigenvector continuation error
We will present a geometrical picture of eigenvector continuation (EC) error as well as some additional insight into the error estimate that appears in Eq. (3) of the main text. We consider a Hamiltonian manifold that depends on the control parameters . We write for the eigenvector of interest and for the corresponding energy eigenvalue. Suppose we know the eigenvectors at different training points, . We label the set of training eigenvectors as . Let us define the norm matrix as
and let be the determinant of . Then corresponds to the square of the volume of the -dimensional parallelopiped defined by the vectors in the set . If all the eigenvectors are normalized, then the maximum possible volume is 1, which is attained when all the eigenvectors are orthogonal.
Let us now consider selecting the next training point, . Let be the projection operator onto the linear span of , and let be the orthogonal complement so that . Suppose we now expand our training set by adding another training vector to form . Let us define the perpendicular projection vector as
Since is the squared volume of the parallelopiped defined by the vectors in and is the squared volume of the parallelopiped defined by the vectors in , it follows that the ratio to is given by the squared norm of ,
Let us define the projections of onto and subspaces as
The EC approximation is nothing more than the approximation of by some eigenvector of , which we denote as . Let the corresponding energy be labelled so that
We also label the eigenvectors of contained in the orthogonal complement as,
When the difference between the exact eigenvector and the eigenvector continuation approximation of the eigenvector is small, we can use first order perturbation theory to write
To first order in perturbation theory, the residual vector is just . We therefore have
If we now combine with Eq. (11), we get
We can now connect this result with the error or loss function in the main text. The second part of the equation gives an expression for the error term using first-order perturbation theory, and the first part of the equation is a geometrical interpretation of the error term as the ratio of the squared volumes, to . Taking the logarithm of the square root, we get
The term in the numerator,
will go to zero at each of the training points, causing large variations in the logarithm of the error as we add more and more training points. In contrast, the term in the denominator, , will be smooth as a function of . Similarly, will also be a smooth function of . We can write
where is a constant and averages to zero over the entire domain of . While the function is unknown, it will be dominated by the large variations in the logarithm of the error as more and more training points are added. We note that
We therefore arrive at the variance error estimate used in the main text,
Model 3 Hamiltonian
Model 3 describes four-distinguishable particles with equal masses on a three-dimensional lattice with pairwise point interactions with coefficients for each pair . We use lattice units where physical quantities are multiplied by powers of the spatial lattice spacing to make the combinations dimensionless. We take the common mass to equal 1 in lattice units. We let denote the spatial lattice points on our three dimensional periodic lattice. Let the lattice annihilation and creation operators for particle be written as and respectively. The free non-relativistic lattice Hamiltonian has the form
We add to the free Hamiltonian single-site contact interactions, and the resulting Hamiltonian then has the form
where is the density operator for particle ,
For calculations discussed in this work, we use a basis of position eigenstates on the lattice. As noted in Ref. [28], we can determine the formation of particle clusters by measuring the expectation values of products of local density operators. For example, can serve as an indicator of two-particle clusters, for three-particle clusters, and for a four-particle cluster.
References
- [4]P. Bedague et al., Eur. Phys. J. A 57, 100 (2021), 2006.05422.
- [5]B. Settles, Computer Sciences Technical Report 1648, University of Wisconsin–Madison (2009).
- [6]D. A. Cohn, Z. Ghahramani, and M. I. Jordan, Journal of artificial intelligence research 4, 129 (1996).
- [7]D. Cohn, L. Atlas, and R. Ladner, Machine learning 15, 201 (1994).
- [8]D. Frame, R. He, I. Ipsen, D. Lee, D. Lee, and E. Rrapaj, Phys. Rev. Lett. 121, 032501 (2018), 1711.07090.
- [9]D. K. Frame, Ph.D. thesis, Michigan State University (2019), 1905.02782.
- [10]S. König, A. Ekström, K. Hebeler, D. Lee, and A. Schwenk (2019), 1909.08446.
- [11]A. Ekström and G. Hagen, Phys. Rev. Lett. 123, 252501 (2019), 1910.02922.
- [12]J. H. Ahlberg, E. N. Nilson, and J. H. Walsh, Academic Press (1967).
- [13]E. Bonilla, P. Giuliani, K. Godbey, and D. Lee (2022), 2203.05284.
- [14]J. A. Melendez, C. Drischler, R. J. Furnstahl, A. J. Garcia, and X. Zhang (2022), 2203.05528.
- [15]A. Quarteroni, A. Manzoni, and F. Negri, Reduced Basis Methods for Partial Differential Equations (Springer, 2016).
- [16]A. Quarteroni, G. Rozza, and A. Manzoni, J.Math.Industry 1 (2011).
- [17]S. E. Field, C. R. Galley, F. Herrmann, J. S. Hesthaven, E. Ochsner, and M. Tiglio, Phys. Rev. Lett. 106, 221102 (2011).
- [18]P. Demol, T. Duguet, A. Ekström, M. Frosini, K. Hebeler, S. König, D. Lee, A. Schwenk, V. Somà, and A. Tichai, Phys. Rev. C101, 041302(R) (2020), 1911.12578.
- [19]P. Demol, M. Frosini, A. Tichai, V. Somà, and T. Duguet, Annals Phys. 424, 168358 (2021), 2002.02724.
- [20]R. J. Furnstahl, A. J. Garcia, P. J. Millcian, and X. Zhang, Phys. Lett. B 809, 135719 (2020), 2007.03635.
- [21]D. Bai and Z. Ren, Phys. Rev. C 103, 014612 (2021), 2101.06336.
- [22]S. Swelsowski, I. Svensson, A. Ekström, C. Forssén, R. J. Furnstahl, J. A. Melendez, and D. R. Phillips (2021), 2104.04441.
- [23]A. Sarkar and D. Lee, Phys. Rev. Lett. 126, 032501 (2021).
- [24]S. Yoshida and N. Shimizu (2021), 2105.08256.
- [25]J. A. Melendez, C. Drischler, A. J. Garcia, R. J. Furnstahl, and X. Zhang (2021), 2106.15608.
- [26]C. Eklind, Ph.D. thesis, Chalmers University of Technology (2021), https://hdl.handle.net/20.500.12380/302455.
- [27]S. Bour, X. Li, D. Lee, U.-G. Meißner, and L. Mitas, Phys. Rev. A83, 063619 (2011), arXiv:1104.2102 [cond-mat.quant-gas].DOI
- [28]S. Elhatisari, E. Epelbaum, H. Krebs, T. A. Lähde, D. Lee, N. Li, B.-n. Lu, U.-G. Meißner, and G. Rupak, Phys. Rev. Lett. 119, 222505 (2017), 1702.05177.
- [29]M. Freer, H. Horiuchi, Y. Kanada-En’yo, D. Lee, and U.-G. Meißner, Rev. Mod. Phys. 90, 035004 (2018), 1705.06192.
- [30]M. Pincus, Operations Research 18, 1225 (1970).