Release notes

What’s new in Qaptiva HPC 0.5.0

Release on March 2026

Qaptiva HPC Requirements

A HPC cluster with a compatible sofware stack:

  • Supported CPU architectures: Intel / AMD / ARM

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system with OpenMPI

  • Python version 3.10 to 3.14 included

Extended distributed noisy emulation

  • The distributed noisy simulator in Distributed Qaptiva now support stochastic noise simulation. The class DNoisy can now additionally accept an argument sim_method which can be set to stochastic to run the noisy simulation in stochastic mode. The default simulation mode remains deterministic. An additional argument n_sample is accepted by DNoisy when running in stochastic mode, to represent the number of trajectories to be shot for each job in stochastic mode. This new simulation method is supported on both CPU and GPU simulation. For more information on this simulation method, please refer to the DNoisy section.

  • The distributed noisy simulator in Distributed Qaptiva now supports observable measurement. The class representing a noisy simulator, DNoisy can now accept a Job that measures an Observable at the end of the emulation in its submit function. To learn how to create an Observable, please refer to the Creating observable section. This new feature is supported in both deterministic noise emulation and the newly added stochastic noise emulation.

Updated features

  • Performance improvement in CLinalg for CPU observable mode nbshots==0, accompanied by a behaviour change (by default, the expected term values are not returned individually anymore).

  • 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 overriden by the user.

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

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

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

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 properly the result 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 HPC 0.4.0

Qaptiva HPC Requirements

A HPC cluster with a compatible sofware stack:

  • Supported CPU architectures: Intel / AMD / ARM

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system with OpenMPI

  • Python version 3.9 to 3.13 included

Release 3 on October 2025

Fixes

  • Qaptiva-hpc license service missing information (server side)

  • Qaptiva-hpc license check not using config.ini file (compute side)

  • Qaptiva HPC license installation updated to use Boost 1.75.0 on RHEL 8

  • Missing files in dqlm-clinalg-hip

  • Ignore remote controlled qubit when constructing state iterator in qat.core

Release 2 on September 2025

Multi-GPU emulators

The distributed emulators in Distributed Qaptiva now supports single-node multi-GPUs emulation. The classes DNoisy and DLinAlg can now additionally accept an argument use_GPU which will perform the emulation with GPUs on the node when set. The argument nb_processes_per_node or the sbatch parameter ntasks-per-node can be used to configure the number of GPUs that will be used on the node. This new feature enables the utilization of GPU computing power within HPC clusters to conduct large-scale simulations.

Connection with 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.

A new analog emulator (single-node)

A new QPU is available for analog quantum computing: QutipQPU using the QuTiP library. It performs a time-dependent evolution of a quantum state under a Hamiltonian specified in a Schedule. The QPU supports executing various types of Hamiltonians like spin, bosonic and fermionic schedules and observables (spin and bosonic can be combined). It also includes schedules with stochastic parameters and, alternatively, a noise description of the environment in terms of Lindblad operators.

New gate-based emulators (single-node)

The tensor network QPUs MPS and MPO are now part of Qaptiva-HPC. Based on a compressed representation of the wavefunction or density matrix, they allow for efficient simulations of short-depth and low-entangling quantum circuits even for large numbers of qubits, and constitute one of the leading numerical tools for quantum computer emulation. They can be used for noiseless and noisy simulations, as well as in the Schrödinger (state evolution) and Heisenberg (observable evolution) pictures.

Updated features

  • DMPSTraj 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.

  • SAMPLE shots from CLinalg will now have a more natural ordering (non-aggregated shots will be stored in the order in which they were simulated)

What’s new in Qaptiva HPC 0.3.0

Released on March 2025

Qaptiva HPC Requirements

A HPC cluster with a compatible software stack:

  • Supported CPU architures: Intel / AMD (ARM work in progress)

  • RHEL 8 or 9, SLES 15 (or compatible OS)

  • Slurm scheduling system 23.02 (or above) with OpenMPI

  • Python version 3.9, 3.10, 3.11 or 3.12

A new distributed noisy emulator

