vibe-qcDocumentation

Unified tensor engine proposal¶

Status: design-first proposal, 2026-11-02. No tensor runtime, dependency, benchmark result or new scientific capability is delivered by this document. The implementation tracker divides the work into claimable capabilities and method migrations. This programme is planned, unscheduled and outside the bounded QC 0.18 release scope in #557.

Semantic contract first¶

Every tensor-using method must eventually submit its numerical tensor work through one vibe-qc-owned C++17 contract. The engine describes values, domains, operations, execution capabilities and resource ownership. Methods describe equations, physical sources, coordinate frames, occupations, selection rules, reconstruction weights, screening and scientific error controls. A shared contract permits several representations and kernels; it never requires a global dense tensor or a generic Python snapshot in a native loop.

The initial implementation uses runtime rank, FP64 and complex FP64, with Eigen/BLAS/LAPACK and existing specialized kernels. Static-rank specialization is permitted inside a kernel. Arbitrary finite rank is a semantic capability, subject to checked metadata, address, work and memory limits. Backend rank, integer-width and layout limits require tiled lowering or explicit refusal.

These are the proposed invariants:

Equal extents do not establish compatible coordinates. Every axis binds an opaque index-space identity, revision and ordered domain map. Transport or identification between spaces is an explicit method-supplied operation.
A borrowed pointer has a byte extent, allocation identity and lifetime lease. Neither constness nor a digest prevents concurrent mutation.
Shapes, signed strides, offsets, products, workspace sizes and backend integer conversions are checked before forming pointers or writing output.
Conjugation is explicit. Bilinear contraction, Hermitian inner product, transpose and adjoint are different operations.
Exact structural absence is distinct from screened omission, underflow, unavailable data and lossy compression. A missing pointer proves none of these by itself.
Scheduling cannot change physical supports, factors, approximation levels, exchange conventions or retained spaces. An exact refactoring may change floating-point reduction order only under the declared numerical policy.
A plan is admitted against all tracked live storage and work limits before execution. Owners and reservations survive every asynchronous consumer.
A specialized execution path participates in capability checks, admission, events, numerical policy and diagnostics. An untracked legacy call wrapped in a tensor name does not satisfy migration.

Decisions still requiring evidence¶

These choices remain open for implementation ADRs. They do not hold unrelated work or existing programmes open. Defaults below permit the two CPU slices.

Decision	Starting proposal	Evidence or decision needed
CPU lowering and optional dependency	Eigen/BLAS plus registered small kernels; explicit-pack/GEMM baseline	TBLIS crossover by actual shapes, layouts, complex handling and total cost; optional version pin and build cost
Index algebra	Opaque spaces, dependent maps and generic reconstruction callbacks	Inventory non-Abelian fusion/multiplicity needs before selecting a sector schema; do not encode only additive Abelian charges
Hard budget boundary	Tracked host/device allocations, bounded backend workspace and declared external reservations	Audit Eigen/BLAS allocator behavior; strict mode rejects unknown dynamic workspace; measured RSS remains separate
Reproducibility	Strict FP64 arithmetic and explicit reduction order policy	Select a supported reproducible-reduction implementation and its coverage/cost; no universal bitwise BLAS promise
Out-of-core data	Provider-owned storage behind a versioned tile interface	Choose portable format, integrity/transaction semantics and scratch accounting from real workloads; no new format prerequisite for CPU slices
GPU portability	Shared adapter ABI, independently qualified CUDA/HIP operations and existing Apple feasibility work	Hardware, precision, workspace and transfer-inclusive crossover; no inferred feature parity
Distributed substrate	Reuse current optional MPI activation and task farming first	Communicator ownership, progress/thread requirements, measured need for distributed tensors, optional CTF or other substrate
Compiler and compression extensions	Explicit optional operation/backend plugins	Profiling benefit, toolchain/license cost and separate method-approved approximation contracts

The proposal does not raise the project C++ standard or introduce a hard dependency. A future breaking API, licensing choice or hard dependency remains a maintainer-owned decision when a concrete implementation needs it.

Smallest useful vertical slices¶

M: molecular RI-J on existing factors¶

Start in df.hpp, df.cpp and the existing DF storage checks. Adapt the actual separate column-major per-P factors described in the GPU operation contract. They are not a single affine rank-three allocation. Register a tiled provider and execute:

