Release notes

What’s new in Qaptiva 1.13

Released on March 2026

Qaptiva requires:

RHEL 9.6 for Qaptiva 800 Appliances
RHEL 9.6 or Rocky OS 9.6 for the Qaptiva Access Front-Ends

Note

This Qaptiva release comes with a new version of theCUDA Toolkit, following NVIDIA’s recommendations for fixing CVE-2025-33228 to CVE-2025-33231 vulnerabilities. More information can be found in NVIDIA’s January security bulletin.

Configuring Qaptiva Access with SLURM

A new, powerful configuration tool has been added for the Qaptiva Access scheduler, utilizing SLURM. It takes the form of a new configuration file /etc/qlmaas/sbatch.cmdmap, and enables changes in the sbatch command used for scheduling Qaptiva and offload jobs. It presents itself as a series of condition lines containing criteria between square brackets, followed by an attached format line. These condition lines are analyzed in order, when one has all its criteria evaluated as True, then the following format line is used as a template for the sbatch command. Here is a toy example showcasing the syntax:

[[qaptiva, job_count == 1]]
# this command will be used if the batch sent by the client contains exactly one job
sbatch --exclusive {qaptiva_script}

[[qaptiva]]
# this is otherwise used as a fallback
sbatch {qaptiva_script}

Many more parameters are available, including support for Python formatter hooks or arbitrary scheduling options from the client. These are documented in the Qaptiva Access admin documentation.

Services

The Qaptiva and Qaptiva Access services have been updated to run under Python 3.14.

A new Linear Algebra emulator

The LinAlg emulator has been replaced by a new version for improved performance and maintainability. It shares most of its interface and can also be found in the qat.linalg module; however, a few legacy options are ignored by this new simulator: gpu_group_size, gpu_buffer_size, group_size, feynman_factor, extract_causal_cones, density_matrix. The new emulator still uses FusionPlugin as a default. The backend implementation used until the last release can still be imported in Qaptiva as LinAlgLegacy, and it is still used as the main backend of NoisyQProc.

Updated features

In MPS and MPO, the automatic linearization of the circuit is now faster. Defaut Nnizer parameters have been changed to give fast (but suboptimal) linearization. These parameters can be overridden by the user.

A new decorator qlmaas_warning() has been introduced to add warnings to a Qaptiva Access service. When this QPU is imported through Qaptiva Access; a warning will be displayed in the user environment.

A function get_job_id() has been introduced to retrieve the Qaptiva Access job ID. This function is designed to be used when implementing a QPU exposed through Qaptiva Access.

The script qlmaas_manage.py can be used to define warning messages from the command line. These warning messages are displayed on both the homepage of Qaptiva Access and the user environment (when a user logs to Qaptiva Access). Please refer to the admin documentation for more information.

Function get_substate() was not documented. This function should be used when implementing a QPU using Qaptiva 800s.

MPSTraj now features high-order time evolution methods (WI and WII). See parameter evol_method.

The delete_old command of qlmaas_manage.py now has a new --not-quiet option.

Plugin NISQCompiler now supports “QUOBLY” as a preset gate set, tailored to Quobly’s silicon-based spin qubit architecture.

Workon utility has been redesigned; source workon is not supported anymore, use workon.

Bug fixes

Lifting a Schedule into a Job (i.e., using qat.core.Schedule.to_job()) with no option passed had an undefined behavior. This function has been updated to have the same behavior as lifting a Circuit into a Job (sampling mode, all qubits are measured).

Plugin Remap was not able to compile empty circuits. This problem is now fixed.

Plugin NISQCompiler was not able to format the result properly when the number of qubits available in the circuit was not matching the number of qubits in the topology.

The tool designed to check the license server did not inherit from the Qaptiva HPC global configuration. This is now fixed.

What’s new in Qaptiva 1.12

Released on September 2025

Qaptiva requires:

RHEL 9.6 for Qaptiva 800 Appliances*
RHEL 9.6 or Rocky OS 9.6 for the Qaptiva Access Front-Ends.

