Neutral and cold atom machines are getting a lot of attention. Libraries are available to successfully simulate the behavior of neutral-atom machines and to create calculations!

Bloqade.jl

The language is written in Julia. Documentation is available, so let's take a look!

https://queracomputing.github.io/Bloqade.jl/dev/

This article is about a year older than this one, but I wrote an introductory article. Let's quickly review it.

An Overview of QuEra's Cooled Atomic Machine, Part 1(sorry in Japanese)

https://blueqat.com/yuichiro_minato2/cee2ebdc-0878-4da7-ae4f-e9b0c2003f7d

引用：https://arxiv.org/abs/2012.12281

So yes, it was like this. It was optical tweezers to trap atoms, dynamic optical tweezers to move them around, and then laser time development.

An overview of QuEra's cooled atom machine, Part 2, including implementation equipment and hardware algorithms.(Japanese)

https://blueqat.com/yuichiro_minato2/24d6f7e3-c790-475d-a7fa-e9ff1595b480

There was quite a lot going on, and I found all sorts of geeky stuff about algorithms for rearranging atoms and even how to apply beams.

Overview of Rydberg atom-based quantum simulator calculation methods

https://blueqat.com/yuichiro_minato2/04cf37d1-e634-436c-95e1-ce7f3ce8c159

The principle was the interaction of transverse magnetic field, local magnetic field, and Rydberg state. The parameters could be varied with time, but the distance was a fixed value determined by the Rydberg radius.

And the time evolution was also determined by the Hamiltonian prepared for this neutral atom. There were various parameter manipulations, time evolution, and how to create the final ordering pattern.

It looks somewhat interesting, so let's take a quick look at bloqade.

Analog and Digital Modes of Neutral Atom Quantum Computers

Since a quantum computer is a digital computer that manipulates 01, the neutral atom seems to use the usual two ground states for 01 calculations and the interaction uses the Rydberg state for entanglement. This one is also described as a "digital mode" in the neutral atom machine. This bloqade is not in the digital mode, but in the analog mode, which uses the ground state |g> and the Rydberg state |r> for the calculation.

The analog mode means that you can perform time evolution simulations of quantum states according to the Rydberg Hamiltonian. Please see the detailed explanation from the previous article.

The steps to perform the calculation are

Positioning the atoms

Determine the waveforms of the Hamiltonian parameters

Create the Hamiltonian

Set initial conditions

Emulation

Measurement

The process is as follows. It is more like designing a simulation based on a specific formula rather than designing a regular quantum circuit.

Let's take a look at the programming method. First, load the Julia tool.

julia> using Bloqade

This example seems to determine the distance between atoms in one dimension.

julia> nsites = 10;
julia> atoms = generate_sites(ChainLattice(), nsites, scale = 5.74)
10-element AtomList{1, Float64}:
(0.0,)
(5.74,)
(11.48,)
(17.22,)
(22.96,)
(28.700000000000003,)
(34.44,)
(40.18,)
(45.92,)
(51.660000000000004,)

Interesting. We have 10 atoms in one dimension, arranged every 5.74 micrometers.

We can then generate the Hamiltonian by determining the parameters given.

As far as this is concerned, the first term is the interaction. You can see the Rydberg radius. The next terms would be the transverse magnetic field and the local magnetic field.

julia> h = rydberg_h(atoms; Ω = 4 * 2π, Δ = 0)
nqubits: 10

├─ [+] ∑ 2π ⋅ 8.627e5.0/|r_i-r_j|^6 n_i n_j
├─ [+] 2π ⋅ 2.0 ⋅ ∑ σ^x_i
└─ [-] 2π ⋅ 0.0 ⋅ ∑ n_i

Then we create the initial state,

julia> reg = zero_state(10)
ArrayReg{2, ComplexF64, Array...}
active qubits: 10/10
nlevel: 2

Here, start from the 0 state. This seems to refer to the ground state.

The next step seems to be a quick time evolution. We calculate the time evolution of the 1.6 microsecond Hamiltonian on the initial state reg.

julia> prob = SchrodingerProblem(reg, 1.6, h)
SchrodingerProblem:
register info:
type: ArrayReg{2, ComplexF64, Matrix{ComplexF64}}
storage size: 8 bytes
time span (μs): (0.0, 1.6)
equation:
storage size: 183.836 KiB
expression:
nqubits: 10
+
├─ [+] ∑ 2π ⋅ 8.627e5.0/|r_i-r_j|^6 n_i n_j
├─ [+] 2π ⋅ 2.0 ⋅ ∑ σ^x_i
└─ [-] 2π ⋅ 0.0 ⋅ ∑ n_i
options:
save_everystep: false
save_start: false
save_on: false
dense: false
julia> integrator = init(prob, Vern8());
julia> emulate!(prob);

The final result is called Density, which apparently represents the probability of getting a 1.

julia> rydberg_populations = map(1:nsites) do i
rydberg_density(prob.reg, i)
end
10-element Vector{Float64}:
0.42192188992855195
0.17593452666204634
0.2841395261750055
0.20000113642535258
0.30570488901568105
0.30570488901567827
0.20000113642535058
0.28413952617500376
0.17593452666205112
0.4219218899285506

Although it looks like a library to run a fairly accurate and complex problem with Julia, the Hamiltonian is quite limited in analog mode, and I have a feeling that there are many things to learn in the future, such as how to set the parameters.

I have only taken a cursory look at it this time, but it is not yet clear how far it can be calculated, so I would like to delve into it in detail little by little. Also, since it seemed to me that it supports combinatorial optimization, I felt that it will be a calculation like QAOA and QA for a while.