gamma[P] = sum(mu,nu) B[P,mu,nu] D[mu,nu]
J[mu,nu] = sum(P) B[P,mu,nu] gamma[P]

The method supplies factors, AO/auxiliary identities, density convention and all energy coefficients. Retain the existing construction, metric solve and fitting rank. Begin with synchronous CPU execution, bounded tile metadata, one BLAS ownership policy and a checked pack fallback. Do not turn an RI-J slice into a new RI-K or occupied-orbital approximation. Add one bounded quarter AO-to-MO transform after this slice to exercise layout/permutation lowering without requiring a four-index production allocation.

Accept asymmetric sentinels, unequal dimensions and real sliced views before testing physical factors. Compare fixed-density J and its method energy, then complete H2O RHF and pure-DFT calculations through vq at unchanged settings against the predecessor and matched ORCA references. A correlated AO-transform extension also needs its affected complete-method check. Pin observables and tolerances before examining results, using existing qualified fixtures where applicable. Record planning, packing, execution, retained bytes and construction peak separately. No measured speedup is assumed.

L: complex local/periodic factors without global materialization¶

Start at the actual periodic Gaussian local-orbital factor blocks, local-factor consumers and their existing block tests. Adapt one rectangular [auxiliary,left,right] complex panel for one q and auxiliary slice, then a bounded contraction in an existing selected-pair MP2 consumer. Register the current specialized producer first; generic lowering must earn replacement through equivalent source and resource checks.

Use unequal local domains, genuine imaginary entries, independent OV/VO orientations and a method-supplied k/q map. Preserve the actual finite-image source, whitener, selected occupied/virtual identities, phases, work caps and node/rank inventories. Retain the current compensated accumulation where the method requires it. There is no q/-q shortcut or real projection. A logical dataset larger than the granted memory must remain tiled, with bounded tile visits and metadata. The synthetic v1 factor stream is useful for transport failure tests, but cannot qualify a numerical Gaussian factor producer.

First compare selected coefficients, complex factors and contracted pair quantities to the predecessor and small independent explicit sums. Then run the existing admitted finite-source HF plus selected-pair MP2 workflow through vq. Use matched CRYSTAL where the method/source is available; otherwise justify same-source numerical sums and known limits and state their scope. This does not establish production periodic correlation or infinite-image convergence. Reuse #580/#581 source admission and #472 evaluated-state gates; do not create competing scientific adapters. An irregular molecular local-pair case follows to verify that the generic core has no periodic-only semantics.

Allocations, views and domains¶

Proposed internal names are vocabulary, not an existing API or stable ABI:

Object	Responsibility
`AllocationHandle`	Unique allocation ID/generation, address space, full byte extent, alignment, deleter/owner and resource reservation
`TensorDesc`	Runtime dtype/rank, ordered axes/domain references, representation tag and immutable logical schema
`AffineView`	Allocation handle or scoped borrow, origin byte offset, signed byte strides, extents, access mode and conjugation flag
`IndexSpace` / `DomainMap`	Opaque identity/revision, ordered coordinate selection, parent/dependency identities and explicit transport maps
`ReadLease` / `WriteLease`	Lifetime plus read/write exclusivity, generation/version pin and completion dependency
`TensorProvider`	Versioned tile schema, access/assembly capabilities, placement, resource/work bounds and completion behavior
`OpGraph` / `Plan` / `Execution`	Checked algebra DAG, inspectable admitted schedule, and stateful completion/failure/ownership respectively

An allocation is counted once even when multiple views reference overlapping regions. A view exposes only authorized bytes; its safe logical range cannot exceed the allocation or the imported borrow extent. External resident owners are registered once in the caller inventory. A subview cannot claim that its small visible region makes the rest of a still-live owner disappear.

Rank zero denotes one scalar. Any zero extent produces an empty logical tensor; no null pointer arithmetic or element access is allowed. Empty reductions yield the additive identity, followed by the explicit alpha/beta rule. For every nonempty affine view compute the minimum and maximum reachable byte offsets with checked signed arithmetic, including reversed strides and the last element’s width. Validate alignment and representability in the target address space separately from logical element-count arithmetic.