Sparse Pauli Dynamics

This release introduces a new module qat-spd, dedicated to Pauli propagation methods. It provides two new QPUs based on sparse Pauli dynamics:

SPD for noiseless simulations,

NoisySPD for noisy simulations.

Both QPUs are approximate QPUs that evaluate the expectation value of observables by backpropagating them through the circuit in the Heisenberg picture. The observable is expressed in the Pauli basis, and several truncation methods are available to keep this representation sparse:

Truncation based on minimal threshold for coefficients of Pauli strings (recommended for near-Clifford circuits)

from qat.qpus import SPD

spd_qpu = SPD(threshold=1e-5, max_size=1e6, nprocs=16)

Truncation based on maximum weight of Pauli strings (recommended for unstructured circuits)

from qat.qpus import SPD

spd_qpu = SPD(max_weight=10, max_size=1e6, nprocs=16, extract_clifford=False)

Truncation based on maximum X-weight of Pauli strings (recommended for simulating encoded fermions)

from qat.qpus import SPD

spd_qpu = SPD(max_x_weight=10, max_size=1e6, nprocs=16, extract_clifford=False)

To make sure that the computation does not grow beyond what the computer can handle, it is possible to set a maximum size for the list of Paulis, truncating some Paulis when this limit is exceeded, starting with the ones with the lowest coefficients (in absolute value). This extra truncation offers no guarantee in terms of accuracy, but gives more control on the computation time.

Nginx WebSocket support

The new version of Qaptiva relies on WebSockets over Nginx for some of its most critical tasks. As such, it is essential that any external reverse proxy service used is configured to support the WebSocket protocol. In particular, the HTTP Upgrade and Connection headers must be correctly passed through.

Offload mode for Qaptiva Access

It is now possible for a Qaptiva Access server to offload jobs to an HPC cluster. This feature requires a Qaptiva Appliance.

Only Qaptiva HPC simulators can be offloaded in such a way. This includes CLinalg, DLinAlg and others.

If this is the prefered mode of execution, please consider settings default_node_type=COMMODITY in the configuration file qlmaas.ini.

Moreover Qaptiva HPC must be installed on the HPC cluster nodes wished to be used for offload. These nodes must also be tagged with the feature corresponding to qaptiva_hpc_constraint in the slurm_commands.ini config file. By default this means having a QAPTIVAHPC feature.

Submitting jobs with Qiskit

In this new version, qaptiva comes with a qiskit wrapper qat.qiskit that allows a user to use Qaptiva QPUs and algorithms in a qiskit environment. With qat.qiskit it is possible to use qaptiva QPU and algorithms as a backend to qiskit objects. One of the central features is that it is now possible to pass a qiskit circuit directly to a QaptivaService, it translates the circuit and performs all necessary computations before returning the result as a qiskit object. The user doesn’t have to do anything manually in that respect. It is possible to perform either a sampling with Sampler or an estimation with Estimator. Both the sampler and the estimator work with a qaptiva backend with a large choice of QPUs available.

Updated features

MPSTraj now supports describing initial states with the '+' and '-' symbols, corresponding to the two eigenstates of the X operator, in addition to '0' and '1'. In addition, an initial state can also be provided as a Numpy vector, allowing arbitrary initial state description for small number of qubits.

MPS and MPO now include the use of PyTorch, which allows for GPU acceleration by setting use_GPU =True when calling the QPU.

MPS and MPO now offer to disable the plugin Nnizer by setting nnize =False when calling the QPU. This allows to bypass the compilation process when the input quantum circuit already statisfies a linear connectivity.

MPS now supports describing an initial state as a string with symbols '0', '1', '+', '-', corresponding to the two eigenstates of the Z and X operators. In addition, an initial state can also be provided as a Numpy vector, allowing arbitrary initial state description for small number of qubits.

Jupyterhub integration

The Jupyterhub web interface is now available as a standalone web application and from the Qaptiva Access web portal (ngnix).

