mjhjmtu

I am trying to reconstruct the time evolution of a Hamiltonian on the quantum computing simulator, quirk. Ideally I would like to generalise this to any simulator. The unitary matrix is

$$U(t)=e^-iHt$$

and I've found a way to decompose the Hamiltonian into the following form:

$$U(t)=A+B(t)$$

Both $A$ and $B(t)$ can be implemented individually. (Although A is a non-unitary diagonal matrix consisting of 0s and 1s) One with a static, custom matrix gate and the other using a series of time dependent and standard gates.

Is there a systematic way to reconstruct $U(t)$ generally? There is no limit on the number of ancillary gates

What you are trying to do is called Hamiltonian Simulation.

If your exponential can be split in a sum of unitary matrices, @smapers' answer guide you to a good algorithm: the Linear Combination of Unitary (LCU) algorithm.

In addition to the paper linked by @smapers, here are some other papers/videos explaining LCU:

• 
  

  Maybe the first paper to present LCU: Simulating Hamiltonian dynamics with a truncated Taylor series (Dominic W. Berry, Andrew M. Childs, Richard Cleve, Robin Kothari, Rolando D. Somma, 2015).

  
  
  

  The paper is quite concise but explains the idea behind this algorithm.

  
  



• A presentation given by Nathan Wiebe at a conference. He explains quickly what is LCU and how it works.




• A presentation given by Robin Kothari at the same conference. You should look the whole presentation from the beginning, but if you don't have the time I provided you a link directly to the part about LCU algorithm.



• 
  

  Finally, a paper explaining in details how LCU works and how they implemented LCU for a very specific kind of Hamiltonian: Toward the first quantum simulation with quantum speedup (Andrew M. Childs, Dmitri Maslov, Yunseong Nam, Neil J. Ross, Yuan Su, 2017). The parts about LCU are spread in the whole article, look at all the parts dealing with the TS (Taylor Series) algorithm:

  
  
  
  1. Section 3.2 (page 4) for a 2-paragraph summary.
  
  
  2. Appendix C.2 (page 13) for an explanation of the TS/LCU algorithms.
  
  
  3. Appendix G (page 38) for an error analysis and for an explanation on how they implemented some sub-routines needed by the LCU algorithm.
  
  

PS: there are plenty of other algorithms to perform Hamiltonian simulation. If your exponential can be split into known unitary matrices, LCU is probably the best algorithm, but you should know that it is not the only algorithm capable of simulating Hamiltonian. You can find more links in one of my previous answers about Hamiltonian Simulation. If you think you need more links on Hamiltonian Simulation algorithms just let me know.

Below is a recent paper by Gilyén et al on doing "quantum matrix arithmetics", allowing to implement linear combinations of unitary operators. They consider the general case where the linear combination in itself might not be unitary. Since the linear combination in your case is unitary, maybe there's a more efficient way.

[1]: Gilyén, András, et al. "Quantum singular value transformation and beyond: exponential improvements for quantum matrix arithmetics." arXiv preprint arXiv:1806.01838 (2018).

It seems that you need oblivious fixed point amplitude amplification. See Theorem 26-28 in the aforementioned paper: https://arxiv.org/pdf/1806.01838.pdf

As a first step, you can implement (A+B(t))/2 as a block of a unitary. This is however not a unitary itself, but then you can turn it into a unitary using oblivious fixed point amplitude amplification. If you also happen to know the (spectral) norm of A+B(t), then ordinary oblivious amplitude amplification suffices.