Slicing composes the domain map, offset and strides. Permutation changes axis order without moving values; it does not identify different index spaces. Read-only broadcasting uses zero strides and explicit singleton expansion. Writable broadcast or overlapping output views are refused initially. General strided overlap is conservatively assumed when disjointness cannot be established. Supported input/output aliasing uses a reserved temporary or a registered, proved-safe in-place kernel; otherwise reject before mutation.

A view-only reshape requires compatible contiguous stride groups and an explicit ordered split/fuse map for the index spaces. Equal element count is insufficient. A reshape that needs reordering is a separate budgeted copy. An adjoint is permutation plus conjugation. A conjugated writable destination is not a normal store: initially normalize it through an explicit temporary and conjugating commit or refuse it. Real-to-complex conversion is an explicit IR node; complex-to-real requires an explicit method-approved conversion.

Index identity includes revision, coordinate ordering and dependent-domain keys. For a pair-local virtual space, the pair identifier and ordered local selection are part of compatibility, even if another pair has the same rank. Coordinates, frames and domain maps come from authoritative method objects; constructing two matching strings cannot certify physical source equivalence. Method selection/reconstruction operations provide signs, phases, multiplicities and, where needed, non-Abelian coupling channels. Generic contraction consumes those maps without deriving chemical rules.

Owned handles keep storage alive. Synchronous native borrows cannot escape their scope. Asynchronous imports need a retainable owner, exclusive write policy and producer-completion handshake, or an admitted owned copy. External NumPy aliases cannot be made immutable by a C++ const pointer or a hash: the safe async default copies mutable imports; trusted zero-copy requires an explicit caller no-mutation lease. Checksums verify supplied identity, not race freedom. Acquiring a write lease invalidates old value/cache bindings; success publishes a new revision and failure leaves that output invalid. Active leases forbid conflicting mutation.

Provider and representation protocol¶

The initial provider protocol has a synchronous implementation and an event extension; GPU or MPI is not needed to define it. Each provider declares:

Contract	Required information
Schema/version	Dtype, logical axes, tile keys, domain/pattern/source revisions, finite-source receipt and address space
Enumeration	Bounded metadata, canonical order or explicit unordered capability, count-only/cursor access and dependent-domain enumeration
Read access	Replayable/random access, replayable sequential, or single-pass; lease validity and maximum simultaneous leases
Bounds	Retained owners/control metadata, maximum tile/scratch bytes, work/read-call upper bounds and backend margin
Assembly	Read-only, private output, replace or add; sorted/unsorted indices, duplicates, reduction order and finalization rules
Locality	Data placement, preferred task placement, communication requirements and allowed movement; these are separate descriptors
Completion	Ready event, release event, cancellation behavior, failure status and valid-output policy
Absence/accuracy	Exact structural zero, evaluated value, screened omission with method receipt, underflow, or unavailable/error

Sparse duplicate entries require declared additive assembly and an approved reduction policy; they are never silently overwritten. Output assembly may choose dense, sparse insert/sort/merge, or direct sorted emission, counting metadata and scratch in each case. Domain enumeration must not allocate a descriptor for every logical element or all possible local pairs.

A single-pass source cannot feed an unbudgeted replaying schedule. The planner must use one pass, stage within an admitted store, or reject before consuming it. A transient workspace tile is consumed synchronously, leased against workspace reuse, or copied into reserved storage. A failed provider must not be replaced by an approximate or scientifically different producer.

Factor graphs remain first-class inputs: RI factors, exact separable products and existing method-approved compressed factors can execute directly through factor contractions. Small explicit reconstruction is a test oracle; full reconstruction is never an automatic fallback. CP/Tucker/TT/HT truncation, randomized sketches and THC fitting are distinct operations with contracts for norm, tolerance, rank, probability/seed/passes where relevant, construction cost and method acceptance. An engine-level norm estimate is not an energy, force or stress error certificate.

Operation IR and planning¶

Both an explicit indexed frontend and a checked einsum parser lower into the same runtime-rank IR. Spell inputs and outputs explicitly; do not infer conjugation or silently broadcast unequal named index spaces. Frontends must check repeated labels/diagonals, contraction versus batch/free indices, domain/duality compatibility, scalar coefficients and output aliasing. Opaque integer index IDs avoid alphabet/rank limits; einsum ellipses expand into explicit broadcast axes before validation.

