1 Introduction

Experimental hardware for quantum computing has been steadily improving in the past twenty years, indicating that a useful quantum computer that outperforms a classical computer may eventually be built. However, until a large-scale and viable quantum computer has been realized, numerically simulating quantum circuits on a classical computer will be necessary for predicting the behavior of quantum computers.

Such simulations can play an important role in the development of quantum computing by (1) numerically verifying the correctness and characterizing the performance of quantum algorithms [1–5], (2) simulating error and decoherence due to the interaction between the quantum computer and its environment [6–9], and (3) improving our understanding of the boundary between classical and quantum computing in terms of computational power, for which recent efforts for characterizing the advantage of quantum computers over classical computers [10–17] serve as an example of this direction.

In this work, we consider the problem of quantum circuit simulation as one where we are given a quantum circuit and an initial state, with the goal of determining the probability of a given output state. Several approaches are possible for such simulation tasks. The most general method is to represent the state vector of an N-qubit state by a complex unit vector of dimension 2^N and apply the quantum gates by performing matrix-vector multiplications. This is essentially the approach adopted in, for example, [1–3, 18, 19]. This method has the advantage that full information of the quantum state is represented at any point during the circuit propagation. However, the exponential cost of storing and updating the state vector renders it prohibitive for simulating circuits larger than ∼45 qubits. On the other hand, for a wide class of circuits with restricted gate sets and input states [20–24], efficient classical simulation algorithms are available. For example, the numerical package Quipu [25, 26] has been developed for taking advantage of prior results [20, 21, 24] on the stabilizer formalism to speed up general quantum circuit simulation. Finally, path integral-based methods [27] have also been proposed—though they do not improve the simulation cost, they lead to reduced memory storage requirements.

Other than considering the gate sets involved, an alternative perspective of viewing a quantum circuit is through its geometry or topology [28, 29]. Under this view, a quantum circuit is simulated via tensor network contractions. An advantage of viewing quantum circuits as tensor networks is that one can afford to ignore the particular kinds of quantum gates used in a circuit, and instead only focus on the graph theoretic properties. While general quantum circuits involving universal sets of elementary gates are likely hard to simulate on a classical computer [30], this geometric perspective sometimes allows for the efficient simulation of a quantum circuit with a universal gate set, provided that it satisfies certain graph theoretic properties. We note that at least one open source implementation of tensor network simulation for quantum circuits already exists, called TNQVM [31], which can simulate tensor networks but also focuses on integrating algorithms with real quantum hardware. Aside from the field of quantum computation, tensor networks and related methods are an important and active area of research in the simulation of quantum mechanical problems in theoretical physics [32–34].

Among others, treewidth is an important graph theoretic parameter that determines the efficiency of contracting a tensor network of quantum gates. A property of graphs that is actively studied in the graph theory literature [35–38], the treewidth provides important structural information about a quantum circuit. Namely, if the circuit’s underlying tensor network has treewidth T, it is shown in [29] that the cost of simulating the circuit is O(exp(T)). In [10] treewidth is also used for estimating the classical resource needed for simulating certain quantum circuits.

Motivated by the importance of tensor networks in quantum circuit simulation in general (and for example quantum computational supremacy tests in particular), it is useful to have a circuit simulation platform singularly dedicated to tensor network contraction. One immediate challenge in contracting tensor networks is to find an efficient contraction ordering, which relies on explicitly or implicitly finding a reasonable tree decomposition of the underlying graph (definitions are further discussed in Section 2). However, finding the optimal contraction ordering (or equivalently finding the minimum-size tree decomposition, or finding the treewidth of a graph) is NP-complete [39]. Therefore one must typically resort to heuristic methods when finding this decomposition [40].

For this study, we implemented a plug-and-play tensor network (TN) contraction code with two contraction schemes. Other schemes were attempted, but were significantly inferior to those that became part of the software package. However, there are likely other heuristic schemes that outperform our stochastic algorithm, and this is an avenue worth pursuing. For a large set of quantum circuits, our tensor network based methods are shown to be less costly than simulation of the full Hilbert space, by comparing to simulations using the LIQUi|> software package [1]. We emphasize again that the tests in this report give timing data for finding the expectation value of a measurement performed after implementing a quantum circuit, not for fully characterizing a circuit’s final state.

