Phase summation in sampler produces incorrect σx/σy decomposition

[cedrickperron]

Pulser combines (sums) the sampled amplitude, detuning, and phase contributions for each qubit when constructing the effective Hamiltonian.

However, this procedure does not reproduce the correct QuTiP Hamiltonian for pulse sequences intended to generate a Hamiltonian of the form

$$ H = \frac{\Omega(t)}{2} \sum_{i=1}^{N} \left[ \sigma_i^x + \sigma_i^y \right] ;-; \Delta(t) \sum_{i=1}^{N} \hat{n}_i ;+; \sum_{j>i} V_{ij} \hat{n}_i \hat{n}_j. $$

Such a Hamiltonian can be constructed by applying two pulses sequentially:

1. A first pulse with parameters
   $$ (\Omega(t), \Delta(t), \phi = 0) $$
2. A second pulse with parameters
   $$(\Omega(t), \Delta(t), \phi = \pi/2)$$

Physically, these two pulses should generate independent contributions proportional to $\sigma^x$ and $\sigma^y$, respectively.

However, Pulser does not reconstruct the correct QuTiP Hamiltonian because it directly sums the phase arrays of pulses acting on the same target qubit instead of converting each pulse into its Cartesian components

$$ \Omega \cos(\phi), \sigma^x \quad \text{and} \quad \Omega \sin(\phi), \sigma^y $$

before summation.

The relevant implementation can be found in:

• pulser_core/pulser/sampler/samples.py (line 573 for global devices),
• pulser_core/pulser/sampler/samples.py (line 581 for local devices).

As a result, the combined pulses yield:

• An effective amplitude of $2 \cdot \Omega(t)/2 = \Omega(t)$,
• A detuning of $\Delta(t)$,
• A phase equal to $0 + \pi/2 = \pi/2$,

which does not correspond to the intended Hamiltonian structure in the $\sigma^x / \sigma^y$ basis.

Below, we compare the Hamiltonian expected from QuTiP with the Hamiltonian returned by Pulser.

XY_Pulser_Error.ipynb

[HGSilveri]

Hi @cedrickperron , thanks for reaching out!

In your explanation, you say

However, this procedure does not reproduce the correct QuTiP Hamiltonian for pulse sequences intended to generate a Hamiltonian of the form

H = Ω ( t ) 2 ∑ i = 1 N [ σ i x + σ i y ] ; − ; Δ ( t ) ∑ i = 1 N n ^ i ; + ; ∑ j > i V i j n ^ i n ^ j .

Such a Hamiltonian can be constructed by applying two pulses sequentially:
...

I believe there is a misunderstanding here. The Hamiltonian you show is not one you get from the application of two sequential pulses. In fact, your code shows that what you intend is rather the simultaneous application of these two pulses. This is what you meant, right?

Why this doesn't work in Pulser

You are right in your diagnostic: Pulser does sum $$\Omega(t)$$, $$\delta(t)$$ and $$\phi(t)$$ over all channels driving the same transition on the same atom and this is not correct.

The justification behind this is arguably shallow: Pulser emulation was simply not designed to support multiple channels driving the same transition simultaneously. This is why the default protocol when you add a pulse ("min-delay") on a "busy" atom is to add it only after the current pulse is done - and why you had to override with the "no-delay" protocol option in your example.

I can't promise that we will change this behavior to support your usecase because it has deep ramifications in how our emulators are designed. However, we can at least raise a warning in such cases, so we'll at least do that.

The silver lining is that you can still encode your Hamiltonian, you just have to do it differently.

How to encode your desired Hamiltonian

To make the desired Hamiltonian in Pulser, what you want to do instead is to make a pulse on a single channel with

$$\phi = -\frac{\pi}{4}$$ $$\Omega(t) -> \sqrt{2}\Omega(t)$$

I'll let you check for yourself why this is equivalent from Pulser's Hamiltonian definition.

[cedrickperron]

Yes, I mean applying the drives \textbf{simultaneously} rather than sequentially.

In the special case where $\Omega_x(t) = \Omega_y(t)$ for all $t$, I agree that we can encode the desired Hamiltonian with a fixed phase $\phi = -\pi/4$. However, in the general case where $\Omega_x(t) \neq \Omega_y(t)$, the phase becomes time-dependent, $\phi(t)$. An example where this situation occurs is in counter-diabatic drivings for instance.

Now, a standard way to implement a time-dependent phase $\phi(t)$ is to apply a \textbf{Z-rotation} to the Hamiltonian via the unitary
$$U = \exp\Big(i \frac{\phi(t)}{2} \sigma^z\Big),$$
which effectively shifts the detuning:
$$ \Delta^{\text{Z-rot}}(t) = \Delta(t) + \partial_t \phi(t) $$
This was described on p.~10 of \href{https://arxiv.org/pdf/2405.14829}{arXiv:2405.14829}. Effectively, this takes a Hamiltonian with X, Y, and Z terms and transforms it into a rotated Hamiltonian with only X and Z terms.

However, I am working in situations where $\phi(t)$ is computed numerically, thus taking $\partial_t \phi(t)$ amounts to doing a numerical differentiation on top of numerical data, which can be highly unstable and prone to large errors. This is why I was hoping to check a X, Y, Z Hamiltonian specifically.

Nevertheless, perhaps Pulser could implement this $Z$-rotation internally, to produce a final Hamiltonian that is compatible with current emulators.

[HGSilveri]

Hi again @cedrickperron , thanks for the details.

In this case, have you considered using Pulse.ArbitraryPhase()? It sounds like it could suit your needs, though it will be internally doing the numerical differentiation you are afraid of. Could you not draw the sequence to see if you are getting spikes in the detuning?

By the way, you can draw any sequence as if it were being phase modulated with the as_phase_modulated=True option.