The initial operations are contraction/reduction, add/scale, explicit cast, permutation, gather/scatter through domain maps, reshape/copy and registered specialized kernels. Elementwise operators are named, versioned native operations with declared domains/effects; arbitrary Python callbacks are not inner-loop kernels. Decomposition/solve nodes reuse the existing mathematical role and solver interfaces: an auxiliary metric, CI Hamiltonian or general non-Hermitian Jacobian does not become a Fock operator.

Each output has an SSA-like value/version and explicit write effects. A multi-expression DAG permits common-subexpression reuse only when source, value versions, domain maps, numerical modes and operation semantics match. In-place execution is a schedule decision after dependency/alias analysis. Symbolic second-quantized algebra or generated CC equations can submit this IR later; they do not live in the generic execution core.

Start with bounded greedy selection, limited dynamic programming for small graphs, and a deterministic no-search fallback. Optimize contraction order jointly with layouts, iteration/assembly order, packing, fusion, batches, communication, resident bytes and work. Alternatives include existing small loops, Eigen/BLAS, explicit-pack/GEMM, batched GEMM, direct packed contraction, sparse traversal and registered method kernels. Never substitute FLOP count or largest-intermediate size for total schedule cost or live memory.

Plan construction records search limits, estimated cost and uncertainty, required capabilities, data movement, allocations, lifetime intervals, reduction tree/order and failure/commit mode. The schedule may reduce concurrency, slice, recompute or spill before refusing an impossible request. Slicing cannot skip factors or introduce domain/screening approximations. Measure cold parsing/planning, optional compilation/tuning, packing and execution separately from warm replay; bound search, tuning and cache storage.

A structural plan cache key includes IR/version and scalar specialization, extents, ordered index/domain revisions and dependent maps, sparsity pattern and provider schema revisions, dtype/conjugation/strides/alignment class, backend version/capabilities, hardware, thread/rank topology, data/task placement, numerical mode, resource budgets and planning policy. Plans carry no stale raw pointers. Rebinding validates current allocations, access leases, provider/source revisions and alignment. Numeric intermediates have a separate cache keyed additionally by actual immutable input versions and source/frame receipts. Persistent cache serialization must not persist native owners.

Resource admission and executor lifecycle¶

Use one reservation ledger per execution scope, with host-node, per-process, per-device and scratch-store limits explicitly related. Count shared owners once at their owning scope and replicas at every actual placement. An adapter must not double-charge an external method reservation or omit storage because another component allocated it. Preserve current method work-unit limits in addition to bytes; engine FLOP estimates cannot replace them.

For each time interval the admitted total is:

unique live input/output allocations + retained method/external inventory
+ live metadata/domain maps + intermediates + packing/assembly buffers
+ backend workspace/margins + concurrent-task scratch + transfer/staging
+ caches + distributed/device replicas + executor/control allocations

Retained space/frame/source owners and legacy export copies count whenever live. Planning and provider metadata are themselves budgeted. Known runtime allocator caches require a conservative reservation or a controlled allocator; unknown dynamic workspace cannot run under a strict tracked-allocation claim. Record untracked runtime/driver overhead and measured RSS separately. A hard tracked-byte limit is not a universal process-RSS or operating-system OOM guarantee. Zero/unknown limits retain the fail-closed meaning of imported periodic contracts; there is no automatic unlimited reinterpretation.

The lifecycle is validate -> plan -> reserve/admit -> bind leases -> launch -> complete/commit or fail/drain -> release. Metadata validation and alias or budget refusal occur before output mutation. Admission is atomic for a runnable task’s required resources; do not enqueue tasks that hold each other’s needed buffers. A plan cached under a larger budget is re-admitted.

Private output handles are unpublished until successful completion; failure invalidates them. Caller-provided output uses a fully reserved temporary for failure-atomic commit, or an explicit destructive-output mode whose failure leaves the whole destination invalid. Do not promise transactionality through unmodeled rollback copies. Cancellation prevents new tasks and drains launched work; it cannot free buffers still in use. An event owns retained leases, reservations and backend error state until actual completion, including after the user drops the future. Errors propagate with the first failed node and dependent outputs are never reported valid. Spill files follow the same ownership/failure cleanup rules, under a user-selected external scratch root.