The remainder of the paper is organized as the follows. Section 2 sets up the definitions and notations used in the paper. Section 3 describes the heuristic methods used for contracting the quantum circuit tensor networks, along with other relevant details of the code implementation. Section 4 presents the example quantum circuits used as benchmarks for demonstrating the performance of our contraction algorithms. Section 5 gives results of comparisons between the qTorch contraction methods, and between qTorch simulations and LIQUi|>’s Hilbert space simulations.

2 Preliminaries

In this section, we provide an overview of relevant concepts and definitions. All graphs that we consider in this paper are undirected. We denote a graph as G(V, E), consisting of the set of nodes V = {v₁, v₂, ⋯, v_n} and edges E ⊆ V × V.

Two relevant concepts are a graph’s tree decomposition and treewidth [35, 40]. A tree decomposition of a graph G(V, E) is a pair (S, T(I, F)), where S = {X_i|i ∈ I} is a collection of subsets X_i ⊆ V and T is a tree (with edge set F and node set I), such that ∪_i∈IX_i = V. Two nodes X_i and X_j are connected by an edge only if the intersection between X_i and X_j is not null. The width of a tree decomposition (S, T) is max_i∈I|X_i| − 1. The treewidth of a graph G is the minimum width among all tree decompositions of G.

Another important concept in tensor network methods is the linegraph of graph G, denoted by L(G). L(G) is itself an undirected graph, with each edge in G corresponding to a node in L(G). Two nodes in L(G) are connected if and only if these two nodes’ corresponding edges in G are connected to the same node in G. There exists an optimal tree decomposition of L(G) that provides the optimal contraction ordering of G [29].

In the context of this work, a tensor is defined as a data structure with rank k and dimension m. More specifically, each tensor is a multidimensional array with m^k complex entries. Each index may have a different dimension, though in this work each index has the same dimension m = 4. A tensor has k indices, which take values from 0 to m − 1.

A tensor contraction is a generalized tensor-tensor multiplication. Here a rank (x + y) dimension m tensor A and a rank (y + z) dimension m tensor B are contracted into C, a rank (x + z) dimension m tensor. (1)

Note that the number of floating point operations performed is m^x+y+z, exponential in the number of indices contracted on y and the rank of the resulting tensor (x + z). It is important to point out that pairwise contractions are always optimal [41]. In other words, a function that contracts three or more nodes at a time will not achieve an improvement in scaling.

A tensor network is a graph G = (V, E) with tensors as vertices, and edges labeled by a set of indices. The rank of each tensor is given by the number of edges connected to it. An edge from one tensor to another indicates a contraction between the two tensors, and multiple connected edges indicate a contraction on multiple indices. Fig 1 shows an example of a tensor network. Note that a tensor may have open edges, i.e. edges that do not connect to any other tensor, though this possibility is not allowed in the current version of qTorch.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. An example of a tensor network.

The number of edges (or wires) connecting to a tensor is equal to that tensor’s rank. When an index (edge) is contracted by combining two tensors according to Eq 1, the two tensor are replaced by a new one. The number of scalar entries in the tensor scales exponentially in the number of edges to which it connects. In general it is not trivial to choose an efficient contraction ordering that minimizes the total number of floating point operations.

https://doi.org/10.1371/journal.pone.0208510.g001

A contraction ordering or contraction scheme determines the order in which the tensor network is contracted. The ordering chosen for the contraction will greatly affect the computation and memory requirements, because some contraction orderings can result in much larger intermediate tensors than others. Although in this work we focus on contracting the tensor network to a scalar that equals the expectation value of the quantum circuit’s measurement, the goal of a tensor network algorithm is often not to contract it to a scalar [32, 34]. An example of this is the infinite tensor networks used to study periodic systems in condensed matter physics.

An important goal is to avoid tensors of large intermediate rank when contracting the network, as floating point operations grow exponentially with tensor rank. However, it is often the case that increasing the tensor rank is unavoidable. A simple example of this issue is a tetrahedral graph of rank 3 tensors (Fig 2), which cannot be contracted without forming intermediate tensors of rank greater than 3. The larger the treewidth of L(G) is, the more one will be forced to create new tensors of higher rank as the network is contracted, greatly increasing the computational cost [29].

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 2. A tetrahedral graph illustrates why it is often unavoidable to form tensors of higher rank while contracting a tensor network.

