Skip to content

Field

Detuning 

Detuning(parent: Optional[Builder] = None)

Bases: Field

This node represent detuning field of a specified level coupling (rydberg or hyperfine) type.

Examples:

- To specify detuning of rydberg coupling:

>>> node = bloqade.start.rydberg.detuning
>>> type(node)
<class 'bloqade.builder.field.Detuning'>

- To specify detuning of hyperfine coupling:

>>> node = bloqade.start.hyperfine.detuning
>>> type(node)
<class 'bloqade.builder.field.Detuning'>
Note

This node is a SpatialModulation node. See [SpatialModulation][bloqade.builder.field.SpatialModulation] for additional options.

Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/base.py 
10
11
12
13
14
def __init__(
    self,
    parent: Optional["Builder"] = None,
) -> None:
    self.__parent__ = parent

Field 

Field(parent: Optional[Builder] = None)

Bases: Builder

Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/base.py 
10
11
12
13
14
def __init__(
    self,
    parent: Optional["Builder"] = None,
) -> None:
    self.__parent__ = parent

uniform property 

uniform: Uniform

Address all atoms as part of defining the spatial modulation component of a drive.

Next steps to build your program include choosing the waveform that will be summed with the spatial modulation to create a drive.

The drive by itself, or the sum of subsequent drives (created by just chaining the construction of drives) will become the field (e.g. Detuning Field, Real-Valued Rabi Amplitude/Rabi Phase Field, etc.).

  • You can now do:
    • ...uniform.linear(start, stop, duration) : to apply a linear waveform
    • ...uniform.constant(value, duration) : to apply a constant waveform
    • ...uniform.poly([coefficients], duration) : to apply a polynomial waveform
    • ...uniform.apply(wf:bloqade.ir.Waveform): to apply a pre-defined waveform
    • ...uniform.piecewise_linear([durations], [values]): to apply a piecewise linear waveform
    • ...uniform.piecewise_constant([durations], [values]): to apply a piecewise constant waveform
    • ...uniform.fn(f(t,...)): to apply a function as a waveform

location 

location(
    labels: Union[List[int], int],
    scales: Union[
        List[ScalarType], ScalarType, None
    ] = None,
) -> Location

Address a single atom (or multiple) atoms.

Address a single atom (or multiple) as part of defining the spatial modulation component of a drive. You can specify the atoms to target as a list of labels and a list of scales. The scales are used to multiply the waveform that is applied to the atom. You can also specify a single label and scale to target a single atom.

Next steps to build your program include choosing the waveform that will be summed with the spatial modulation to create a drive.

The drive by itself, or the sum of subsequent drives (created by just chaining the construction of drives) will become the field. (e.g. Detuning Field, Real-Valued Rabi Amplitude/Rabi Phase Field, etc.)

Usage Example:
>>> prog = start.add_position([(0,0),(1,4),(2,8)]).rydberg.rabi
# to target a single atom with a waveform
>>> one_location_prog = prog.location(0)
# to target a single atom with a scale
>>> one_location_prog = prog.location(0, 0.5)
# to target multiple atoms with same waveform
>>> multi_location_prog = prog.location([0, 2])
# to target multiple atoms with different scales
>>> multi_location_prog = prog.location([0, 2], [0.5, "scale"])
  • You can now do:
    • ...location(labels, scales).linear(start, stop, duration) : to apply a linear waveform
    • ...location(labels, scales).constant(value, duration) : to apply a constant waveform
    • ...location(labels, scales).poly([coefficients], duration) : to apply a polynomial waveform
    • ...location(labels, scales).apply(wf:bloqade.ir.Waveform): to apply a pre-defined waveform
    • ...location(labels, scales).piecewise_linear([durations], [values]): to apply a piecewise linear waveform
    • ...location(labels, scales).piecewise_constant([durations], [values]): to apply a piecewise constant waveform
    • ...location(labels, scales).fn(f(t,..)): to apply a function as a waveform
Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/field.py 
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
def location(
    self,
    labels: Union[List[int], int],
    scales: Union[List[ScalarType], ScalarType, None] = None,
) -> "Location":
    """Address a single atom (or multiple) atoms.

    Address a single atom (or multiple) as part of defining the spatial
    modulation component of a drive. You can specify the atoms to target
    as a list of labels and a list of scales. The scales are used to
    multiply the waveform that is applied to the atom. You can also specify
    a single label and scale to target a single atom.

    Next steps to build your program include choosing the waveform that
    will be summed with the spatial modulation to create a drive.

    The drive by itself, or the sum of subsequent drives (created by just
    chaining the construction of drives) will become the field.
    (e.g. Detuning Field, Real-Valued Rabi Amplitude/Rabi Phase Field, etc.)

    ### Usage Example:
    ```
    >>> prog = start.add_position([(0,0),(1,4),(2,8)]).rydberg.rabi
    # to target a single atom with a waveform
    >>> one_location_prog = prog.location(0)
    # to target a single atom with a scale
    >>> one_location_prog = prog.location(0, 0.5)
    # to target multiple atoms with same waveform
    >>> multi_location_prog = prog.location([0, 2])
    # to target multiple atoms with different scales
    >>> multi_location_prog = prog.location([0, 2], [0.5, "scale"])
    ```

    - You can now do:
        - `...location(labels, scales).linear(start, stop, duration)` : to apply
            a linear waveform
        - `...location(labels, scales).constant(value, duration)` : to apply
            a constant waveform
        - `...location(labels, scales).poly([coefficients], duration)` : to apply
            a polynomial waveform
        - `...location(labels, scales).apply(wf:bloqade.ir.Waveform)`: to apply
            a pre-defined waveform
        - `...location(labels, scales).piecewise_linear([durations], [values])`:
            to apply
            a piecewise linear waveform
        - `...location(labels, scales).piecewise_constant([durations], [values])`:
            to apply
            a piecewise constant waveform
        - `...location(labels, scales).fn(f(t,..))`: to apply a function as a
            waveform

    """
    return self._location(labels, scales)

