gbskernels 0.2.0__tar.gz

gbskernels-0.2.0/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## [0.2.0] - 2026-07-22
+
+### Important Correction
+
+- Replace the legacy Jiuzhang state reconstruction with the published
+  paired-source Q7 construction and the exact real xxpp threshold-torontonian
+  matrix. The two v0.1 frontier JSON files remain historical artifacts and are
+  rejected by the current figure tooling.
+
+### Added
+
+- A fail-closed Jiuzhang confirmatory-v2 workflow covering exposure-ledger
+  audit, outcome-blind design, immutable public registration and beacon-derived
+  selection, content-addressed evaluation, refusal recovery,
+  reconstruction/calibration uncertainty, joint normalizer replicates,
+  absolute predictive checks, simultaneous coherence-grid inference, and
+  hash-verified release bundles.
+- Canonical registration, design, and exposure templates plus focused contract
+  and regression tests for the workflow and exact xxpp construction.
+
+### Fixed
+
+- Harden certified recursive-torontonian bounds with directed downward
+  subtraction, sound double-double magnitude bounds, and explicit
+  double-double-to-FP64 collapse residual accounting, plus a dedicated
+  enclosure gate.
+
+### Scope
+
+- This release provides code, templates, and validation contracts. It contains
+  no completed v2 registration or new scientific outcome; external calibration,
+  public timestamp/beacon evidence, and acquisition inputs remain required.
+
+[0.2.0]: https://github.com/chaofanzhougit/GBSKernels/compare/v0.1.1...v0.2.0

gbskernels-0.2.0/CITATION.cff

@@ -0,0 +1,11 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "GBSKernels: a GPU-native, batched library of photonic sampling matrix functions"
+version: 0.2.0
+date-released: 2026-07-22
+license: Apache-2.0
+repository-code: "https://github.com/chaofanzhougit/GBSKernels"
+authors:
+  - given-names: Chaofan
+    family-names: Zhou
+    email: chaofanzhou97@gmail.com

gbskernels-0.2.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

gbskernels-0.2.0/MANIFEST.in

@@ -0,0 +1,15 @@
+# Source distribution contents: the CPU library packages are declared in
+# pyproject; this adds the CUDA sources, bindings, examples, docs, and the
+# session tooling so the sdist is a complete, buildable source release.
+graft core
+graft bindings
+graft examples
+graft docs
+graft scripts
+graft envs
+include LICENSE README.md CHANGELOG.md CITATION.cff pyproject.toml
+prune core/build
+prune core/build_prof
+prune bindings/build
+prune bindings/build_host
+global-exclude __pycache__ *.pyc *.so *.o

gbskernels-0.2.0/PKG-INFO