In this example, contracting any of the six edges produces a tensor of rank 4, even though all of the original tensors were of rank 3.

https://doi.org/10.1371/journal.pone.0208510.g002

We note that tensor network methods are commonly used to efficiently find approximate solutions—indeed this is often the main source of a TN’s utility. In approximate TN methods, the space of the smaller values of the eigenspectrum are removed, after e.g. performing a singular value decomposition on the tensor [32, 34]. This allows one to contract to form a larger tensor, then renormalize its size before continuing to contract the network. Though this strategy is useful in the context of quantum circuits as well, the current version of qTorch is limited to numerically exact contractions of the tensor network.

Before contracting, the tensor network graph must first be created from a quantum circuit, a procedure that has been summarized in previous work [29]. Each node on the graph represents one of the following: An initial state of the qubit (usually |0〉〈0|), a gate operation, or a measurement. The initial density matrix is represented as a rank 1 dimension 4 tensor (i.e. a vector), [ρ_|0〉〈0|;ρ_|0〉〈1|;ρ_|1〉〈0|;ρ_|1〉〈1|]. Measurement nodes are rank 1 as well. All indices in the graph are dimension 4, regardless of rank. Nodes corresponding to quantum gates are represented in superoperator form. Hence a gate U which acts on the quantum state as ρ → UρU^† is represented by the superoperator . The same operation can be expressed as , where is the Lindblad representation of the density operator. Single qubit gates correspond to rank 2 tensors and two-qubit gates correspond to rank 4 tensors. The graph’s connectivity is identical to the connectivity of the original quantum circuit.

We end this section with explicit examples of tensors for standard quantum circuit components. Tensors for other circuit components can be viewed in the source code for qTorch.

The initial state |0〉〈0| corresponds to the tensor (2)

Superoperator tensors for the Pauli matrices are (3)

The CNOT gate is represented as a sparse rank 4 tensor for which only the following entries are nonzero: (4)

Finally, the nodes for measurement are rank 1 tensors. , , and correspond respectively to determining expectation values for measurements in the X, Y, and Z bases. Note that using , , or is equivalent to inserting a Pauli gate at the end of the circuit before implementing . (5)

3 Contraction schemes and implementation details

For many problems in quantum physics to which matrix product states (MPS) or other tensor network methods have been applied, an efficient contraction scheme is often obvious from the underlying structure of the Hamiltonian [33]. However, efficient contraction schemes are not available for arbitrary tensor networks. A general heuristic contraction scheme is important for the simulation of general quantum circuits, when one does not know a priori the topological properties of the underlying tensor network problem.

3.3 Estimating the answer string

qTorch computes expectation values of the form 〈ψ|M|ψ〉, where M is a measurement operator such as a Pauli string, and |ψ〉 is the quantum state produced by the circuit. If instead one wishes to capture all the information of this final state of n qubits, it generally requires O(2ⁿ) repetitions of the algorithm. However, many quantities of interest may be calculated efficiently. For instance, the probability that one measurement operator (e.g. a Pauli string) will provide a particular outcome can be estimated in just one contraction of the tensor network, a result essential to simulating the variational quantum eigensolver (VQE) [42–45].

qTorch provides a heuristic scheme to output a high-probability answer string from the circuit, which we summarize here. Though this scheme is not used for the results presented in Section 5, it may be useful in the future for simulating algorithms (like QAOA) where the goal is to estimate a most likely bit string.

The scheme is implemented as follows. First we run one simulation, and measure in the computational basis to project the first qubit into 0 or 1. Based on the resulting expectation value from the simulation, we choose the value for the first qubit that has the greater probability. If the 0 and 1 are equally likely, one is chosen randomly. In the next full contraction, we set the resulting binary value as the measurement outcome for the first qubit in the next simulation, and repeat with a projective measurement on the second qubit. We continue this process for the rest of the qubits. As we show below, this method often gives a good approximation of the most likely final computational basis state. In original tests on 3-regular graphs of 30 vertices, the scheme (used on Quantum Approximate Optimization Algorithm [QAOA] circuits) gave bit strings that provided good estimates to the solution of the Max-Cut problem (average approximation ratio of 94% compared to the exact brute force solution).