Certificate revocation

The certificate revocation list (CRL) is now supported for Qaptiva Access.

Fixes

The resource usage estimation of a job based on AnalogQPU was incorrect. Then, a job submitted using Qaptiva Access could likely fail (use more resource than allocated). This error is now fixed [BRQ-1816]

The maximum size of a job submitted to Qaptiva Access has been changed from 5 MB to 8 MB. The error code 413: Request Entity Too Large is less likely to appear. The NGINX configuration file can still be updated to change this maximum size [BRQ-1815]

What’s new in Qaptiva 1.11.2

Released on February 2025

Qaptiva requires:

RHEL 9.5 … for Qaptiva 800 Appliances
RHEL 9.5 … or Rocky OS 9.5 … for the Qaptiva Access Front-Ends.

Note

This Qaptiva release continues to utilize the Virtual Environments feature introduced in Qaptiva 1.10. Please refer to the previous release notes for more details.

Heisenberg simulation

Using the feature heisenberg_picture=True, the QPU MPO uses a tensor network contraction method tailored for computing expectation values. Unlike the conventional Schrödinger picture, where the initial state is evolved forward in time by applying gates directly to the state, here the process is reversed: the observable is evolved backward in time through the circuit and then projected onto the initial state. This contraction approach can be beneficial for simulating quantum circuits with a larger number of qubits, especially when the qubit topology is not restricted to one dimension, when circuits are close to Clifford circuits, or when circuit depths permit light-cone structures. This enables us, for instance, to replicate the 127-qubit Kicked Ising experiment from [IBM2023] by utilizing the Heisenberg picture with the MPO QPU, which were beyond the capabilities of standard MPS simulations, as shown here:

_images/mpo_qpu_example.png — The MPO QPU reproduces expectation values obtained from the 127 qubit experiment.

[IBM2023]

Kim, Y., Eddins, A., Anand, S. et al. Evidence for the utility of quantum computing before fault tolerance. Nature 618, 500–505 (2023).

Qaptiva Access and virtual environment

To run a job on the appliance, Qaptiva Access creates a sub-process and activates a virtual environment to make the Qaptiva libraries accessible inside the sub-process. In the previous version of Qaptiva, the virtual environment was always based on Python 3.12.

Now, myQLM (since version 1.11) shares with the server the version of Python used on the client side. Then, Qaptiva Access will try to use a virtual environment, on the appliance, having the same version of Python as the client. This new behavior provides more flexibility while reducing the risk of serialization errors due to incompatibilities between different versions of Python (version of Python used on server side vs client side).

Note

If the client is using myQLM 1.10 or no matching virtual environment is found on the server side, Python 3.12 will be used. In the future, the fallback virtual environment will rely on the latest Python version available on the appliance.

Updated features

Improvements have been brought to MPS and MPO:

adding truncation threshold mode: in addition to truncating singular values above a given rank (current bond_dimension parameter), the MPS/MPO QPUs now support truncating singular values below a given value (to remove very small singular values). Both can be combined. Note that the MPO QPU in the Heisenberg mode automatically uses a truncation threshold by default.

Support non-1D circuits by automatic nnization: MPS/MPO codes can now support circuits with any topology. Qaptiva’s Nnizer compiler will compile the ingoing circuit to linear topology. This works also in noisy simulation mode (where the circuit that is being simulated is the original one, the compilation to linear topology is only used to make it compatible with MPS/MPO algorithms)

Application of SWAP gate has been optimized and is now faster in MPS/MPO QPUs.

The seed to random number generators used in sampling mode can now be set within MPS/MPO QPUs.

Fixes

In MPSTraj, a bug where monitor times are given out of the simulation time range has been fixed.

KPTree was generating wrong state prepartions if the state to prepare has a negative amplitude. The state preparation routine KPTree can now generate state preparations having negative real numbers.

CliffordNormalizer was not able to recognizes S-dagger gates and Pauli rotations of angle pi as Clifford gates. These gates are now correctly identified as Clifford gates and are compiled in the final Clifford operator.

