### Testing the performance of Ava on a typical computational physics problem.

The transverse field Ising model is the ‘quantum version' of the well-known Ising model. It consists of a lattice of interacting spins in the presence of an external (transverse) magnetic field. We focus on the two dimensional case, which is further away from its mean-field description than its higher dimensional counterparts, yet (for non-zero magnetic field) does not admit an analytical solution like it does in one dimension, making it difficult to study. The boundary conditions are often assumed to be either periodic or open.

The (spin-1/2) Hamiltonian for the system is described by

where *<i,j>* denotes nearest-neighbour sites on the lattice, *J* and *h* are (real) parameters, and *Z* and *X* are the Pauli-*Z* and -*X* operators, respectively.

Depending on the goal, this system can be difficult to study using classical (computational) techniques. For instance, one may wish to evolve the system forward in time (starting from some initial state) and compute observables at regular intervals, e.g. the energy of the system. This is a reasonably trivial task for a fault tolerant quantum computer, and is an instance of a problem for which quantum computers could aid in the numerical study of physics systems.

To perform the time evolution on a quantum computer, all that needs to be done is to implement the time evolution operator for the system, *exp(iHt)*, where *t* is the duration of the time evolution. To do this, we can use __'Trotterization____'__ to decompose the operator into a sequence of 1- and 2-qubit gates that can be implemented on a quantum computer. For a model with open boundary conditions, as we use here, this yields a quantum circuit with 2-dimensional connectivity whose depth depends on the length of time for which the system is evolved.

## Emulation benchmarks

Below, we benchmark our emulator on quantum circuits implementing time evolution of the transverse field Ising model for different numbers of qubits, and different circuit depths (lengths of time). The time evolution has the following settings for the Hamiltonian and Trotterization:

J = -1

h = 2

Open boundary conditions

Trotter step size dt = 0.2

Initial state: all-zeros state

In Figure 2 below, we show the runtime and fidelity achieved by Ava for different values of the bond dimension (D) across different numbers of qubits. We see that as the number of qubits increases, the runtime increases and the fidelity decreases, as one would expect.

Next, we see the runtime required to reach a particular fidelity (Figure 3) and the fidelity achieved within a particular time (Figure 4) for a range of qubit numbers and circuit depths, all running on a single Nvidia H100 with 96Gb of memory. These again emphasize the relationship between qubit count, circuit depth, and bond dimension in a tensor network emulation.

It is worth noting at this point that a statevector simulation running on the same H100 GPU can handle at most 32 qubits, and that every qubit requires doubling the memory — meaning that, memory-wise, **1024 H100’s** would be required to run a 42-qubit simulation. The ability to simulate, say, 64 qubits in under 5 minutes and achieve a good fidelity is not possible with statevector methods.

## Closer inspection

To inspect the relationship between bond dimension and fidelity closer, and to investigate the effect that a non-perfect fidelity has on the quality of the emulation, we show extended results for the 8x7 = 56 qubit TFIM - this time with **periodic** boundary conditions - below, where the time-evolution was run for 40 Trotter steps, yielding a circuit of depth 762 with 4480 2-qubit gates.

This circuit is rather difficult to emulate - even at bond dimension 4000 we only achieve fidelity 0.52 at the end of the simulation, after 40 Trotter steps.

However, all is not lost -- we can use a fairly simple technique to improve the accuracy of the result: **bond dimension extrapolation**. To see how this works, suppose we are interested in tracking the energy of the state as it evolves in time. We could plot the energy after each Trotter step:

This plot may not be reliable as the number of Trotter steps increases, because the fidelity decreases as the circuit depth increases:

In the regime where the fidelity is less than one, we can use the energies computed at every fidelity (i.e. every non-maximal value of the bond dimension) to attempt to extrapolate the value of the energy to the fidelity = 1 regime.

To see what these extrapolations might look like, we show two below: one for the energy after 5 Trotter steps (when the fidelity is still quite high), and another after 30 Trotter steps (when the fidelity is quite low).

The extrapolation at 5 Trotter steps appears to be quite reliable: whilst the energy does not converge in fidelity, it does sit on a straight line with a small distance to the fidelity 1 point. For 30 Trotter steps, the uncertainty in the extrapolation is significantly higher: whilst the data points sit on a reasonably straight line, there is a large distance from the highest fidelity data point (<0.6) to fidelity 1.

We can use these extrapolated values to improve the accuracy of our plot of energy over time. Below is a plot of energy over time for increasing values of the bond dimension, and the extrapolation of these to fidelity one.

We saw in the plots above that low fidelity tends to yield lower energies, and so the extrapolations serve to 'correct' this bias. To what extent the extrapolated values can be trusted depends on the use-case and tolerance to error. However, they can serve as a useful tool to investigate regimes that are difficult or impossible to simulate with perfect fidelity.

## Conclusion

In this post we shared some of the results from our benchmarking of Ava on quantum circuits implementing time evolution of the transverse-field Ising model. Thanks to Ava's scalability, we were able to simulate circuits on up to 100 qubits in reasonable time, starting from non-trivial initial states. For one of these circuits, we presented more detailed results obtained by simulating at high accuracy using bond dimensions of up to 4000, all on a single Nvidia H100. Using a simple technique known as bond dimension extrapolation, we were able to obtain qualitatively informative results for circuits several hundreds of layers deep and consisting of a few thousand 2-qubit gates.

## Comentários