As a way to test the general applicability of this scheme, we performed some tests on more general circuits than the QAOA problem. These tests are meant to provide some early insight into how useful this heuristic would be for estimating the most likely bit string of a quantum algorithm, for the users who are interested in running this string estimation subroutine. We note that it is abundantly clear that in many cases this scheme does not produce a string closest to the most likely string—indeed, if it was a generally accurate scheme then we would have no need for a quantum computer.

In the remainder of this section, we consider the most likely bit string of the final state |ψ〉 = ∑_i ψ_i|i〉, which we define as argmax_i|ψ_i|², where the vectors {|i〉} are in the computational basis. We apply a unitary of the form (6) where the matrix D_j is a diagonal matrix with entries chosen randomly from the integers {1, ⋯, nm}. Here m is a parameter that could be interpreted as the number of clauses, if this were a QAOA problem. The elements of the p-dimensional vectors β and γ are drawn uniformly from [0, π] and [0, 2π] respectively. We use the construction of U_p(β, γ) to emulate the form of parametrized unitary operations used in QAOA with the same p. Starting from the uniform superposition over all 2ⁿ bit strings |s〉, we apply U_p to compute the final state . Let p_i = |ψ_i|² denote the probability distribution associated to the QAOA-like output state |Ψ〉. We ran 10,000 trials (with n = 6, m = 10, and p = 2) using Eq 6, and ranked the result by how many bit strings in the true state were more likely than our outputted bit string.

Conceptually, our likely string estimation algorithm can be thought of as falsely assuming that the output state is a product state. Suppose we apply our algorithm to the state |Ψ〉. The product state then reads (7) where |α_k|² is the probability of |0〉 that the algorithm obtains at the k^th step, with an analogous definition for β_k. With this conceptual framing, we also numerically study the 1-norm distance ∥p′ − p∥₁ between the approximate distribution p′ which the algorithm effectively assumes and the actual distribution p.

The results are shown in Fig 3. Here we use the number of qubits n = 6, with parameters m = 10 and p = 2. Fig 3(a) shows that most of the time our algorithm produces a high ranking bit string—roughly 90% of the time the output of the algorithm is among the top 10% most likely bit strings. Fig 3(b) shows that the 1-norm distance between the approximate and exact distributions is less than 0.1 for nearly all of the data points. These results suggest that our heuristic for estimating an output bit string will produce acceptable estimates for some circumstances—in QAOA for instance, where one might be interested in a good approximate (as opposed to exact) solution to the constraint satisfaction problem.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 3. Results from implementing 10,000 trials of Eq 6.

We use n = 6 qubits, m = 10, and p = 2. (a) The histogram plots how close the method’s output string is to the actual most likely string. qTorch’s procedure for the “estimate” is given in the text. The horizontal axis Ranking is the number of computational basis states in |Ψ〉 with higher probability than the estimated string—a lower number ranking indicates a better estimate. (b) Distribution of the 1-norm distance between the approximate distribution p′ arising from the product state approximation |Ψ′〉 in and the distribution p arising from the exact state |Ψ〉.

https://doi.org/10.1371/journal.pone.0208510.g003

4 Circuit simulations

Here we describe the classes of quantum circuits that were simulated for this work.

5 Results

Simulations were performed on the NERSC Cori supercomputer, using one “Knights Landing” (KNL) node per simulation, each of which contains 68 cores and 96 GB of memory. Each LIQUi|> simulation was run on a full node as well, using Docker [59] (computational details in the Appendix). The free version of LIQUi|> allows for the simulation of 24 qubits. Because full Hilbert space simulation scales exponentially regardless of the quantum algorithm’s complexity, we would not have been able to simulate more than ∼31 qubits on one of these compute nodes. For each set of parameters (regularity and number of vertices/qubits) 50 instances of Max-Cut/QAOA circuit were created. For higher qubit counts and higher regularities, only a subset of these circuits were completed, since many simulations exceeded memory capacity. In this section, LG or qTorch-LG refer to the use of qTorch with the linegraph-based contraction, Stoch or qTorch-Stoch refer to qTorch with stochastic contraction. To determine a qTorch-LG contraction ordering, QuickBB simulations were run for an arbitrary time of 3000 seconds for each quantum circuit. The plotted qTorch results do not include the QuickBB run time.