scale 

scale(coeffs: Union[str, List[ScalarType]]) -> Scale

Address all the atoms scaling each atom with an element of the list or define a variable name for the scale list to be assigned later by defining a name and using assign or batch_assign later.

Next steps to build your program include choosing the waveform that will be summed with the spatial modulation to create a drive.

The drive by itself, or the sum of subsequent drives (created by just chaining the construction of drives) will become the field (e.g. Detuning Field, Real-Valued Rabi Amplitude/Rabi Phase Field, etc.)

Usage Example:
>>> prog = start.add_position([(0,0),(1,4),(2,8)]).rydberg.rabi

# assign a literal list of values to scale each atom
>>> one_location_prog = prog.scale([0.1, 0.2, 0.3])
# assign a variable name to be assigned later
>>> one_location_prog = prog.scale("a")
# "a" can be assigned in the END of the program during variable assignment
# using a list of values, indicating the scaling for each atom
>>> single_assignment = ...assign(a = [0.1, 0.2, 0.3])
# a list of lists, indicating a set of atoms should be targeted
# for each task in a batch.
>>> batch_assignment = ...batch_assign(a = [list_1, list_2, list_3,...])
  • You can now do:
    • ...scale(coeffs).linear(start, stop, duration) : to apply a linear waveform
    • ...scale(coeffs).constant(value, duration) : to apply a constant waveform
    • ...scale(coeffs).poly([coefficients], duration) : to apply a polynomial waveform
    • ...scale(coeffs).apply(wf:bloqade.ir.Waveform): to apply a pre-defined waveform
    • ...scale(coeffs).piecewise_linear(durations, values): to apply a piecewise linear waveform
    • ...scale(coeffs).piecewise_constant(durations, values): to apply a piecewise constant waveform
    • ...scale(coeffs).fn(f(t,..)): to apply a function as a waveform
Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/field.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
def scale(self, coeffs: Union[str, List[ScalarType]]) -> "Scale":
    """
    Address all the atoms scaling each atom with an element of the list
    or define a variable name for the scale list to be assigned later by
    defining a `name` and using `assign` or `batch_assign` later.

    Next steps to build your program include choosing the waveform that
    will be summed with the spatial modulation to create a drive.

    The drive by itself, or the sum of subsequent drives (created by just
    chaining the construction of drives) will become the field
    (e.g. Detuning Field, Real-Valued Rabi Amplitude/Rabi Phase Field, etc.)

    ### Usage Example:
    ```
    >>> prog = start.add_position([(0,0),(1,4),(2,8)]).rydberg.rabi

    # assign a literal list of values to scale each atom
    >>> one_location_prog = prog.scale([0.1, 0.2, 0.3])
    # assign a variable name to be assigned later
    >>> one_location_prog = prog.scale("a")
    # "a" can be assigned in the END of the program during variable assignment
    # using a list of values, indicating the scaling for each atom
    >>> single_assignment = ...assign(a = [0.1, 0.2, 0.3])
    # a list of lists, indicating a set of atoms should be targeted
    # for each task in a batch.
    >>> batch_assignment = ...batch_assign(a = [list_1, list_2, list_3,...])

    ```

    - You can now do:
        - `...scale(coeffs).linear(start, stop, duration)` : to apply
            a linear waveform
        - `...scale(coeffs).constant(value, duration)` : to apply
            a constant waveform
        - `...scale(coeffs).poly([coefficients], duration)` : to apply
            a polynomial waveform
        - `...scale(coeffs).apply(wf:bloqade.ir.Waveform)`: to apply
            a pre-defined waveform
        - `...scale(coeffs).piecewise_linear(durations, values)`:  to
            apply a piecewise linear waveform
        - `...scale(coeffs).piecewise_constant(durations, values)`: to
            apply a piecewise constant waveform
        - `...scale(coeffs).fn(f(t,..))`: to apply a function as a waveform

    """
    from bloqade.analog.builder.spatial import Scale

    return Scale(coeffs, self)

