Skip to content

qubosolver.solving.quantum

qubosolver.solving.quantum

Quantum solvers based on analog sampling on Pasqal devices.

Modules:

analog_quantum_sampling

Analog quantum sampling compilation.

The primary quantum solving primitive that compiles a pulse program for a target device. Callers submit the compiled program themselves via backend.run(program) to sample bitstrings from the quantum state.

Functions:

compile 

compile(register: qoolqit.Register, drive: qoolqit.Drive, device: qoolqit.Device, *, compiler_profile: CompilerProfile = CompilerProfile.MAX_ENERGY, default_sequence_duration: int | None = None) -> qoolqit.QuantumProgram

Build and compile a qoolqit.QuantumProgram for the target device.

Parameters:

  • register (qoolqit.Register) –

    Atom register defining qubit positions.

  • drive (qoolqit.Drive) –

    Pulse drive schedule encoding the quantum operations.

  • device (qoolqit.Device) –

    Target quantum device that provides hardware constraints used during compilation.

  • compiler_profile (CompilerProfile, default: CompilerProfile.MAX_ENERGY ) –

    Compilation strategy controlling how the pulse sequence is mapped to device constraints.

  • default_sequence_duration (int | None, default: None ) –

    Fallback maximum sequence duration (ns) injected when device has no native max_duration cap. None leaves the device unpatched.

Returns:

  • qoolqit.QuantumProgram –

    A compiled quantum program ready to be executed on a quantum backend (local/remote emulator, QPU).

Raises:

  • ValueError –

    If register's max/min radial distance ratio exceeds what device allows, e.g. because it was embedded without device constraints in mind.

Example 
program = compile(register, drive, device)
# Submit the program to a quantum backend
job = backend.run(program)
results = job.results()
Source code in qubosolver/solving/quantum/analog_quantum_sampling.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def compile(
    register: qoolqit.Register,
    drive: qoolqit.Drive,
    device: qoolqit.Device,
    *,
    compiler_profile: CompilerProfile = CompilerProfile.MAX_ENERGY,
    default_sequence_duration: int | None = None,
) -> qoolqit.QuantumProgram:
    """Build and compile a [`qoolqit.QuantumProgram`][] for the target device.

    Args:
        register: Atom register defining qubit positions.
        drive: Pulse drive schedule encoding the quantum operations.
        device: Target quantum device that provides hardware constraints used
            during compilation.
        compiler_profile: Compilation strategy controlling how the pulse
            sequence is mapped to device constraints.
        default_sequence_duration: Fallback maximum sequence duration (ns)
            injected when `device` has no native `max_duration` cap.
            [`None`][] leaves the device unpatched.

    Returns:
        A compiled quantum program ready to be executed on a quantum backend
            (local/remote emulator, QPU).

    Raises:
        ValueError: If `register`'s max/min radial distance ratio exceeds what
            `device` allows, e.g. because it was embedded without device
            constraints in mind.

    Example:
        ```python
        program = compile(register, drive, device)
        # Submit the program to a quantum backend
        job = backend.run(program)
        results = job.results()
        ```
    """
    max_min_distance_ratio = register.max_radial_distance() / register.min_distance()
    device_max_min_distance_ratio = _max_min_distance_ratio(device)
    if max_min_distance_ratio > device_max_min_distance_ratio:
        raise ValueError(
            f"Register max/min distance ratio ({max_min_distance_ratio:.3g}) exceeds "
            f"the device's maximum allowed ratio ({device_max_min_distance_ratio:.3g}). "
            "This usually means the register was embedded without the target device's "
            "constraints in mind. Did you pass `device` to your embedding algorithm's config?"
        )

    if device.specs["max_duration"] is None and default_sequence_duration is not None:
        device_with_duration = dataclasses.replace(
            device._device,
            max_sequence_duration=default_sequence_duration,
        )
        device = qoolqit.Device(
            pulser_device=device_with_duration, default_converter=device.converter
        )

    program = qoolqit.QuantumProgram(
        register=register,
        drive=drive,
    )
    max_duration_ratio = 0.99 if device.specs["max_duration"] is not None else None

    program.compile_to(
        device,
        profile=compiler_profile,
        device_max_duration_ratio=max_duration_ratio,
    )
    return program