Task execution owns threads explicitly. Default outer tasks use BLAS=1; a large GEMM can instead own an exclusive BLAS team under a fixed execution policy. Never race process-global BLAS thread settings between tasks. NUMA placement/first-touch and affinity are explicit policies, with bounded cross-node stealing. Report requested and actual thread teams and memory placement rather than assuming environment variables established them.

Numerical policy, backends and Python¶

Default inputs, outputs and accumulation are FP64 or complex FP64, with no implicit reduced precision or blanket fast-math. Strict mode preserves the documented treatment of nonfinite values and subnormals. Alpha/beta rules are explicit: beta=0 does not read old output; alpha=0 skips input evaluation and scales/fills output, matching the declared BLAS-like semantics. Nonzero beta requires initialized readable output. Zero-reduction identity and signed-zero policy are tested. If an application requires propagation from skipped NaNs, it needs a different explicitly selected operation policy.

Distinguish fixed-plan repeatability on a pinned backend, deterministic task ordering, and reproducible reductions across thread/rank counts or backends. Cross-backend reproducible summation is a separate capability that may use binned accumulation and extra storage. It cannot promise bitwise equality of different GEMM products, eigensolvers or complete calculations. Reassociation, FMA contraction and compensated algorithms have explicit legality rules; TensorRight-style real-algebra proofs do not establish IEEE equivalence. Unsupported requested modes refuse or use an explicitly admitted same-source fallback. Roundoff estimates state their conditioning and overflow premises.

A backend advertises per-operation dtype, rank, stride, conjugation, alias, assembly, workspace, numerical-mode, thread and asynchronous capabilities. Use checked BLAS integer conversion/tiling. Benchmark optional TBLIS against packing and existing small loops before selecting a crossover. The inspected TBLIS 1.3.0 general dense GEMM path asserts no conjugation: use checked conjugate packing or another registered path, never forward unsupported flags. Mixed precision and compression require a separate method-approved policy.

GPU adapters use explicit device/stream/event ownership and readiness/release handshakes, bound plan/workspace caches and host/device transfer staging. Query exact FP64/complex/rank/layout/sparse capabilities in the installed backend. A CPU fallback retains the same physical source and numerical policy and counts migration cost. Align with existing G0-G6 and G1m work; this proposal neither selects a vendor nor cancels the Apple feasibility route.

MPI stays optional. Reuse the existing MPIWorld activation rules; ordinary serial import must not initialize MPI. Retain communicators/process groups until requests complete. Query actual MPI_THREAD_* support, provide explicit progress ownership and serialize MPI calls when required. Collective order, rank failure/refusal and cancellation must not strand other ranks; a failure policy may need collective termination rather than recovery. Count messages, buffers, replicas and node/rank totals. Data distribution and task placement are separate; distributed dense linear algebra follows measured need, not the existence of a generic tensor API.

Python submits coarse graphs, tiles and registered operations. NumPy/buffer imports declare copy/zero-copy behavior, dtype, strides and owners. Release the GIL around native execution; avoid per-element callbacks and worker-thread Python provider calls. Device exchange uses DLPack or an equivalent explicit stream handshake, without implicit host synchronization claims. Futures retain owners; returned NumPy views retain their native owners. Descriptors and plan metadata can serialize separately from process-local buffers and events.

Existing interface boundaries checked¶

Source baseline: main 3ec1a4ae, including incoming RI metric change 4ae22b85: its LAPACK/Eigen solver identity and bounded queried workspace must survive adapters and cache binding. Issue descriptions and latest available non-system notes for #472/#594, #580, #617 and #639 were read on 2026-11-02. Issue states and implementation evolve; recheck before selecting files.

