v7 API update

Major release v7.0.0 takes lessons learned from the PyQrack API and basically inducts them back into the underlying C++11 library. The public API now follows a general "POCO" principle, letting primitive parameters be simply primitives, while all array pointers that are treated as const are explicitly const. Large but infrequently used method groups of the API can be switched on or off for inclusion in builds with the CMake options ENABLE_ALU, ENABLE_REG_GATES, ENABLE_ROT_API, and (pre-existing) ENABLE_BCD, where ENABLE_ALU for the "arithmetic logic unit" methods is the only option of these left on by default.

Primary generic gate method names have been shortened, to Mtrx for general 2x2 matrix gates, Phase for general 2-component phase gates, and Invert for general 2-component "inversion" (or "Pauli-X-like") gates. Controlled variants are MCMtrx, MCPhase, and MCInvert, (for "multiply-controlled,") and "anti-controlled" variants are MACMtrx, MACPhase, and MACInvert, (which activate the gate "payload" if all control qubits are reset off, as opposed to set on).

This overhaul of the API in itself makes for signficantly smaller binaries and appreciable speed increases, potentially due to better cache utilization, though, of course, many other small, targeted optimizations of specific methods add to this overall performance improvement, like overhauled measurement distribution sampling with MultiShotMeasureMask.

(Happy 2022! You rock!)

Final stable release before v7 API refactor

This release marks the final stable state of the Qrack v6 API, before merging v7 to main branch. It can be considered an "LTS" release in the sense that, if something is found to be broken in it, and you request a patch to the v6 API, rather than migrating to v7, then the Qrack developers intend to issue a patch upon your request.

Mirror circuit test suite and debugging

Upon suggestion from the Unitary Fund team, Qrack has been debugged against the newly developed [mirror] suite of "mirror circuit" (or "Loschmidt echo") integration tests, at all levels of the layer stack. For scope, about 20+ separate logical bugs were fixed. Random mirror circuits were generated to the exhaustion of detecable bugs, mostly at the 6 qubit width by 6-plus-inverse qubit depth level, but also ultimately for 27 qubits width by 6-plus-inverse depth.

In the process of refactoring and debugging, QStabilizerHybrid has also been extended with single-qubit matrix product state buffers that are commuted around control qubits, which are now effectively "trimmed" like with the Schmidt decomposition techniques of QUnit, to significantly increase the breadth of circuits which can be handled as Gottesman-Knill sub-states of QUnit.

QPager and approximation techniques

The QPager type from earlier development was revived and better integrated to give major performance boosts and typically 2 additional qubits of GPU maximum width, for common 4 segment GPU RAM architectures! It has been integrated as part of the default layer stack, and it does not require multi-device OpenCL environments to enjoy a performance boost.

We also have begun to expand into approximate simulation techniques, besides the major improvements in exact techniques. TrySeparate() has finally demonstrated returns under the right conditions, as it permutes through X/Y/Z single qubit and Bell pair bases as a "reactive" separability method, (as opposed to the "proactive" methods QUnit has always prioritized). Rounding tolerance can be set via constructor argument or universally overridden with the QRACK_QUNIT_SEPARABILITY_THRESHOLD environment variable.

16-bit floating point accuracy is now supported for both CPU and GPU, (when available for the OpenCL device and environment,) and FP16 build has been added to CI.

QStabilizerHybrid

Major changes in this release include a “hybridized” Gottesman-Knill stabilizer simulation type, adapted from the basis of Aaronson’s CHP, suitable for general purpose use under QUnit. When operations outside of Clifford set gates are invoked, this QInterface type transparently converts (base simulation unit or selective QUnit sub-units) to “ket” simulation, without any required user code action, which is further “hybridized” by default between CPU and GPU QEngine types.

QUnit “Decompose()” variants have finally been adapted to separate sub-units without first maximally entangling representation within the group of qubits to “Decompose().”

“TryDecompose()” and “TrySeparate()” have been restored, (except in QUnitMulti, with "dummy" implementations there,) and “SumSqrDiff()” has been broken out as a separate public method from “ApproxCompare(),” in order to allow users to measure a quantitative difference between (happenstance numerical) raw “kets.” The point of this set of changes is to start to allow user experimentation with “approximate separability” of qubits, such as by trading off between error and efficiency by “Decompose()-ing” bits that introduce only small but non-zero overall “SumSqrDiff()” changes.

Many miscellaneous bug fixes have been made, as the library continues to be tested for stability and correctness on a rolling basis. Builds have been tested on x64 Linux, Windows, and Mac, as well as Android and iOS, and also Raspberry Pi 3 and 4. Qiskit, Q#, and ProjectQ integrations remain available and supported, with unit tests. Windows and mobile builds are now also officially supported as plugins for the Unity video game development engine, as integrated with WrathfulSpatula’s unaffiliated personal fork of the OpenRelativity physics module by the MIT Game Lab, for education, game development, and general modern physics simulation qualitative proof-of-concept.

QHybrid

• This release introduces the Qrack::QHybrid type, which switches between CPU and GPU modes as effecient.
• Small QEngineCPU (and QHybrid) workloads are now asynchronous.
• QUnit now loads underlying "shard" engines lazily, when a QEngine is not necessary to simulate single separable qubits.
• The experimental Qrack::QPager type has been added.

Issue #357 addressed

Issue #357 related to Qrack::QUnit buffering accuracy was addressed and tested up to a random universal circuit depth of 5 layers.

QUnit buffering debbuging

This release is a stability enhancement for Qrack::QUnit controlled gate buffers, debugged against cross entropy benchmark tests.

Improved QUnit buffering and fSim gate

QUnit buffering has been improved, and the "fSim" gate has been added, which is useful in the simulation of quantum particles with fermionic statistics.

Stability improvements and API refactor

1. Cross entropy benchmarks have helped us debug QUnit to its most stable, accurate, and performant point to date.
2. Builds have been tested on Linux, Windows, Apple, and with VC4CL on the Raspberry Pi 3.
3. QFusion was determined to be obsolete, including for performance considerations, and it was removed.
4. The "Hash" method has been added, which effectively lets the user specify any one-to-one function (without phase effects) for unitary qubit state transformation via a classical hash table.
5. CMake options now include arbitrary (power-of-two) maximum qubit capacity in a single QUnit, with the Boost libraries for big integers. Of course, allocation is still limited by system resources, and the maximum OpenCL "shard" indexing is 64 qubits or less, (which is safely outside of possible resource limits for "Schrödinger method" simulation).
6. Documentation has been brought into line with the features and benchmarks of the new release.