Distributed Qaptiva now features a distributed noisy emulator, DNoisy. It builds upon the the highly optimized distributed emulator DLinAlg and offers the same benefits of of multi-core (with OpenMP parallelism) and multi-nodes architectures, but will aditionally accept a hardware model describing the noise model to be applied to the circuit. DNoisy can then perform the exact simulation of such noisy quantum circuits by storing the entire density matrix describing the qubits’ state and distributing it across multiple nodes in a cluster, overcoming the memory limitation of a mono-node architecture.

A new distributed analog simulator

As of the present release, Qaptiva HPC now features a first analog simulator, called DMPSTraj. This emulator relies on a Matrix Product State (MPS) representation to perform the computation. It supports both ideal and noisy emulations. Because the noisy emulation is embarrassingly parallel, this emulator can use multiple nodes to emulate all the trajectories, and hence simulate even more qubits.

New compilation plugins

Qaptiva HPC provides new plugins to transpile a quantum circuits. These plugins can be divided in two categories:

  • plugins designed to execute a circuit on real quantum hardware.

  • plugins designed to perform emulation of quantum hardware.

Distributed Qaptiva now provides transpilers to transform a quantum circuit into an equivalent one executable on a real quantum hardware. The transpiled circuit is not equal to the initial circuit but equivalent, meaning that result of the transpiled circuit may require classical processing to retrieve the expected result. Our transpilers are wrapped in plugins, like NISQCompiler, as plugins handle classical postprocessing automatically. Please refer to transpilation section to get more information on our transpilers tools.

Please note that are transpilers cannot transform circuits having more than 20 qubits. If you need to transpile bigger quantum circuits, please consider using a Qaptiva Appliance.

A new plugin RepairPermutation has been added in Qaptiva HPC. Its purpose is to return the qubits to their initial position at the end of a circuit that has been localized. This plugin is important for the new DNoisy emulator since it puts the state probabilities to be sampled back on the diagonal of the density matrix. It is applied by default by DNoisy after the Localizer plugin.

Updated features

  • DLinAlg updated features:

    • Now has an improved parallelism when sampling shots for nbshots > 0

    • Now does the sampling in place, so the number of qubits that can be simulated in SAMPLE mode and OBSERVABLE mode are now the same (No additional memory space needed for sampling)

    • Now supports observable mode with nbshots > 0

    • Removed qubit threshold for Localizer and FusionPlugin in the default plugins

  • CLinalg updated features:

    • Now supports string type psi_0.

    • Now supports observable mode with nbshots > 0 (no need to add ObservableSplitter anymore).

    • Observable mode with nbshots == 0 now sets value_data.

    • Now supports intermediate measurements in GPU simulation.

    • Now supports SAMPLE mode for nbshots > 0 in GPU simulation

  • FusionPlugin will now work even if the circuit contains gates that cannot be fused

Fixes

  • Fixed a segmentation fault in DLinAlg when sampling shots for nbshots > 0

  • Fixed an error in DLinAlg where SWAP gate was not working when there is only one local qubit

  • Fixed aligned_alloc/free in CLinalg on windows for diagonal gates

  • Fixed CUDA n-qbits gate in CLinalg

  • 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.

First release of Distributed Qaptiva

Version 0.1.0 released on July 2024

What is Distributed Qaptiva

Distributed Qaptiva is the distributed Quantum Appliance developed by Eviden. This appliance is meant to be deployed in a High-Performance Computing (HPC) environment with distributed resources, offering a highly optimized quantum circuit simulation with multithreading and state vector distribution. It features DLinAlg, a distributed Linear-algebra based simulator that extends the mono-node LinAlg simulator in Qaptiva to take advantage of multi-core (with OpenMP parallelism) and multi-nodes architectures. Message Passing Interface (MPI) protocol is used to handle communication between the distributed resources used to store and manipulate quantum states. This simulator offers the possibility to simulate larger circuits, as the complete representation of the state vector can be distributed across multiple nodes in a cluster, which allows us to overcome the memory limitation of a mono-node architecture.

Distributed Qaptiva Requirements

A HPC cluster with a compatible software stack:

  • Compute nodes with AVX512 support (preferably)

  • RHEL 8 or 9 Operating System (preferably RHEL 9.4)

  • Slurm scheduling system 23.02 (or above)

  • Python version 3.9, 3.10, 3.11 or 3.12

  • OpenMPI version 4.1.5 or above

  • CUDA version 11.8 on RHEL 8, 12.4 on RHEL 9

  • Intel oneAPI MKL library