Authority	Actual current interface	Tensor integration boundary
#472/#594 Fock and eigensolver	`EvaluatedFockView` borrows synchronously; `OwnedEvaluatedFock` copies terminal matrices. Python `FockBuild`/`OperatorFrame` owns physical evaluated state; auxiliary/CI/non-Hermitian roles remain distinct	Adapt matrix views/owners without changing capture lifetime, physical versus solver state, energy formulas or frame admission. Recent native RHF source landing has scientific acceptance pending; it is not universal provider qualification
#580 local consumers; #581 factors	PAO/pair/frozen/spin identities and admitted physical references; separate Gram/metric roles	Consume existing admissions, domain maps and retained blocks. Tensor transport does not prove stationarity, source equality or frozen-space compatibility
Periodic resource/factor contracts	`PeriodicCorrelationResourceBudget` and staged static/pair/triple census; Gaussian factor panels carry finite-source, whitener, work and per-node inventory	Import current reservations/identities without double counting, padding all pairs or claiming production correlation. Synthetic factor-stream v1 remains nonphysical
#617 MANTA	`IntegralProvider::evaluate` returns workspace-borrowed `TileView` valid until next evaluation; null values denote screened/underflowed tiles. `BuildPlan`/`ResourceBudget` count memory and work; receipts carry physical source/screening	Preserve workspace exclusion or copy under reservation; do not treat null as exact zero. Preserve J/K capabilities, kernel/support/q=0, source, rank and arithmetic certificates
#639 MANTA acceleration	Optional tile/action prototype depends on measured #638 bottlenecks and #624 precision accounting	Generic GPU/MPI issues supply shared execution capabilities; #639 retains MANTA scientific qualification. No second MANTA backend programme
GPU programme	Operation contracts, G0/G1m plan, roadmap G0-G6	Reuse physical layouts, spin factors, signed densities, noise evidence and complete-cost protocol; qualify complex/periodic separately
MPI programme	MPI design, `python/vibeqc/mpi.py`, roadmap MPI0-MPI5	Reuse launcher/communicator policy, k/output-block farming and source-qualified schedules; no implicit distributed FFT or dense solver claim

The tensor programme owns general storage/IR/execution. Existing programmes retain their Fock, provider, symmetry, science and release authority. A needed interface is a dependency; closure of a whole parent is not. Claim exact files on the implementing issue, preserve owners and live jobs, and link shared changes to their consumer issues. No new coordinator, review chain or CI gate.

Evidence and departures¶

The completed library collection tensor-engine-2026-11-02 contains README, evidence, software, benchmarks and feedback documents: 25 acquired papers, 37 evidence rows and primary software snapshots checked through 2026-11-02. That study did not build packages, benchmark or audit vibe-qc issues. This proposal reuses its inspected passages and adds the interface audit above. Library keys below locate reading details in the configured catalog. There is no claim that this proposal independently reran the study’s experiments.

Primary evidence and inspected passage	Consequence and deliberate limit
Matthews 2018, 10.1137/16M108968X, sections 4-7, 9.1; `tensor20261102_matthews`	Packing-aware contraction avoids global transposition; packing still costs memory. Compare current CPU shapes rather than assuming historical speedups
Springer/Bientinesi GETT 2018, 10.1145/3157733, sections 3-5, 7-8; `tensor20261102_gett`	Several contraction lowerings and crossovers; no default generator or unverified TCCG code/license dependency
TAMM 2023, 10.1063/5.0142433, III-IV; `mutlu2023tamm`	Dependent tiled spaces and scheduling; own a lighter C++17 layer rather than mandate current C++20/MPI/GA/HDF5 build
DISTAL 2022, 10.1145/3519939.3523437, sections 3-7; `tensor20261102_distal`	Separate data/computation placement; do not impose Legion/compiler infrastructure initially
CoRa 2022, arXiv:2110.10221, sections 4-7; CoNST 2024 preprint, arXiv:2401.04836, sections 2-5	Dependent shapes and joint layout/fusion decisions; ML and serial fast-math results do not qualify strict chemistry
Finch 2025, 10.1145/3720473, sections 3-7; sparse workspaces 2024, 10.1145/3656426, sections 4-7	Iterator lifecycle, assembly and bounded scratch are explicit; no Julia runtime dependency
SparseConflicts 2026 preprint, arXiv:2609.06328, sections 3-6	Cost search versus sparse conversion; serial fast-math results are not strict-mode speed evidence
Gray/Kourtis 2021, 10.22331/q-2021-03-15-410, sections 2-4, especially 4.7	Bounded path search and slicing; width is not peak live memory and slices repeat work
CTF 2014, 10.1016/j.jpdc.2014.06.002, mapping/2.5D algorithms; symmetry bounds arXiv:1707.04618, section 6	Communication and replication matter; minimal packed storage is not always fastest
Demmel et al. 2016, ReproBLAS report, sections 6.9, 7	Reproducible reduction is separately costed and scoped, not universal correctly rounded arithmetic
TensorRight 2025, 10.1145/3704865, sections 5-8, 10	Algebraic rewrites still need IEEE, alias and layout legality checks
Kolda/Bader 2009, 10.1137/07070111X, sections 2-4; Grasedyck et al. 2013, 10.1002/gamm.201310004, sections 2-3	Keep factor representations; CP conditioning, Tucker growth and TT/HT ordering/ranks preclude universal automatic compression
Hohenstein et al. 2012, 10.1063/1.4732310, THC/MP2/MP3; Jiang et al. 2023, 10.1021/acs.jctc.2c00996, equations 22-23	THC is a method approximation; exact triples blocking and approximate triples are separate work