Qaptiva Access creates cgroups, on the Appliance, to ensure that a job do not consume more resources than allowed. Additional restrictions have been added (e.g., use of unshare) to prevent a user to exit his cgroup.

In the previous release, Qaptiva Access could lose connection with the PostgreSQL database and was not able to reconnect. This problem is now fixed.

General bug fixes and improvements.

What’s new in Qaptiva 1.10.2

Released on July 2024

Qaptiva requires:

RHEL 9.4 for the Qaptiva 800 Appliances

RHEL 9.4 or Rocky OS 9.4 for the Qaptiva Access Front-Ends.

Since Qaptiva version 1.10, Qaptiva software is delivered to support multiple versions of Python (3.9, 3.10, 3.11, 3.12). Users can choose which Python version they want to use. To do so, the use of virtual environment is highly recommended to ensure the software functions properly.

Virtual environment in Qaptiva v1.10

The “workon” command is useful for creating and managing these environments, providing isolation and manageability of project dependencies. For detailed instructions, please refer to the workon section of the documentation.

Virtual environment in Jupyter

Qaptiva delivers Qaptiva-ready kernels (ipkernels) for the supported Python versions (3.9, 3.10, 3.11, 3.12). When choosing the kernel to use, a corresponding virtual environment is automatically created and activated.

A new QPU is available for analog quantum computing: MPSTraj. This is a Matrix Product State (MPS) based method, implementing Time-Evolution Block Decimation (TEBD) to compute the time evolution of qubits under a time-dependent schedule. It also allows to emulate the effect of noise through jump operators with several variants of the trajectory algorithm. This QPU is able to go beyond AnalogQPU or QutipQPU in terms of number of qubits, as it is limited by the entanglement entropy only.

The qat.opt module has been enhanced to address combinatorial problems on Rydberg atom quantum devices. These devices are quantum processors that can execute jobs matching the following schedule:

\[H = \sum_v \frac{\Omega_v}{2}\sigma_v^x - \sum_v \Delta_v n_v + \sum_{v, w}U_{vw}n_v n_w\]

where \(\Omega_v\) is the rabi frequency, \(\Delta_v\) the detuning and \(U_{vw}\) the elements of the coupling matrix between atoms.

Qaptiva 800s provides:

A generic method to embed Maximum Weighted Independent Set (MWIS) problems into the Rydberg atom platform (see MWIS)

A generic method to embed Quadratic Unconstrained Binary Optimization (QUBO) problems into the Rydberg atom platform (see QUBO)

import networkx as nx
from qat.opt import MaxCut

# This graph is not unit disc so it can not be embedded
# directly in a rydber atom device
graph = nx.circular_ladder_graph(5)

# Generate Rydberg Schedule
pbm = MaxCut(graph)
schedule = pbm.to_job(job_type="ryd")

Changing the scheduler does not change anything from a user point of view.

A new Qaptiva Access scheduler can now easily be configured (see the admin documentation). This scheduler uses Slurm for managing Qaptiva resources through Generic RESources. Configured in this way, Qaptiva Access jobs are logged both in Slurm’s and Qaptiva Access’ databases. Jobs ran through this scheduler are still managed by the Qaptiva Resource Manager once executed on the Qaptiva machine.

Such Qaptiva Access server can either be introduced in an already existing Slurm cluster, or setup in a new one.

Plugins SPQEPlugin and PQEOptimizationPlugin implement the projective quantum eigensolver method, an improvement over the variational quantum eigensolver (VQE) method that converges better and is more robust to noise. Qaptiva provides an adaptive (SPQEPlugin) as well as fixed-ansatz implementation (PQEOptimizationPlugin).

LinAlg uses FusionPlugin to optimize circuits before a CPU emulation of at least 20 qubits, leading to better performances. This plugin is also used for GPU emulation of at least 23 qubits. This can be disabled by using the parameter fusion=False.

