...
42 | ```
43 | With default arguments this will create a new file with the same name as the old file, but with `-analog` appended to the end of the filename. For example, if you have a file called `my_bloqade.json`, the new file will be called `my_bloqade-analog.json`. You can then use `load` to deserialize this file with the `bloqade-analog` package. There are other options for converting the file, such as setting the indent level for the output file or overwriting the old file. You can see all the options by running:
44 |
45 | ```sh
46 | python -m bloqade.analog.migrate --help
47 | ```
48 |
49 | Another option is to use the migration tool in a python script:
50 |
51 | ```python
52 | from bloqade.analog.migrate import migrate
53 |
54 | # set the indent level for the output file
55 | indent: int = ...
56 | # set to True if you want to overwrite the old file, otherwise the new file will be created with -analog appended to the end of the filename
57 | overwrite: bool = ...
58 | f
59 | or filename in ["file1.json", "file2.json", ...]:
60 | migrate(filename, indent=indent, overwrite=overwrite)
61 | ```
62 | This will migrate all the files in the list to the new format.
63 |
64 |
65 | ## Having trouble, comments, or concerns?
66 |
67 | Please open an issue on our [GitHub](https://github.com/QuEraComputing/bloqade-analog/issues)
68 |
--------------------------------------------------------------------------------
/docs/digital/examples/index.md:
--------------------------------------------------------------------------------
1 | # Tutorials on digital circuits
2 |
3 | In this section you will find a number of tutorials and examples that show how you can use the digital bloqade subpackage, `bloqade-circuit`, in order to write quantum programs.
4 | The examples are split into sub-sections featuring the different [dialects](./dialects_and_kernels) and submodules.
5 |
6 | ## General tutorials
7 |
8 |
9 |
10 | - [Circuits with Bloqade](../tutorials/circuits_with_bloqade/)
11 |
12 | ---
13 |
14 | Learn how to use `bloqade-circuit` to write your quantum programs.
15 |
16 |
17 | - [Automatic Parallelism](../tutorials/auto_parallelism/)
18 |
19 | ---
20 |
21 | Explore the benefits of parallelizing your circuits.
22 |
23 |
24 |
25 |
26 | ## Squin
27 |
28 | Squin is bloqade-circuits central dialect used to build circuits and run them on simulators and hardware.
29 |
30 |
31 |
32 | - [Deutsch-Jozsa Algorithm](../examples/squin/deutsch_squin/)
33 |
34 | ---
35 |
36 | See how you can implement the fundamental Deutsch-Jozsa algorithm with a Squin kernel function.
37 |
38 |
39 | - [GHZ state preparation and noise](../examples/squin/ghz/)
40 |
41 | ---
42 |
43 | Inject noise manually in a simple squin kernel.
44 |
45 |
46 |
47 |
48 |
49 | ## Interoperability with other SDKs
50 |
51 | While bloqade-circuit provides a number of different dialects (eDSLs), it may also be convenient to transpile circuits written using other SDKs.
52 |
53 |
54 |
55 | - [Heuristic noise models applied to GHZ state preparation](../examples/interop/noisy_ghz/)
56 |
57 | ---
58 |
59 | Learn how to apply our heuristic noise models built to work with the cirq SDK.
60 |
61 |
62 |
63 |
64 | ## QASM2
65 |
66 | One of the most central languages used to define quantum programs is QASM2.
67 | You can also write your quantum programs using the QASM2 dialect directly in bloqade-circuit.
68 |
69 | !!! warning
70 |
71 | Some of the examples below use the `qasm2.extended` dialect, which adds more advanced language features, such as control flow.
72 | However, this dialect is deprecated and we recommend using `squin` instead.
73 |
74 |
75 |
76 |
77 |
78 | - [Quantum Fourier Transform](../examples/qasm2/qft/)
79 |
80 | ---
81 |
82 | An example showing how to implement the well-known Quantum Fourier Transform (QFT).
83 |
84 | - [GHZ Preparation and Parallelism](../examples/qasm2/ghz/)
85 |
86 | ---
87 |
88 | Learn how to use parallelism to reduce the circuit (execution) depth.
89 |
90 | - [Pauli Exponentiation for Quantum Simulation](../examples/qasm2/pauli_exponentiation/)
91 |
92 | ---
93 |
94 | Simulating Hamiltonian dynamics by exponentiating Pauli operators.
95 |
96 |
97 | - [Repeat until success with STAR gadget](../examples/qasm2/repeat_until_success/)
98 |
99 | ---
100 |
101 | Here's how to implement a Z phase gate with the repeat-until-success protocol.
102 |
103 |
104 |
--------------------------------------------------------------------------------
/docs/blog/.authors.yml:
--------------------------------------------------------------------------------
1 | authors:
2 | rogerluo:
3 | name: Xiuzhe (Roger) Luo
4 | description: I cast quantum spells. Senior Scientific Software Engineer at QuEra Computing Inc.
5 | avatar: https://github.com/Roger-luo.png
6 | url: https://rogerluo.dev
7 | weinbe58:
8 | name: Phillip Weinberg
9 | description: I build Classical and Quantum software. Senior Scientific Software Engineer at QuEra Computing Inc.
10 | avatar: https://github.com/weinbe58.png
11 | url: https://github.com/weinbe58
12 | kaihsin:
13 | name: Kai-Hsin Wu
14 | description: Scientific Software Engineer at QuEra Computing Inc.
15 | avatar: https://github.com/kaihsin.png
16 | url: https://github.com/kaihsin
17 | johnzl-777:
18 | name: John Long
19 | description: Scientific Software Developer at QuEra Computing Inc.
20 | avatar: https://github.com/johnzl-777.png
21 | url: https://github.com/johnzl-777
22 | yuval:
23 | name: Yuval Boger
24 | description: Chief Commercial Officer at QuEra Computing Inc.
25 | avatar: https://media.licdn.com/dms/image/v2/D5603AQHYz_g9GdF7jQ/profile-displayphoto-shrink_800_800/profile-displayphoto-shrink_800_800/0/1690639226393?e=1746057600&v=beta&t=Jji90LOhwmtBohp3FtD5peXCqkO_QFzOyt7gzdHNCZI
26 | url: https://www.linkedin.com/in/yuvalboger/
27 | shengtao:
28 | name: Shengtao Wang
29 | description: Quantum Algorithms & Applications Manager at QuEra Computing Inc.
30 | avatar: https://media.licdn.com/dms/image/v2/C5603AQH8_yNWMmTWbw/profile-displayphoto-shrink_400_400/profile-displayphoto-shrink_400_400/0/1572705692501?e=1746057600&v=beta&t=T_XyG8bvHA4gNIwZvGb0oteEXLO_6GaBx3p2P2e_Llw
31 | url: https://www.linkedin.com/in/shengtao-wang-aa6548178/
32 | takuya:
33 | name: Takuya Kitagawa
34 | description: President of QuEra Computing Inc.
35 | avatar: https://media.licdn.com/dms/image/v2/C4D03AQH1s7sGmGmfag/profile-displayphoto-shrink_400_400/profile-displayphoto-shrink_400_400/0/1516633791754?e=1746057600&v=beta&t=ClOY_mraAuv0uN7hQZhugcsYqPUlSvdBVG9IgtXb5sw
36 | url: https://www.linkedin.com/in/takuya-kitagawa-2b366117/
37 | dean:
38 | name: Dean Bogdanovic
39 | description: Discovering new technology applications. Senior Vice President of Engineering at QuEra Computing Inc.
40 | avatar: https://www.sdmmag.com/ext/resources/2022/05/03/Alef_Dean-Bogdanovic_Headshot.jpeg?1651611331
41 | url: https://www.linkedin.com/in/dbogdanovic/
42 | jwurtz:
43 | name: Jonathan Wurtz
44 | description: Quantum Solutions Lead at QuEra Computing Inc.
45 | avatar: https://github.com/jon-wurtz.png
46 | url: https://www.linkedin.com/in/jonathan-wurtz-7a4855181/
47 | dplankensteiner:
48 | name: David Plankensteiner
49 | description: Scientific Software Engineer at QuEra Computing Inc.
50 | avatar: https://github.com/david-pl.png
51 | url: https://github.com/david-pl
52 | lmartinez:
53 | name: Luis A. Martinez
54 | description: Research Scientist at QuEra Computing Inc.
55 | avatar: https://github.com/lamq317.png
56 | url: https://github.com/lamq317
57 | tcochran:
58 | name: Tyler A Cochran
59 | description: Quantum Scientist at QuEra Computing Inc.
60 | avatar: https://ca.slack-edge.com/T011VA51XJL-U08L2D8GMCY-abadd562fee2-512
61 | url: https://github.com/tcochran-quera
62 |
--------------------------------------------------------------------------------
/docs/analog/reference/standard.md:
--------------------------------------------------------------------------------
1 |
2 | # Build Workflow
3 | ```mermaid
4 |
5 | flowchart TD
6 | ProgramStart(["start"])
7 |
8 | Geometry("Geometry or Lattice")
9 |
10 | Coupling["Coupling
11 | -----------
12 | rydberg
13 | hyperfine"]
14 |
15 | Detuning["detuning"]
16 | Rabi["rabi"]
17 |
18 | Amplitude["amplitude"]
19 | Phase["phase"]
20 |
21 | SpaceModulation("SpatialModulation
22 | ----------------------
23 | uniform
24 | scale
25 | location
26 | ")
27 | Waveform{"Waveform
28 | ------------
29 | piecewise_linear
30 | piecewise_constant
31 | constant
32 | linear
33 | poly
34 | fn
35 | "}
36 |
37 | Options(["Options
38 | ---------
39 | assign
40 | batch_assign
41 | args
42 | parallelize
43 | "])
44 |
45 | Services(["Services
46 | ----------
47 | bloqade
48 | quera
49 | braket"])
50 |
51 | QuEraBackends(["Backends
52 | ------------
53 | mock
54 | cloud_mock
55 | aquila
56 | device"])
57 |
58 | BraketBackends(["Backends
59 | ------------
60 | aquila
61 | local_emulator"])
62 |
63 | BloqadeBackends(["Backends
64 | ------------
65 | python
66 | julia"])
67 |
68 | Execution("
69 | Execution hardware only
70 | -------------------------------
71 | run_async()
72 |
73 | Hardware and simulation
74 | -------------------------------
75 | run()
76 | __call__")
77 |
78 | ProgramStart -->|add_position| Geometry;
79 | Geometry --> Coupling;
80 | ProgramStart --> Coupling;
81 |
82 | Coupling --> Detuning;
83 | Coupling --> Rabi;
84 |
85 | Rabi --> Amplitude;
86 | Rabi --> Phase;
87 |
88 | Detuning --> SpaceModulation;
89 | Amplitude --> SpaceModulation;
90 | Phase --> SpaceModulation;
91 |
92 | SpaceModulation --> Waveform;
93 |
94 | Waveform --> Coupling;
95 | Waveform --> Services;
96 | Waveform --> Options;
97 | Options --> Services;
98 |
99 | Services -->|quera| QuEraBackends;
100 | Services -->|braket| BraketBackends;
101 | Services -->|bloqade| BloqadeBackends;
102 | QuEraBackends --> Execution;
103 | BraketBackends --> Execution;
104 | BloqadeBackends --> Execution;
105 |
106 | click ProgramStart "../bloqade/#bloqade.start";
107 | click Geometry "../bloqade/atom_arrangement/";
108 | click Coupling "../bloqade/builder/drive/";
109 | click Detuning "../bloqade/builder/field/#bloqade.builder.field.Detuning";
110 | click Rabi "../bloqade/builder/field/#bloqade.builder.field.Rabi";
111 | click Amplitude "../bloqade/builder/field/#bloqade.builder.field.Amplitude";
112 | click Phase "../bloqade/builder/field/#bloqade.builder.field.Phase";
113 | click SpaceModulation "../bloqade/builder/spatial/";
114 | click Waveform "../bloqade/builder/waveform/";
115 | click Options "../bloqade/builder/pragmas/";
116 | click Services "../bloqade/builder/backend/";
117 | click QuEraBackends "../bloqade/builder/backend/quera/#bloqade.builder.backend.quera.QuEraDeviceRoute";
118 | click BraketBackends "../bloqade/builder/backend/braket/#bloqade.builder.backend.braket.BraketDeviceRoute";
119 | click BloqadeBackends "../bloqade/builder/backend/bloqade/#bloqade.builder.backend.bloqade.BloqadeBackend";
120 | click Execution "../bloqade/ir/routine/braket/#bloqade.ir.routine.braket.BraketRoutine";
121 |
122 | ```
123 |
--------------------------------------------------------------------------------
/docs/digital/examples/qasm2/pauli_exponentiation.py:
--------------------------------------------------------------------------------
1 | # %% [markdown]
2 | # # Pauli Exponentiation for Quantum Simulation
3 | # In this example, we will consider a simple Pauli Exponentiation circuit.
4 |
5 | # %%
6 | import math
7 |
8 | from bloqade import qasm2
9 |
10 | # %% [markdown]
11 | # First, we define the `zzzz_gadget` function which is a simple implementation of Pauli Z exponentiation
12 | # with a parameterized angle `gamma`.
13 |
14 |
15 | # %%
16 | @qasm2.extended
17 | def zzzz_gadget(targets: tuple[qasm2.Qubit, ...], gamma: float):
18 | for i in range(len(targets) - 1):
19 | qasm2.cx(targets[i], targets[i + 1])
20 |
21 | qasm2.rz(targets[-1], gamma)
22 |
23 | for j in range(len(targets) - 1):
24 | qasm2.cx(targets[-j - 1], targets[-j - 2])
25 |
26 |
27 | # %% [markdown]
28 | # Next, we define the `pauli_basis_change` function which is a simple implementation of Pauli basis change
29 | # with a parameterized start and end Pauli basis.
30 |
31 |
32 | # %%
33 | @qasm2.extended
34 | def pauli_basis_change(targets: tuple[qasm2.Qubit, ...], start: str, end: str):
35 | # assert len(targets) == len(start)
36 | # assert len(targets) == len(end)
37 |
38 | # for qubit, start_pauli, end_pauli in zip(targets, start, end):
39 | for i in range(len(targets)):
40 | qubit = targets[i]
41 | start_pauli = start[i]
42 | end_pauli = end[i]
43 |
44 | target = start_pauli + end_pauli
45 | if target == "ZX":
46 | qasm2.ry(qubit, math.pi / 2)
47 | elif target == "ZY":
48 | qasm2.rx(qubit, -math.pi / 2)
49 | # elif target == "ZZ":
50 | # pass
51 | # elif target == "XX":
52 | # pass
53 | elif target == "XY":
54 | qasm2.rz(qubit, math.pi / 2)
55 | elif target == "XZ":
56 | qasm2.ry(qubit, -math.pi / 2)
57 | elif target == "YX":
58 | qasm2.rz(qubit, -math.pi / 2)
59 | # elif target == "YY":
60 | # pass
61 | elif target == "YZ":
62 | qasm2.rx(qubit, math.pi / 2)
63 |
64 |
65 | # %% [markdown]
66 | # Putting it all together, we define the `pauli_exponential` function which is a simple implementation of Pauli Exponentiation
67 | # with a parameterized Pauli basis and angle `gamma`.
68 | # %%
69 | @qasm2.extended
70 | def pauli_exponential(targets: tuple[qasm2.Qubit, ...], pauli: str, gamma: float):
71 | # assert len(targets) == len(pauli)
72 |
73 | pauli_basis_change(targets=targets, start="Z" * len(targets), end=pauli)
74 | zzzz_gadget(targets=targets, gamma=gamma)
75 | pauli_basis_change(targets=targets, start=pauli, end="Z" * len(targets))
76 |
77 |
78 | # %% [markdown]
79 | # Finally, we define the `main` function as the entry point of the program.
80 |
81 | #
82 | #
83 | # 
84 | #
85 | #
25 | #
26 | # 
27 | #
28 | #
59 | #
Circuit vs. Execution Depth
60 | #
61 | # Before going any further, it's worth distinguishing between the concept of circuit depth and circuit execution depth.
62 | # For example, in the following implementation, each CX gate instruction inside the for-loop is executed in sequence.
63 | # So even though the circuit depth is $log(N) = n$, the circuit execution depth is still $N$.
64 | #
65 | #
68 | #
69 | # 
70 | #
71 | #
150 | #
Using Closures to Capture Global Variables
151 | #
152 | # While bloqade.qasm2 permits a main program with arguments, standard QASM2 does not.
153 | # To get around this, we need to put the program in a closure.
154 | # Our Kirin compiler toolchain can capture the global variable inside the closure.
155 | # In this case, the n_qubits will be captured upon calling the ghz_log_simd(n_qubits) python function.
156 | # As a result, the returned QASM2 program will not have any arguments.
157 | #
158 | #
129 | #
Noise operators
130 | #
131 | # As opposed to standard gates, there is no standard library for noise statements as of now.
132 | # While we plan to add that in the future, also note how it can be convenient to separate the operator
133 | # from the gate application: we define the paired noise operator only once and apply it to different
134 | # pairs of qubits in the loop.
135 | #
136 | #
2 |
3 | 
4 | 
5 |
6 |
50 |
51 | 
52 |
53 |
72 |
73 | 
74 |
75 |
108 |
109 | 
110 |
111 |
153 |
154 |
155 | ## Features
156 |
157 |
158 | ### Customizable Atom Geometries
159 |
160 | You can easily explore a number of common geometric lattices with Bloqade's `atom_arrangement`'s:
161 |
162 | ```python
163 | from bloqade.analog.atom_arrangement import Lieb, Square, Chain, Kagome
164 |
165 | geometry_1 = Lieb(3)
166 | geometry_2 = Square(2)
167 | geometry_3 = Chain(5)
168 | geometry_4 = Kagome(3)
169 | ```
170 |
171 |
172 | If you're not satisfied with the [Bravais lattices](https://en.wikipedia.org/wiki/Bravais_lattice) we also allow you to modify existing Bravais lattices as follows:
173 |
174 | ```python
175 | geometry_5 = Kagome(3).add_position((10,11))
176 | ```
177 |
178 | You can also build your geometry completely from scratch:
179 |
180 | ```python
181 | from bloqade import start
182 |
183 | geometry = start.add_positions([(0,0), (6,0), (12,0)])
184 | ```
185 |
186 | ### Flexible Pulse Sequence Construction
187 |
188 | Define waveforms for pulse sequences any way you like by either building (and chaining!) them immediately as part of your program:
189 |
190 | ```python
191 | from bloqade.analog.atom_arrangement import Square
192 |
193 | geometry = Square(2)
194 | target_rabi_amplitude = geometry.rydberg.rabi.amplitude.uniform
195 | custom_rabi_amp_waveform = (
196 | target_rabi_amplitude
197 | .piecewise_linear(values=[0, 10, 10, 0], durations=[0.1, 3.5, 0.1])
198 | .piecewise_linear(values=[0, 5, 3, 0], durations=[0.2, 2.0, 0.2])
199 | )
200 | ```
201 |
202 | Or building them separately and applying them later:
203 |
204 | ```python
205 | from bloqade.analog.atom_arrangement import Square, Chain
206 |
207 | geometry_1 = Square(3)
208 | geometry_2 = Chain(5)
209 |
210 | target_rabi_amplitude = start.rydberg.rabi.amplitude.uniform
211 | pulse_sequence = target_rabi_amplitude.uniform.constant(value=2.0, duration=1.5).parse_sequence()
212 |
213 | program_1 = geometry_1.apply(pulse_sequence)
214 | program_2 = geometry_2.apply(pulse_sequence)
215 | ```
216 |
217 | ### Hardware and Emulation Backends
218 |
219 | Go from a fast and powerful emulator:
220 |
221 | ```python
222 | from bloqade.analog.atom_arrangement import Square
223 | from math import pi
224 |
225 | geometry = Square(3, lattice_spacing = 6.5)
226 | target_rabi_amplitude = geometry.rydberg.rabi.amplitude.uniform
227 | program = (
228 | target_rabi_amplitude
229 | .piecewise_linear(values = [0, pi/2, pi/2, 0], durations = [0.06, 1.0, 0.06])
230 | )
231 | emulation_results = program.bloqade.python().run(100)
232 | ```
233 |
234 | To real quantum hardware in a snap:
235 |
236 | ```python
237 | hardware_results = program.braket.aquila().run_async(100)
238 | ```
239 |
240 | ### Simple Parameter Sweeps
241 |
242 | Use variables to make parameter sweeps easy on both emulation and hardware:
243 |
244 | ```python
245 | from bloqade import start
246 | import numpy as np
247 |
248 | geometry = start.add_position((0,0))
249 | target_rabi_amplitude = geometry.rydberg.rabi.amplitude.uniform
250 | rabi_oscillation_program = (
251 | target_rabi_amplitude
252 | .piecewise_linear(durations = [0.06, "run_time", 0.06], values = [0, 15, 15, 0])
253 | )
254 | rabi_oscillation_job = rabi_oscillation_program.batch_assign(run_time=np.linspace(0, 3, 101))
255 |
256 | emulation_results = rabi_oscillation_job.bloqade.python().run(100)
257 | hardware_results = rabi_oscillation_job.braket.aquila().run(100)
258 | ```
259 |
260 | ```
261 | emulation_results.report().rydberg_densities()
262 | 0
263 | task_number
264 | 0 0.16
265 | 1 0.35
266 | 2 0.59
267 | 3 0.78
268 | 4 0.96
269 | ... ...
270 | 96 0.01
271 | 97 0.09
272 | 98 0.24
273 | 99 0.49
274 | 100 0.68
275 |
276 | [101 rows x 1 columns]
277 | ```
278 |
279 | ### Quick Results Analysis
280 |
281 | Want to just see some plots of your results? `.show()` will show you the way!
282 |
283 | ```python
284 | from bloqade.analog.atom_arrangement import Square
285 |
286 | rabi_amplitude_values = [0.0, 15.8, 15.8, 0.0]
287 | rabi_detuning_values = [-16.33, -16.33, 42.66, 42.66]
288 | durations = [0.8, 2.4, 0.8]
289 |
290 | geometry = Square(3, lattice_spacing=5.9)
291 | rabi_amplitude_waveform = (
292 | geometry
293 | .rydberg.rabi.amplitude.uniform.piecewise_linear(durations, rabi_amplitude_values)
294 | )
295 | program = (
296 | rabi_amplitude_waveform
297 | .detuning.uniform.piecewise_linear(durations, rabi_detuning_values)
298 | )
299 | emulation_results = program.bloqade.python().run(100)
300 | emulation_results.report().show()
301 | ```
302 | 
303 |
304 | ## Contributing to Bloqade
305 |
306 | Bloqade is released under the [Apache License, Version 2.0](https://github.com/QuEraComputing/bloqade-analog/blob/main/LICENSE). If you'd like the chance to shape the future of [neutral atom][neutral-atom-qubits] quantum computation, see our [Contributing Guide](contributing/index.md) for more info!
307 |
308 | [rabi-oscillation-wiki]: https://en.wikipedia.org/wiki/Rabi_cycle
309 | [neutral-atom-qubits]: home/background.md#neutral-atom-qubits
310 | [rydberg-hamiltonian]: home/background.md#rydberg-many-body-hamiltonian
311 |
--------------------------------------------------------------------------------
51 | # 
4 | 
5 |