@@ -0,0 +1,255 @@
+Metadata-Version: 2.4
+Name: gbskernels
+Version: 0.2.0
+Summary: GPU-native, batched library of photonic sampling matrix functions (hafnian, loop hafnian, permanent, torontonian).
+Author-email: Chaofan Zhou <chaofanzhou97@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/chaofanzhougit/GBSKernels
+Project-URL: Documentation, https://github.com/chaofanzhougit/GBSKernels#readme
+Project-URL: Issues, https://github.com/chaofanzhougit/GBSKernels/issues
+Keywords: quantum,photonics,gaussian-boson-sampling,hafnian,permanent,torontonian,loop-hafnian,gpu,cuda,numerical-methods
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Requires-Dist: mpmath>=1.3
+Dynamic: license-file
+
+# GBSKernels
+
+A GPU-native, batched library of the #P-hard matrix functions behind photonic
+quantum sampling — the **permanent, hafnian, loop hafnian, and torontonian** —
+with an explicit floating-point accuracy model that ranges from native double
+precision to rigorous a-posteriori error bounds.
+
+Gaussian boson sampling and its displaced- and threshold-detector variants, and
+standard boson sampling, reduce computationally to evaluating *large batches of
+independent, medium-sized* instances of these four functions. Each is an
+alternating signed sum whose value can be many orders of magnitude smaller than
+its terms, so it is cancellation-prone in floating point: both throughput and
+*known* accuracy matter. GBSKernels targets exactly this workload — batched-first
+kernels on CPU and CUDA, every function validated against independent
+combinatorial ground truth, and a precision model in which the accuracy of every
+result is either measured or provably bounded.
+
+GBSKernels is designed to **complement**
+[The Walrus](https://github.com/XanaduAI/thewalrus), the canonical CPU/C++
+reference implementation, rather than to replace it: a GPU-native, batched
+companion with an explicit accuracy characterization. The Walrus is used here as
+one of several independent test oracles.
+
+> **Status.** The CPU library is complete and `pip`-installable (pure Python,
+> `numpy` + `mpmath` only). Historical release validation covers NVIDIA hardware
+> (RTX 4090, A100); the v0.2 changes pass the CPU host-shim gates and still require
+> a fresh on-device validation session. This is pre-1.0 software and the public
+> API may change.
+
+Version 0.2.0 adds the fail-closed Jiuzhang confirmatory workflow and corrects
+the real threshold-torontonian construction used by the Jiuzhang examples. See
+the [changelog](CHANGELOG.md) for the release scope and compatibility notes.
+
+## Installation
+
+Not yet on PyPI; install from source. The CPU backend needs only `numpy` +
+`mpmath`; the CUDA extension is a separate, optional build (see
+[`bindings/README.md`](bindings/README.md)):
+
+```bash
+uv build                        # -> dist/gbskernels-*.whl, then pip install it
+# pip install gbskernels        # planned once published to PyPI
+```
+
+## Quick start
+
+```python
+import numpy as np
+import gbskernels
+
+A = np.array([[1., 2.], [3., 4.]])
+gbskernels.perm(A)                              # (10+0j)
+
+# The API is batched-first: one call evaluates a stack of matrices.
+rng = np.random.default_rng(0)
+stack = rng.standard_normal((4096, 8, 8))
+stack = stack + stack.transpose(0, 2, 1)        # symmetric, as the hafnian needs
+
+gbskernels.haf_batched(stack)                   # double precision (default)
+gbskernels.haf_batched(stack, precision="auto") # double precision + cancellation guard
+gbskernels.haf_batched(stack, backend="gpu")    # CUDA, if the extension is built
+gbskernels.haf(stack[0], precision="ref")       # arbitrary-precision reference
+```
+
+A short guided tour — closed-form checks, the `auto` tier catching real
+double-precision cancellation, a GBS distribution, and a sampling run — runs
+with wheel dependencies only:
+
+```bash
+python examples/gbs_demo.py
+```
+
+## Precision model
+
+Precision is always an explicit tier, so the accuracy of a result is never left
+implicit:
+
+| Tier | Description |
+|---|---|
+| `"fp64"` (default) | Native double precision — the throughput path, with a measured accuracy boundary. |
+| `"dd"` | Double-double arithmetic carried internally through the cancelling sum (a GPU tier); recovers a correct double-precision result where plain double precision cancels. |
+| `"ref"` | Arbitrary-precision reference (`mpmath`); the accuracy ground truth. |
+| `"auto"` | Double precision plus a per-evaluation cancellation indicator; evaluations flagged as risky are recomputed in a higher tier (`mpmath` on CPU, double-double on GPU). The indicator is a calibrated heuristic, not a certificate. |
+| `"certified"` | The double-precision value together with a **rigorous a-posteriori error bound**: `\|value − exact\| ≤ abs_error_bound`, a running error bound in the standard model of floating-point arithmetic (on the GPU, the bound arithmetic uses per-instruction directed rounding). Available for all four functions on CPU and GPU. With `rtol=`, a failed certified-fp64 bound escalates to the arbitrary-precision reference; GPU permanent and hafnian first try a certified double-double bound. The reference result is flagged as non-certified. `tor_single(..., dd=True)` provides a separate certified-double-double large-torontonian path. |
+
+## Features
+
+- **All four functions, batched, on CPU and CUDA.** Field-standard algorithms
+  (Glynn/BB–FG for the permanent, the power-trace form for the hafnian and loop
+  hafnian, subset-determinant inclusion–exclusion for the torontonian), each with
+  an independent naive reference used for verification.
+- **A measured accuracy boundary.** The double-precision–vs–double-double
+  crossover is characterized for every function against an arbitrary-precision
+  reference, on physical and adversarial inputs.
+- **Certified evaluation.** Every value can be returned with a rigorous error
+  bound whose enclosure of the true value is a hard test invariant — verified on
+  closed forms, random ensembles, and adversarial cancellation families.
+- **A device-resident workspace.** `gbskernels.Workspace` evaluates ragged
+  batches with a persistent stream, pinned staging, and a zero-copy DLPack output
+  that CuPy / PyTorch / JAX can consume without a device-to-host copy
+  ([`docs/device_resident_contract.md`](docs/device_resident_contract.md)).
+- **A conditional GBS sampler** (`sampling/`) that draws photon-number samples by
+  the chain rule, evaluating each mode's batch of hafnians on the GPU, validated
+  distributionally (total-variation distance below 0.03 against both the exact
+  distribution and The Walrus, and a chi-square goodness-of-fit p > 10⁻³ against
+  The Walrus).
+- **Structure-aware kernels** for the sampling workload: a repeated-row
+  finite-difference sieve for the loop hafnian, and a recursive prefix-Cholesky
+  torontonian — including a single-large mode that splits one evaluation across
+  the GPU to dimension 64 (32 modes).
+- **A fail-closed confirmatory workflow** for the public Jiuzhang example,
+  covering exposure audit, frozen design, future-beacon selection,
+  content-addressed evaluation, refusal recovery, simultaneous coherence-grid
+  inference, predictive checks, and release verification
+  ([protocol](docs/confirmatory_v2.md),
+  [tools](examples/jiuzhang/README.md)). The repository ships templates and
+  validation contracts, not a fabricated registration or completed v2 outcome.
+
+## Verification
+
+Verification is treated as the deliverable ([`docs/DESIGN.md`](docs/DESIGN.md), §8).
+Five layers are exercised by the test suite on every commit:
+
+1. **Independent combinatorial ground truth** — perfect-matching counts and
+   closed forms (`perm(J_n) = n!`, `haf(J_{2n}) = (2n−1)!!`, …), sharing no code
+   with any existing library.
+2. **Differential testing against The Walrus** across sizes, seeds, and
+   real/complex inputs.
+3. **Property-based invariants** (Hypothesis): scaling, permutation, transpose,
+   the loop-hafnian → hafnian reduction, and others.
+4. **Statistical / end-to-end validation** — the kernels compute GBS
+   distributions that sum to one and match The Walrus per pattern in all three
+   detector regimes.
+5. **Numerical-accuracy characterization** against the arbitrary-precision
+   reference, including adversarial cancellation families that defeat double
+   precision and must survive double-double.
+
+The Jiuzhang v2 tooling adds workflow-contract tests for canonical hashing,
+registration timing, exclusion-ledger completeness, selection, immutable run
+reduction, refusal recovery, inference, reconstruction, and release assembly.
+
+The development discipline is CPU-first: host-shim-compatible CUDA kernels are
+compiled and run through the CPU pre-flight (part of the test suite), then the
+full source set is checked on-device against independent CPU references before
+any throughput result is considered publishable. Device-only variants such as
+the warp-specialized permanent are covered by the on-device gates; profiler
+diagnostics collected before those gates remain provisional until they pass.
+
+## Performance
+
+The library is batched-first: throughput comes from evaluating thousands of
+independent instances per launch, and the benchmark harness reports where the
+CPU wins (small single evaluations) as plainly as where the GPU wins (large
+batches), always alongside the accuracy each point was measured at. The
+structure-aware kernels give substantial speedups in their regimes — the
+recursive torontonian over the LU form, and the finite-difference sieve over the
+expanded power-trace at repeated-row patterns. Raw benchmark data is written,
+append-only, to `results/`; the protocol is described in
+[`docs/benchmark_protocol.md`](docs/benchmark_protocol.md).
+
+```bash
+python -m bench.accuracy                          # the accuracy boundary, all four functions
+python -m bench.throughput --func perm --sizes 4,6,8,10
+bash scripts/gpu_session.sh                       # full on-device session (on a CUDA host)
+```
+
+## Scope and limitations
+
+These are correctness-first kernels with a deliberately narrow scope:
+
+- **One evaluation per GPU thread** is the default mapping. Warp/block-cooperative
+  variants exist and are dispatched only where they measurably win (the
+  cooperative permanent); for the hafnian, loop hafnian, and torontonian the
+  per-thread linear algebra is memory-bound, and the cooperative strategy does
+  not help them.
+- **The four functions do not share a single subset-enumeration engine.** Only
+  the permanent uses the Gray-code delta walk; the others enumerate masks
+  independently, because their per-subset work is memory-bound.
+- **Fixed size limits** (per-thread buffers): permanent ≤ 28, hafnian ≤ 20 (DD
+  ≤ 16), loop hafnian ≤ 20 (DD ≤ 14), torontonian 2n ≤ 24. Larger inputs raise on
+  `backend="gpu"`; use the CPU backend. The single-large recursive torontonian
+  extends to dimension 64.
+- **The double-double tier is internal**: kernels carry double-double through the
+  cancelling summation and collapse to `complex128` on output — they recover a
+  correct double-precision answer under cancellation rather than exposing
+  extended-precision results. The double-double torontonian is real-input only.
+- **The sampler is pure-state and hybrid host-orchestrated** (the host drives the
+  chain rule; the GPU evaluates each step's batch of hafnians). A fully
+  on-device variant is available but limited to double precision within a
+  submatrix-size cap.
+- **Single GPU, CUDA only** — no multi-GPU, ROCm, or automatic differentiation.
+
+## Repository layout
+
+```
+gbskernels/     batched-first Python API (the public surface)
+cpu_ref/        independent CPU reference implementations (double + double-double)
+highprec_ref/   arbitrary-precision reference (mpmath)
+core/           CUDA C++: subset-enumeration utilities, the kernels, on-device gates
+bindings/       nanobind extension exposing the GPU backend to Python
+sampling/       boson-sampling orchestration and the conditional GBS sampler
+examples/       runnable CPU demo plus Jiuzhang reproduction and v2 workflow tools
+tests/          the five-layer verification suite
+bench/          accuracy and throughput harnesses
+scripts/ envs/  scripted GPU-session runner and container definitions
+docs/           design, benchmark/device contracts, and v2 protocol/templates
+results/        append-only validation, gate, benchmark, and profiler artifacts
+```
+
+## Development
+
+```bash
+uv sync                      # Python 3.12 environment, dependencies, editable install
+uv run pytest                # the CPU verification suite
+uv run pytest -m layer1      # the independent combinatorial ground truth
+uv run pytest -m "not slow"  # the fast tier
+```
+
+Building the CUDA extension requires `nvcc` and is a separate, optional step
+([`bindings/README.md`](bindings/README.md)); the pure-Python wheel never
+requires it. The full design rationale — algorithms, precision strategy, and the
+verification contract — is in [`docs/DESIGN.md`](docs/DESIGN.md).
+
+## Relationship to The Walrus
+
+GBSKernels would not exist without [The Walrus](https://github.com/XanaduAI/thewalrus),
+which remains the canonical reference implementation and this library's primary
+differential oracle. The scope here is deliberately narrower: the four batched
+kernels and their precision characterization.
+
+## License
+
+[Apache-2.0](LICENSE).