Skip to content

Local-Energy-Scale Drive

Local-Energy-Scale Drive Shaper

LocalEnergyScaleDriveShaper generates a fixed analog drive from:

  • the diagonal of the QUBO matrix;
  • the interactions returned by the embedded register;
  • a scaling parameter \(\kappa\).

It does not run a pulse-parameter optimization loop.

The shaper returns the generated Drive and an empty Solution. Samples and QUBO costs are produced when the drive is executed.

Target Detunings

For a QUBO matrix \(Q\), the target detuning associated with variable \(i\) is

\[ d_i = -\frac{Q_{ii}}{2}. \]

These values are taken directly from the matrix received by the drive shaper.

DMM Encoding

The DMM is used only when:

  • dmm=True;
  • the selected device exposes a DMM detuning range;
  • the target detunings are not all equal.

Let

\[ d_{\min}=\min_i d_i, \qquad d_{\max}=\max_i d_i, \qquad \Delta d=d_{\max}-d_{\min}. \]

When \(\Delta d>10^{-15}\), the code sets

\[ \delta_g(T)=d_{\max}, \]
\[ \delta_{\mathrm{dmm}}(T)=-\Delta d, \]

and

\[ w_i= \frac{d_{\max}-d_i}{\Delta d}. \]

The weights are clipped to \([0,1]\). The resulting local final detuning is

\[ \delta_i(T) = \delta_g(T) + \delta_{\mathrm{dmm}}(T)w_i. \]

With the unscaled target detunings, this gives

\[ \delta_i(T)=d_i. \]

If DMM is not used, the code applies one global final detuning:

\[ \delta_g(T) = \frac{1}{N} \sum_{i=1}^{N}d_i. \]

In that case,

\[ \delta_i(T)=\delta_g(T) \]

for every qubit.

Local Energy Scale

Let \(V_{ij}\) denote the interaction value returned by

register.interactions()

for qubits \(i\) and \(j\).

For each qubit, the code accumulates

\[ I_i = \sum_{j\neq i}|V_{ij}|. \]

The local energy scale is

\[ E_i = |\delta_i(T)| + I_i. \]

The mean local energy scale is

\[ \overline{E} = \frac{1}{N} \sum_{i=1}^{N}E_i. \]

The raw peak Rabi frequency is

\[ \Omega_{\max}^{\mathrm{raw}} = \kappa\overline{E}. \]

The default value is

local_energy_scale_kappa = 0.25

Hardware Adjustments

Amplitude

The code obtains the maximum compilable amplitude for the selected device and register through max_virtual_amplitude(...).

If

\[ \Omega_{\max}^{\mathrm{raw}} > \Omega_{\max}^{\mathrm{device}}, \]

the amplitude is clamped:

\[ \Omega_{\max} = \Omega_{\max}^{\mathrm{device}}. \]

Otherwise,

\[ \Omega_{\max} = \Omega_{\max}^{\mathrm{raw}}. \]

A warning is emitted when clamping occurs.

Detunings

The code defines the allowed detuning magnitude as

\[ d_{\mathrm{allowed}} = \rho\,\Omega_{\max}(1-10^{-3}), \]

where \(\rho\) is returned by detuning_amplitude_ratio(device).

If

\[ \max_i |d_i| > d_{\mathrm{allowed}}, \]

all target detunings are multiplied by

\[ \frac{d_{\mathrm{allowed}}} {\max_i |d_i|}. \]

The global detuning and DMM encoding are then recomputed from the scaled target detunings.

The local energy scale and \(\Omega_{\max}\) are not recomputed after this detuning rescaling.

Waveforms

The sequence duration is

device.specs["max_duration"] or 1000.0

The amplitude waveform is

\[ \left[ \varepsilon, \Omega_{\max}, \Omega_{\max}, \varepsilon \right], \qquad \varepsilon=10^{-9}. \]

The initial detuning is

\[ \delta_0 = -\max_i |d_i|, \]

using the possibly rescaled target detunings.

The global detuning waveform is

\[ \left[ \delta_0, \delta_0, \delta_g(T), \delta_g(T) \right]. \]

Both waveforms are created with qoolqit.InterpolatedWaveform.

When DMM is active, the weighted detuning waveform is created with constant_weighted_dmm(...).

Configuration

Field Type Description
drive_shaping_method DriveType \| str DriveType.LOCAL_ENERGY_SCALE or "local_energy_scale"
dmm bool Requests DMM encoding when supported by the device
local_energy_scale_kappa float Multiplies the mean local energy scale; default: 0.25

Example

from qubosolver import (
    DriveShapingConfig,
    DriveType,
    Instance,
    Solver,
    SolverConfig,
    matrix,
)

qubo = matrix.tensor(
    [
        [-6.0, 2.0, 2.0, 2.0],
        [2.0, -7.5, 2.0, 2.0],
        [2.0, 2.0, -7.5, 2.0],
        [2.0, 2.0, 2.0, -7.0],
    ]
)

instance = Instance(matrix=qubo)

config = SolverConfig(
    use_quantum=True,
    drive_shaping=DriveShapingConfig(
        drive_shaping_method=DriveType.LOCAL_ENERGY_SCALE,
        dmm=True,
        local_energy_scale_kappa=0.25,
    ),
)

solver = Solver(instance, config)
solution = solver.solve()

print(solution)