Release 0.24.0

New features since last release

• Add SingleExcitation and DoubleExcitation qchem gates and generators. (#289)

• Add a new dispatch mechanism for future kernels. (#291)

• Add IsingXY gate operation. (#303)

• Support qml.state() in vjp and Hamiltonian in adjoint jacobian. (#294)

Breaking changes

• Codebase is now moving to C++20. The default compiler for Linux is now GCC10. (#295)

• Minimum macOS version is changed to 10.15 (Catalina). (#295)

Improvements

• Split matrix operations, refactor dispatch mechanisms, and add a benchmark suite. (#274)

• Add native support for the calculation of sparse Hamiltonians' expectation values. Sparse operations are offloaded to Kokkos and Kokkos-Kernels. (#283)

• Device lightning.qubit now accepts a datatype for a statevector. (#290)

dev1 = qml.device('lightning.qubit', wires=4, c_dtype=np.complex64) # for single precision
dev2 = qml.device('lightning.qubit', wires=4, c_dtype=np.complex128) # for double precision

Documentation

• Use the centralized Xanadu Sphinx Theme to style the Sphinx documentation. (#287)

Bug fixes

• Fix the issue with using available clang-format version in format. (#288)

• Fix a bug in the generator of DoubleExcitationPlus. (#298)

Contributors

This release contains contributions from (in alphabetical order):
Mikhail Andrenkov, Ali Asadi, Amintor Dusko, Lee James O'Riordan, Chae-Yeun Park, and Shuli Shu

Release 0.23.0

Release 0.23.0

New features since last release

• Add generate_samples() to lightning. (#247)

• Add Lightning GBenchmark Suite. (#249)

• Support runtime and compile information. (#253)

Improvements

• Add ENABLE_BLAS build to CI checks. (#249)

• Add more clang-tidy checks and kernel tests. (#253)

• Add C++ code coverage to CI. (#265)

• Skip over identity operations in "lightning.qubit". (#268)

Bug fixes

• Update tests to remove JacobianTape. (#260)

• Fix tests for MSVC. (#264)

• Fix #include <cpuid.h> for PPC and AArch64 in Linux. (#266)

• Remove deprecated tape execution methods. (#270)

• Update qml.probs in test_measures.py. (#280)

Contributors

This release contains contributions from (in alphabetical order):
Ali Asadi, Chae-Yeun Park, Lee James O'Riordan, and Trevor Vincent

Release 0.22.1

Bug fixes

• Ensure qml.Identity kernel is registered to C++ dispatcher. (#275)

Release 0.22.0

New features since last release

• Add Docker support. (#234)

Improvements

• Update quantum tapes serialization and Python tests. (#239)

• Clang-tidy is now enabled for both tests and examples builds under Github Actions. (#237)

• The return type of StateVectorBase data is now derived-class defined. (#237)

• Update adjointJacobian and VJP methods. (#222)

• Set GitHub workflow to upload wheels to Test PyPI. (#220)

• Finalize the new kernel implementation. (#212)

Bug fixes

• Fix for OOM errors when using adjoint with large numbers of observables. (#221)

• Add virtual destructor to C++ state-vector classes. (#200)

• Fix a bug in Python tests with operations' matrix calls. (#238)

• Refactor utility header and fix a bug in linear algebra function with CBLAS. (#228)

Contributors

This release contains contributions from (in alphabetical order):

Ali Asadi, Chae-Yeun Park, Lee James O'Riordan

Release 0.21.0

New features since last release

• Add C++ only benchmark for a given list of gates. (#199)

• Wheel-build support for Python 3.10. (#186)

• C++ support for probability, expectation value and variance calculations. (#185)

Improvements

• setup.py adds debug only when --debug is given (#208)

• Add new highly-performant C++ kernels for quantum gates. (#202)

The new kernels significantly improve the runtime performance of PennyLane-Lightning
for both differentiable and non-differentiable workflows. Here is an example workflow
using the adjoint differentiation method with a circuit of 5 strongly entangling layers:

import pennylane as qml
from pennylane import numpy as np
from pennylane.templates.layers import StronglyEntanglingLayers
from numpy.random import random
np.random.seed(42)
n_layers = 5
n_wires = 6
dev = qml.device("lightning.qubit", wires=n_wires)

@qml.qnode(dev, diff_method="adjoint")
def circuit(weights):
    StronglyEntanglingLayers(weights, wires=list(range(n_wires)))
    return [qml.expval(qml.PauliZ(i)) for i in range(n_wires)]

init_weights = np.random.random(StronglyEntanglingLayers.shape(n_layers=n_layers, n_wires=n_wires))
params = np.array(init_weights,requires_grad=True)
jac = qml.jacobian(circuit)(params)

The latest release shows improved performance on both single and multi-threaded evaluations!

• Ensure debug info is built into dynamic libraries. (#201)

Documentation

• New guidelines on adding and benchmarking C++ kernels. (#202)

Bug fixes

• Update clang-format version (#219)

• Fix failed tests on Windows. (#218)

• Fix failed tests for the non-binary wheel. (#213)

• Add virtual destructor to C++ state-vector classes. (#200)

Contributors

This release contains contributions from (in alphabetical order):

Ali Asadi, Amintor Dusko, Chae-Yeun Park, Lee James O'Riordan

Release v0.20.2

• Introduce CY kernel to Lightning to avoid issues with decomposition & adjoint. (#203)

Release 0.20.1

Bug fixes

• Fix missing header-files causing build errors in algorithms module.
  (#193)

• Fix failed tests for the non-binary wheel.
  (#191)

Release 0.20.0

What's Changed

• Add Multi-threaded DOTC, GEMV, GEMM along with BLAS Support by @maliasadi in #155
• Update PL-Lightning to support new features in PL by @maliasadi in #179
• Fix missing header for dependent packages by @mlxd in #180
• setup.py uses CMake by @chaeyeunpark in #176
• Disable AVX default for PPC and ARM by @chaeyeunpark in #182
• No init module use for the tests by @antalszava in #184
• Gate Aggregate Performance Tests; Issue #158 by @isschoch in #165
• Add VJP support to PL-Lightning by @maliasadi in #181
• Add np.complex64 support in PL-Lightning by @maliasadi in #177

New Contributors

• @Jaybsoni made their first contribution in #159
• @isschoch made their first contribution in #165

Release 0.19.0

What's Changed

• Update to development version 0.19 by @trbromley in #150
• Fix C++ compiler warnings by @maliasadi in #147
• Ensure Lightning adheres to C++17 modernization standard with clang-tidy by @mlxd in #153
• Add check-tidy to Makefile by @maliasadi in #156
• Optimise x86_64 builds with AVX friendly opts by @mlxd in #157
• Version Bump 0.19.0 by @github-actions in #163
• Fix OpenMP library issues on M1 Macs by @mlxd in #166
• Fix CI builder release issues by @mlxd in #168

New Contributors

• @github-actions made their first contribution in #163

Full Changelog: v0.18.0...v0.19.0

Release 0.18.0

New features since last release

• PennyLane-Lightning now provides a high-performance
  adjoint Jacobian method for differentiating quantum circuits.
  (#136)

  The adjoint method operates after a forward pass by iteratively applying inverse gates to scan
  backwards through the circuit. The method is already available in PennyLane's
  default.qubit device, but the version provided by lightning.qubit integrates with the C++
  backend and is more performant, as shown in the plot below:

  

  The plot compares the average runtime of lightning.qubit and default.qubit for calculating the
  Jacobian of a circuit using the adjoint method for a range of qubit numbers. The circuit
  consists of ten BasicEntanglerLayers with a PauliZ expectation value calculated on each wire,
  repeated over ten runs. We see that lightning.qubit provides a speedup of around two to eight
  times, depending on the number of qubits.

  The adjoint method can be accessed using the standard interface. Consider the following circuit:

  import pennylane as qml
  
  wires = 3
  layers = 2
  dev = qml.device("lightning.qubit", wires=wires)
  
  @qml.qnode(dev, diff_method="adjoint")
  def circuit(weights):
      qml.templates.StronglyEntanglingLayers(weights, wires=range(wires))
      return qml.expval(qml.PauliZ(0))
  
  weights = qml.init.strong_ent_layers_normal(layers, wires, seed=1967)

  The circuit can be executed and its gradient calculated using:

  >>> print(f"Circuit evaluated: {circuit(weights)}")
  Circuit evaluated: 0.9801286266677633
  >>> print(f"Circuit gradient:\n{qml.grad(circuit)(weights)}")
  Circuit gradient:
  [[[-1.11022302e-16 -1.63051504e-01 -4.14810501e-04]
  [ 1.11022302e-16 -1.50136528e-04 -1.77922957e-04]
  [ 0.00000000e+00 -3.92874550e-02  8.14523075e-05]]
  
  [[-1.14472273e-04  3.85963953e-02  0.00000000e+00]
  [-5.76791765e-05 -9.78478343e-02  0.00000000e+00]
  [-5.55111512e-17  0.00000000e+00 -1.11022302e-16]]]  

• PennyLane-Lightning now supports all of the operations and observables of default.qubit.
  (#124)

Improvements

• A new state-vector class StateVectorManaged was added, enabling memory use to be bound to
  statevector lifetime.
  (#136)

• The repository now has a well-defined component hierarchy, allowing each indepedent unit to be
  compiled and linked separately.
  (#136)

• PennyLane-Lightning can now be installed without compiling its C++ binaries and will fall back
  to using the default.qubit implementation. Skipping compilation is achieved by setting the
  SKIP_COMPILATION environment variable, e.g., Linux/MacOS: export SKIP_COMPILATION=True,
  Windows: set SKIP_COMPILATION=True. This feature is intended for building a pure-Python wheel of
  PennyLane-Lightning as a backup for platforms without a dedicated wheel.
  (#129)

• The C++-backed Python bound methods can now be directly called with wires and supplied parameters.
  (#125)

• Lightning supports arbitrary unitary and non-unitary gate-calls from Python to C++ layer.
  (#121)

Documentation

• Added preliminary architecture diagram for package.
  (#131)

• C++ API built as part of docs generation.
  (#131)

Breaking changes

• Wheels for MacOS <= 10.13 will no longer be provided due to XCode SDK C++17 support requirements.
  (#149)

Bug fixes

• An indexing error in the CRY gate is fixed. (#136)

• Column-major data in numpy is now correctly converted to row-major upon pass to the C++ layer.
  (#126)

Contributors

This release contains contributions from (in alphabetical order):

Thomas Bromley, Lee James O'Riordan