We note that LIQUi|> implements a thorough set of important optimizations, which makes it a fair benchmark against which to compare qTorch. For example, LIQUi|> fuses many gates together before acting on the state vector, and uses sparse operations. qTorch, on the other hand, does not yet use sparsity at all (even when the circuit consists primarily of sparse CNOT gates), which is one of several optimizations that we expect would further improve performance.

LIQUi|> is the fastest simulation method to use for the Hubbard simulations, as shown in Fig 4. This is because the treewidth of the circuit’s graph increases substantially with the number of qubits, even for these short-depth circuits. The result is not surprising—if the algorithm were easy to simulate with a tensor network on a classical computer, then it would not have been worth proposing as a candidate for a quantum computer.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 4. Time results for simulating quantum circuits of the Hubbard model.

LG, Stoch, and LIQUi|> denote linegraph-based tensor contraction, stochastic tensor contraction, and LIQUi|>, respectively. LIQUi|>’s full Hilbert simulation method is substantially faster than either tensor contraction method. Missing data points resulted from exceeding memory capacity.

https://doi.org/10.1371/journal.pone.0208510.g004

Simulation timing results for 3-, 4-, and 5-regular Max-Cut/QAOA circuits are shown using Tukey boxplots in Figs 5 and 6. Stoch and LG simulation times are of similar order of magnitude for these circuits, though LG is generally faster. The exception is the 3-regular graph problems, where Stoch often appears to find a more efficient contraction than the 3000-second run of QuickBB does. We note that if the QuickBB algorithm were run for infinite time before beginning the contraction, then qTorch-LG should always (except in very simple graphs) contract the circuit faster than qTorch-Stoch. This is because, while the Stoch search is purely local (considering only individual wires), the tree decomposition approach of QuickBB implicitly considers the effects of multiple contraction steps. Note that actual search time of Stoch is negligible compared to the tensor contraction time. Note that LIQUi|> begins to outperform tensor contraction methods once the algorithm is run on 5-regular graphs, because the increased circuit complexity leads to larger intermediate tensors in qTorch.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. Simulation time plotted against number of qubits for Max-Cut/QAOA circuits.

LG, Stoch, and LIQUi|> denote linegraph-based tensor contraction, stochastic tensor contraction, and the LIQUi|> software package, respectively. Tree decompositions for the LG method were determined by running the QuickBB simulation for 3000 seconds. For lower regularities, the tensor contraction methods outperform LIQUi|>, since LIQUi|> simulates the full Hilbert space. However, as the regularity of the Max-Cut graphs (and hence the treewidth of the quantum circuits’ line graphs) increase, full Hilbert space simulation using LIQUi|> becomes more efficient.

https://doi.org/10.1371/journal.pone.0208510.g005

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. Simulation time plotted against number of qubits for 3-regular Max-Cut/QAOA circuits.

LG and Stoch denote linegraph-based tensor contraction and stochastic tensor contraction respectively. For 3-regular Max-Cut/QAOA circuits, we were able to simulate a small subset of the 100-qubit circuits we created, not shown here.

https://doi.org/10.1371/journal.pone.0208510.g006

Note that in principle, Hilbert space simulation can be considered a subset of TN contraction, where the state vector is simply a large tensor. Hence one might expect that there would not be a crossover point at all, i.e. that in the worst case TN contraction would not ever be slower than Hilbert space simulation. However, because our implementation considers density matrices instead of state vectors, one would in fact expect this crossover point to exist. The largest tensor in qTorch would have 4^N entries, while the state vector has just 2^N entries. The various choices made in software implementations for qTorch and LIQUi|> would also affect the position of this crossover point.

