Rydberg Atoms Simulation

marcorossignolo commented 2 years ago

Describe the missing feature

The current Qubit class in the chip module is not suitable for a Rydberg Atom simulation. In particular, I am interested in the position of a qubit in a lattice and the pairwise long-range Van Der Walls (VdW) interaction. What I have in mind is the simulation of the dynamics for the following Ising-type Hamiltonian for N qubits:

H = \Omega(t) \sum{i} \sigma{x, i} + \delta(t) \sum{i} \sigma{z, i} + \sum{i<j} U{i,j} n{i} n{j}

where

\sigma_{a, i} with a={x, y, z} and i={1, ..., N} is the pauli matrix acting on the ith qubit
\Omega(t) is the amplitude pulse
\delta(t) is the detuning pulse
U_{i, j} is the long range VdW interaction
n{i} = (1 + \sigma{z, i}) is the number operator for the i-th qubit

Describe the solution you'd like

I would like to introduce a new subclass called RydergAtom that inherits the functionalities of the PhysicalComponent class. The RydbergAtom will then contain the position of the atom in the lattice. In order to build the VdW term, a new Coupling class could be written in which the relative position of the two atoms has to be considered. The Hamiltonian function for the VdW will then be specified in the "hamiltonians" module.

Describe alternatives you've considered

To create the RydbergAtom subclass the following alternatives were considered:

Subclass the Qubit class in chip.py
Subclass the PhysicalComponent class
First, make the Qubit class more generic such that it is not only a superconducting qubit and then subclass this Qubit class I am opting for the second option, as specified in the previous section, since it is a compromise between generality and speed.

Additional context

The components for the model are q_i = chip.RydbergAtom(..., position=[a, b],...) : the i-th atom in the lattice at the position [a,b] The drives, i.e. the amplitude and the detuning are: amplitude = chip.Drive(..., connected=[q_1, ..., q_N], ...) detuning = chip.Drive(..., connected=[q_1, ..., q_N], ...)

and finally the interaction: interaction = chip.VanDerWalls(connected=[[q_1, q2], ..., [q{N-1}, q_{N}]])

All of those components will be then given as parameter to the Model class:

model = Mdl(None, # individual, self-contained components [amplitude, detuning, interaction], # Interaction between components )

nwittler commented 2 years ago

The observation is completely correct that the current Qubit class is really a superconducting qubit and the current Model a superconducting chip. So, I'd propose to try and make the Rydberg simulation inherit from Model directly. That would give you more freedom to implement the Hamiltonian, etc. I know, it is not well documented but for the rest of the code to work, the Model needs to provide very few methods, most importantly get_Hamiltonian(signal) where signal is a dict, in your case something like

signal = {
      "amplitude": [ ...] ,
      "detuning:" [...]
}

This seems to be the easiest way to realize the ordered sum. This class would need to have only the U_ij matrix to be initialized, as the number of qubits is the dimension, right? Again, I know it's not ideal, but starting with a minimal RydbergModel class and implementing only the methods required seems to be the way to go. This can also provide some learnings about how to properly define the interfaces.

shaimach commented 2 years ago

May be relevant: How did Kevin implement the NV-center Hamiltonian?

On Thu, May 12, 2022 at 11:54 AM Nicolas Wittler @.***> wrote:

The observation is completely correct that the current Qubit class is really a superconducting qubit and the current Model a superconducting chip. So, I'd propose to try and make the Rydberg simulation inherit from Model directly. That would give you more freedom to implement the Hamiltonian, etc. I know, it is not well documented but for the rest of the code to work, the Model needs to provide very few methods, most importantly get_Hamiltonian(signal) where signal is a dict, in your case something like

signal = {
  "amplitude": [ ...] ,

  "detuning:" [...]
}

´´´

This seems to be the easiest way to realize the ordered sum. This class would need to have only the U_ij matrix to be initialized, as the number of qubits is the dimension, right?

Again, I know it's not ideal, but starting with a minimal RydbergModel class and implementing only the methods required seems to be the way to go. This can also provide some learnings about how to properly define the interfaces.

— Reply to this email directly, view it on GitHub https://github.com/q-optimize/c3/issues/198#issuecomment-1124710039, or unsubscribe https://github.com/notifications/unsubscribe-auth/AAH3Q4NEPMCYOQ6BETLVSWTVJTBMHANCNFSM5VVQXIXQ . You are receiving this because you are subscribed to this thread.Message ID: @.***>

marcorossignolo commented 2 years ago

This class would need to have only the U_ij matrix to be initialized, as the number of qubits is the dimension, right?

Yes, the coefficients U{i,j} scale as N * (N - 1), where N is the number of the qubits, and they are a function of the distance between two qubits i.e. |\vec{r}{i} - \vec{r}_{j}|.

q-optimize / c3