Rabi 

Rabi(parent: Optional[Builder] = None)

Bases: Builder

This node represent rabi field of a specified level coupling (rydberg or hyperfine) type.

Examples:

- To specify rabi of rydberg coupling:

>>> node = bloqade.start.rydberg.rabi
<class 'bloqade.builder.field.Rabi'>

- To specify rabi of hyperfine coupling:

>>> node = bloqade.start.hyperfine.rabi
>>> type(node)
<class 'bloqade.builder.field.Rabi'>
Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/base.py 
10
11
12
13
14
def __init__(
    self,
    parent: Optional["Builder"] = None,
) -> None:
    self.__parent__ = parent

amplitude property 

amplitude: RabiAmplitude

Specify the real-valued Rabi Amplitude field.

Next steps to build your program focus on specifying a spatial modulation.

The spatial modulation, when coupled with a waveform, completes the specification of a "Drive". One or more drives can be summed together automatically to create a field such as the Rabi Amplitude here.

  • You can now
    • ...amplitude.uniform: Address all atoms in the field
    • ...amplitude.location(...): Scale atoms by their indices
    • ...amplitude.scale(...): Scale each atom with a value from a list or assign a variable name to be assigned later

phase property 

phase: RabiPhase

Specify the real-valued Rabi Phase field.

Next steps to build your program focus on specifying a spatial modulation.

The spatial modulation, when coupled with a waveform, completes the specification of a "Drive". One or more drives can be summed together automatically to create a field such as the Rabi Phase here.

  • You can now
    • ...amplitude.uniform: Address all atoms in the field
    • ...amplitude.location(...): Scale atoms by their indices
    • ...amplitude.scale(...): Scale each atom with a value from a list or assign a variable name to be assigned later

RabiAmplitude 

RabiAmplitude(parent: Optional[Builder] = None)

Bases: Field

This node represent amplitude of a rabi field.

Examples:

- To specify rabi amplitude of rydberg coupling:

>>> node = bloqade.start.rydberg.rabi.amplitude
>>> type(node)
<class 'bloqade.builder.field.Amplitude'>

- To specify rabi amplitude of hyperfine coupling:

>>> node = bloqade.start.hyperfine.rabi.amplitude
>>> type(node)
<class 'bloqade.builder.field.Amplitude'>
Note

This node is a SpatialModulation node. See [SpatialModulation][bloqade.builder.field.SpatialModulation] for additional options.

Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/base.py 
10
11
12
13
14
def __init__(
    self,
    parent: Optional["Builder"] = None,
) -> None:
    self.__parent__ = parent

RabiPhase 

RabiPhase(parent: Optional[Builder] = None)

Bases: Field

This node represent phase of a rabi field.

Examples:

- To specify rabi phase of rydberg coupling:

>>> node = bloqade.start.rydberg.rabi.phase
>>> type(node)
<class 'bloqade.builder.field.Phase'>

- To specify rabi phase of hyperfine coupling:

>>> node = bloqade.start.hyperfine.rabi.phase
>>> type(node)
<class 'bloqade.builder.field.Phase'>
Note

This node is a SpatialModulation node. See [SpatialModulation][bloqade.builder.field.SpatialModulation] for additional options.

Source code in .venv/lib/python3.12/site-packages/bloqade/analog/builder/base.py 
10
11
12
13
14
def __init__(
    self,
    parent: Optional["Builder"] = None,
) -> None:
    self.__parent__ = parent