NoisyQProc now raises an exception when trying to emulate a circuit containing intermediate measurements if nbshots=0.

FusionPlugin now ignores non-compatible circuits, instead of raising an exception.

FusionPlugin is now compatible with non-inlined circuits (but will inline them).

FusionPlugin has a new option qbits_compilation_threshold to specify a minimal number for compilation. Jobs having less qubits are not compiled.

CliffordNormalizer now retrieves the stabilizer tableau used in post processing from the batch’s meta_data instead of storing it in attribute.

Job has a new optional attribute meta_data of type dict[str, str].

HardwareSpecs has a new optional attribute meta_data of type dict[str, str].

In QutipQPU and AnalogQPU, rename argument nsteps to n_steps for harmonization between QPUs.

In MPS and MPO, the truncation method DMT has been removed.

Jump operators were mistranslated into Qutip when emulating a noisy schedule with QutipQPU. This issue is fixed [BRQ-1639].

NISQCompiler can now compile batches composed of multiple jobs [BRQ-1569].

The option optimize_initial of CliffordNormalizer has been fixed [BRQ-1594].

The order of the Clifford gates added to the stabilizer tableau when merging a Pauli Y rotation was inverted in CliffordNormalizer. This has now been fixed [BRQ-1619].

Nnizer can now compile a job for a hardware having a ALL_TO_ALL topology with unspecified number of qubits [BRQ-1563].

LinAlg and Feynman can aggregate results having intermediate measurements.

NoisyQProc was raising an exception when a circuit with intermediate measurements is submitted, even when a number of shots is given. This is now fixed [BRQ-1505].

Improved resource estimation for MPS and MPO [BRQ-1642].

Diagonalization backends 0 and 2 of codiagonalize_with_architecture have been fixed [BRQ-1655].

QutipQPU and AnalogQPU can measure qubits in any order, in respect to the attribute qubits of Job.

An exception was raised when submitting a Batch having no meta_data to a QPU. This is now fixed [BRQ-1654].

The “eager” merge strategy of FusionPlugin has been fixed (if the gate qubits count is higher thant the qubits fusion limit).

In MPS and MPO, the DMRG method is now properly relying on initial guess based on SVD.

The algorithm to produce samples in MPS and MPO has been changed to the method of ArXiv:2401.10330, fixing some inconsistencies.

Result objects can store states composed of a larger number of qubits. Downloading a result via Qaptiva Access will no longer raise the exception Internal Error: "int too big to convert" [BRQ-1571].

Various fixes and improvements for NoisyQProc.

What’s new in Qaptiva 1.9.1

Released on July 2023

Qaptiva 800s requires:

RHEL 9.2 for the QLM Appliances

RHEL 9.2 or Rocky OS 9.2 on the QLMaaS proxy systems.

The Quantum Learning Machine (QLM) has been renamed Qaptiva 800s. Any code written on the QLM should remain valid on Qaptiva 800s. The renaming also comes with:

improvement of the qat library

refactoring of the documentation

bug fixes

The documentation has been restructured to better highlight the main features of the Qaptiva Appliance. This new documentation is designed to better explain the architecture of this software and better highlights tools available in this software

Quantum circuits and quantum jobs can be defined using the Python function (using qfunc() and qrout() decorators). This new syntax can be used to define variational algorithm. For instance:

from qat.lang import qrout, RX, H, CNOT

@qrout
def circuit(theta):
    " Dummy example "
    RX(theta)(0)
    H(1)
    CNOT(1, 0)

circuit.display(batchmode=True)

 ┌─────────┐┌─┐
─┤RX[theta]├┤X├
 └─────────┘└┬┘
             │ 
 ┌─┐         │ 
─┤H├─────────●─
 └─┘           
               

Quantum jobs have new methods run() (to execute a job on a QPU - if no QPU is specified, get_default_qpu() is used) and compile() (to compile a job). QPUs and Plugins are selected using the scope syntax of Python:

with ScipyMinimizePlugin(...):
    my_job.run()  # Execute "my_job" on "ScipyMinimizePlugin(...) | get_default_qpu()"

with NISQCompiler(...):
    my_job.compile(specs)  # Compile "my_job" using "NISQCompile"

This feature is detailed in the ticket [BRQ-1487]

Qaptiva 800s provides two new QPUs:

MPS for noiseless simulations, which replaces the old MPS QPU (renamed to MPSLegacy),

MPO for noisy simulations.

Each of them features the standard maximum bond dimension truncation scheme, as well as a new adaptative truncation method, which adapts bond dimensions based on a fidelity lower-bound given as input. The final quantum state fidelity will be close to or higher than given input fidelity.

Fixed maximum bond dimension

from qat.qpus import MPS, MPO

noiseless_qpu = MPS(bond_dimension=64)
noisy_qpu = MPO(hardware_model=..., bond_dimension=64)

Adaptative bond dimension

from qat.qpus import MPS, MPO

noiseless_qpu = MPS(fidelity=0.99)
noisy_qpu = MPO(hardware_model=..., fidelity=0.99)

This feature is detailed in the ticket [BRQ-1486]

Observable has been internally redesigned to store Term is a more efficient way. Manipulating an Observable and performing Observables arithmetic is much faster than before. The API remains unchanged.

The static constructors for Pauli operators in the Observable class have been slightly changed to automatically infer the total number of qubits

Observable and Term can be caster into a matrix by using the new method to_matrix(), in a dense or sparse form. This feature is detailed in the ticket [BRQ-1482]

Enabling computating the density matrix from a simulation (also with jump ops) for AnalogQPU with GPU

Noisy simulations and noisy circuits handling have been optimized

Add a new option to the constructor to check if the quantum channel is trace preserving or trace decreasing at construction. This check relies on a brand new function is_trace_reducing to check whether a quantum channel (in the Kraus form) reduces the trace of density matrices

Method generate() of AbstractGenerator can now return a tuple (job, meta_data), instead of returning a batch having meta-data

Result object now has a display() method to get a more convenient HTML view of the object. This feature is detailed in the ticket [BRQ-1485]

Batch generators of combinatorial optimization problems will now automatically set the best parameters of the SQAQPU when an annealing job is generated. This feature is detailed in the ticket [BRQ-1460]

The subprocess manager of PowerAccess has been re-designed, to improve the latency of a request. This feature is detailed in the ticket [BRQ-1468]

Added RemoteQPU in qat.qpus module [BRQ-1490]

Added RemotePlugin in qat.plugins module [BRQ-1492]

Fix an error in the evaluation of the gradient in AdaptVQEPlugin.

Parameters containing symengine number types such as Rational or Half are now correctly translated to ArithExpression (issue #6).

Fix the resource estimation for AnalogQPU with deterministic jobs.

CLASSICCTRL and RESET are now supported by LinAlg on GPU. Circuits composed of this kind of gate are now executable on this QPU.

Fixed a bug where the intermediate measurements will always be 0 starting from the second shot in GPU simulation [BRQ - 1504].

Fixed LinAlg GPU sampling where same samples are returned at independent execution [BRQ - 1488].

Update the documentation of ParametricPureDephasing to display the right Kraus operators.

Change definition of heaviside to exclude end point.

Fixed an issue in a QLMaaS script that deletes older jobs and results. This issue is detailled in [BRQ-1450].

Fixed bugged quantum channels (generalized amplitude damping and PureDephasingQuasiprobs). This issue is detailled in [BRQ-1494].

Fixed inconsistent results in LinAlg QPU with intermediate measurements and nbshots > 1. Disallow nbshots=0 for it cannot be computed easily with intermediate measurements [BRQ - 1502].

User defined applications located under module qat are not importable remotely (even from module qlmaas).

User defined applications should be moved under another module and imported using get_importable().

Even so cirq is provided, it is not fully operational and therefore not supported by default in the Appliance. cirq can be installed using –user if needed.