Using a single Cori NERSC node, we were able to contract quantum circuits of 90 qubits for a very small subset of the simulated graphs, though not on enough graphs to report statistics. Full Hilbert space methods would be limited to ∼30 qubits on these nodes, and indeed previous simulation packages have not yet surpassed 46 qubits [2, 19], using thousands of nodes.

Interesting trends appear when the simulation time is plotted against regularity of the Max-Cut problem’s graph (Fig 7). It is notable that the LG method runs out of memory before the Stoch method does. As previously mentioned, the LG method contracts more efficiently the longer QuickBB has been run, and we chose 3000 seconds as an arbitrary QuickBB limit for all circuits. There is a trade-off between running a longer QuickBB simulation and instead immediately using the Stoch method. Even with few qubits, at higher regularities the full Hilbert space simulation (using LIQUi|>) performs better. This is expected, since as the complexity of the quantum circuit increases, higher-rank intermediate tensors appear.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. Simulation time plotted against the regularity of the underlying Max-Cut graph, for Max-Cut/QAOA circuits.

LG, Stoch, and LIQUi|> denote linegraph-based tensor contraction, stochastic tensor contraction, and LIQUi|>, respectively. As regularity increases, full Hilbert space simulation (using LIQUi| >) becomes a more competitive simulation method. Missing data points resulted from running out of memory.

https://doi.org/10.1371/journal.pone.0208510.g007

Fig 8 shows simulation time as the estimated upper bound for the treewidth increases, for Max-Cut/QAOA circuits of 18 qubits. These include 3- through 7-regular graphs. This treewidth upper bound is simply the treewidth of the tree decomposition that defines the contraction ordering. The plot shows the expected general trend of an increase simulation time with increased treewidth, regardless of contraction scheme.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 8. Simulation time plotted against approximate treewidth, for all simulated Max-Cut/QAOA quantum circuits of 18 qubits.

The plot demonstrates the general trend of increased simulation time with the quantum circuit’s line graphs’s treewidth, despite a constant number of qubits.

https://doi.org/10.1371/journal.pone.0208510.g008

Finally, we note that we were easily able to perform simulations of 100 qubits for less complex graphs. To report one such example, we produced a random 3-regular graph with a slightly different procedure from that given in of Section 4.1. Beginning with a 2-regular graph (i.e. a ring) of 100 vertices, we added edges between random pairs of vertices until all vertices were of 3 degrees. Contracting this graph’s Max-Cut/QAOA circuit took ∼150 seconds.

6 Conclusions

We have implemented a tensor contraction code for the efficient simulation of quantum circuits. We compared a stochastic contraction scheme to one based on the line graph of the quantum circuit’s graph, showing that the latter is more efficient in most circuits simulated herein. However, there is a subset of cases for which calculating an efficient approximate optimal tree decomposition of the line graph takes longer than contracting the circuit stochastically, in which case the stochastic scheme is superior. For the circuits studied in this work, our simulations suggest that the point at which qTorch is no longer faster than LIQUi| > occurs in QAOA/Max-Cut approximately when the Max-Cut graph has a regularity of five. In the future, qTorch may be used to estimate these points of equivalent computational cost in other classes of circuits, which may help to determine which simulation method to use in simulations.

Several immediate algorithmic improvements are possible for this software. The use of sparse tensors would reduce the number of floating point operations for some relevant circuits. Tensor decompositions (such as the singular value decomposition) along with trimming can be added as intermediate steps, as has been done in tensor network based simulations of physical systems [32, 34]. Additionally, more advanced parallelization methods would allow for faster calculation of a tree decomposition as well as faster contractions.

Supporting information

Acknowledgments

We are grateful to Edward Farhi and Aram Harrow for discussions about QAOA, to Salvatore Mandrà for general discussions, and to Dave Wecker for helpful advice on using LIQUi| >. N.S. acknowledges the use of resources of the National Energy Research Scientific Computing Center, a DOE Office of Science User Facility supported by the Office of Science of the U.S. Department of Energy under Contract No. DE-AC02-05CH11231. A.A.-G. and E.F. were supported by the Office of Naval Research under grant N00014-16-1-2008 (Vannevar Bush Faculty Fellowship). A. A.-G. and Y.C. were supported by NSF grant CHE-1655187.