Software alternatives remain candidates rather than mandatory dependencies. The study’s current TiledArray/TAMM/BTAS development requirements add C++20 or substantial build costs. TiledArray introduces GPL distribution decisions; MPL/GPL combinations are not categorically ruled out or preapproved. SeQuant is LGPL-3.0, distinct from GPL, and belongs at an optional symbolic frontend. Static-rank Eigen Tensor/Fastor/mdspan alone do not supply the dynamic-rank contract; xtensor alone is not a planner. MLIR/TACO/TVM/COMET require a measured benefit before integration. Update license documentation with exact versioned terms if a dependency is actually introduced.

The 2026 Faingnaert GPU paper, 10.1109/TPDS.2026.3658162, section IV, times FP16 inputs/FP32 accumulation against cuTENSOR 2.0.1. Its FP64 correctness check does not demonstrate FP64 speedups; its GM2 statistic clips losses. The study’s cuTENSOR 2.8.1 snapshot needs installed capability checks and new FP64/complex benchmarks. Nautilus 2026 preprint FP16/FP8 transformer results likewise do not establish chemistry throughput. Oseledets 2011’s primary PDF remains unavailable; TT claims here rely on the acquired survey. TCCG licensing and LibreTT discovery remain unresolved.

Verification and completion¶

The work tracker owns migration coverage. Every implemented family needs semantic, numerical, memory and performance evidence at unchanged method settings. Exact refactoring and approximation changes are separate issue scopes. No backend microbenchmark qualifies a complete method, and no method energy comparison alone qualifies derivatives.

For core semantics test scalars/empty/rank 8 and 12, overflow, reversed and broadcast views, alias refusal/temporary paths, allocation lifetime, complex bilinear versus adjoint products, domain mismatch/revision invalidation, single-pass providers, duplicate assembly, cancellation and allocator failure. Use independent small loops/high precision and exact integer sentinels where appropriate. Test backend limits before narrowing. Memory cases cover exact and just-below caps, concurrent tasks, cache eviction, delayed completion and metadata growth with logical datasets larger than memory.

Benchmark matrix products 16-4096 where feasible, prime/skinny shapes, rank-four and rank-six chemistry tiles, skewed dependent spaces 8-257, clustered/adversarial block sparsity and repeated DAGs (1, 10, 1000 replays). Record actual shapes, source/runtime/dependency/compiler identity, precision, hardware, thread/NUMA/rank placement, packing/conversion/communication, cold planning/compilation/tuning and warm replay, measured high-water tracked bytes and separate RSS. Compare fastest qualified current execution, explicit-pack/GEMM and optional specialized alternatives, including losses. The library study’s median overhead <=10% and unexplained >2x regression flags are pilot hypotheses to calibrate, not measured results or release gates.

Method acceptance uses complete vq calculations and matched ORCA/CRYSTAL when available. Otherwise state justified numerical/literature/limit evidence and remaining uncertainty. Pin tolerances, physical domains, thresholds, references and runtime identity; reuse qualifying results for unchanged paths. Record energies and relevant residuals, states, forces/stress or properties, not only successful process exit. Dev lands focused checked source on main; Validator owns scientific closure and can be the same worker. Runtime delivery and pending science do not prolong finished source work. Ordinary development uses CI skip; full CI remains a release-candidate responsibility.