Heuristic Drive
Heuristic Drive Shaper
Section titled “Heuristic Drive Shaper”HeuristicDriveShaper constructs a fixed, closed-form analog drive directly from
the diagonal of the QUBO matrix, without running any classical pulse
optimization loop.
Compared with OptimizedDriveShaper, it is lighter and faster:
it builds the drive analytically from the problem structure and the hardware
limits. It is especially useful when the diagonal coefficients carry meaningful
site-dependent bias information.
The shaper returns:
- a generated
Drive, ready to be simulated by the solver; - an empty
QUBOSolutionplaceholder. The actual bitstrings, probabilities, and costs are produced later, when the quantum simulation is executed.
Principle
Section titled “Principle”The shaper first normalizes the QUBO matrix: Qeff=∥Q∥Q and extracts its diagonal: qi=(Qeff)ii.
It then defines target final local detunings from these diagonal terms: di=−αqi, where α>0 is chosen automatically so that the resulting schedule remains compatible with the hardware bounds.
Intuitively, the diagonal coefficients act as local biases, and the shaper translates them into a final detuning landscape.
Final Detuning Encoding
Section titled “Final Detuning Encoding”With DMM enabled
Section titled “With DMM enabled”When a Detuning Map Modulator (DMM) is available, the shaper encodes the final local targets exactly in the intended operating regime.
Let dmin=imindi,dmax=imaxdi.
The final detuning is decomposed into:
- a global detuning δg(T)=dmax,
- a DMM detuning amplitude δdmm(T)=−(dmax−dmin)≤0,
- and site-dependent weights wi=dmax−dmindmax−di∈[0,1].
This gives the final local detuning δi(T)=δg(T)+δdmm(T)wi=di.
This sign convention is important: in this stack, WeightedDetuning waveforms
must be non-positive, so the DMM contribution is encoded as a negative quantity.
If the DMM spread is negligible, or if no effective DMM range is available, the DMM contribution is omitted.
Without DMM
Section titled “Without DMM”If dmm=False, only a global detuning can be applied. In that case the shaper
cannot realize each di individually, so it uses a single global final
value:
δg(T)=meani(di),
and no weighted detunings are declared.
How α is chosen
Section titled “How α\alphaα is chosen”The shaper computes a conservative upper bound αmax from the active hardware constraints, then applies a safety factor.
Let qmin=iminqi,qmax=imaxqi,qabs=imax∣qi∣.
The effective encoding must satisfy:
- the global detuning bound,
- the DMM detuning bound (when DMM is used),
- the Rabi amplitude bound, since the amplitude scale is derived from the detuning scale.
The implementation therefore uses: αmax=min(qabsδg,max,qmax−qminδdmm,max,κqabsΩhw,max), where only meaningful terms are included:
- the DMM term is used only when DMM is enabled and qmax>qmin,
- the amplitude term is used only when κ>0,
- degenerate zero-denominator cases are ignored safely.
The final value is then: α=heuristic_alpha_safety×αmax.
In the current implementation, the fallback default is:
heuristic_alpha_safety = 0.6
If no valid upper bound can be formed, the code falls back to a very small positive value for α.
How Ωmax is chosen
Section titled “How Ωmax\Omega_{\max}Ωmax is chosen”The plateau amplitude is derived from the detuning energy scale: Ωmax(raw)=κimax∣di∣.
This value is then clamped to the hardware amplitude constraints of the global Rydberg channel. In particular, the implementation:
- enforces the channel lower bound through
min_avg_amp, - keeps a small safety margin below the hard upper limit (
0.99 * max_amp).
The current fallback default is:
heuristic_kappa = 0.25
Schedule Shape
Section titled “Schedule Shape”The shaper uses the full sequence duration allowed by the device and constructs simple interpolated waveforms.
Amplitude
Section titled “Amplitude”The amplitude follows a flat-top profile: Ω(t)=[ε, Ωmax, Ωmax, ε] with a very small ε>0 at the endpoints rather than a strict zero.
Global detuning
Section titled “Global detuning”The global detuning starts from the most negative hardware-allowed value and then ramps to the final encoded value: δg(t)=[δ0, δ0, δg(T), δg(T)],δ0=−∣δmax∣.
This creates a simple three-stage pattern:
- initial negative detuning,
- drive-on plateau,
- sweep toward the encoded final bias.
DMM weighted detuning
Section titled “DMM weighted detuning”When DMM is active and the final DMM amplitude is strictly negative, the shaper
declares a weighted detuning map through weighted_detunings(...), using the
weights wi and final detuning δdmm(T).
Hardware Bounds Used
Section titled “Hardware Bounds Used”The shaper reads the following hardware limits from the device:
- global detuning bound from the global Rydberg channel
(
max_abs_detuning); - global amplitude bound from the same channel (
max_amp); - minimum average amplitude from
min_avg_amp; - DMM bound from the DMM channel
bottom_detuningwhen available.
If no explicit DMM bound is found, the code falls back to the global detuning bound.
Configuration Parameters
Section titled “Configuration Parameters”| Field | Type | Description |
|---|---|---|
drive_shaping_method |
DriveType \| str |
Must be set to DriveType.HEURISTIC or "heuristic" |
dmm |
bool |
Enables site-dependent final detuning through weighted DMM detunings |
heuristic_alpha_safety |
float |
Safety factor applied to αmax; current fallback default: 0.6 |
heuristic_kappa |
float |
Proportionality factor used to derive Ωmax from the detuning scale; current fallback default: 0.25 |
These parameters are provided through DriveShapingConfig and read at drive
generation time.
Notes and Limitations
Section titled “Notes and Limitations”- The method uses only the diagonal of the normalized QUBO matrix. Off-diagonal couplings are not used directly to shape the schedule.
- With DMM enabled, the final local targets are encoded analytically through the global detuning plus a weighted negative DMM correction.
- Without DMM, the method can only apply a single global final detuning, so the site-dependent targets are approximated by their mean.
- Final values are still clipped to hardware-compatible ranges when needed.
Example
Section titled “Example”import torchfrom qubosolver import QUBOInstancefrom qubosolver.config import SolverConfig, DriveShapingConfigfrom qubosolver.solver import QuboSolverfrom qubosolver.qubo_types import DriveType
Q = torch.tensor([ [-1.0, 0.5, 0.2], [0.5, -2.0, 0.3], [0.2, 0.3, -3.0],])
instance = QUBOInstance(Q)
config = SolverConfig( use_quantum=True, drive_shaping=DriveShapingConfig( drive_shaping_method=DriveType.HEURISTIC, dmm=True, heuristic_alpha_safety=0.6, heuristic_kappa=0.25, ),)
solver = QuboSolver(instance, config)solution = solver.solve()
print(solution)