Skip to main content
Back to research

An open, ontology-grounded benchmark for quantum collateral optimisation, with every allocation certified twice

Published 29 August 2026.

Repository on GitHub (opens in new tab)

Banks and other financial institutions satisfy their margin, settlement and funding commitments by posting assets that vary across class, currency, issuer and liquidity. Deciding which piece of collateral should back which commitment, subject to eligibility schedules, no-reuse controls, exact coverage requirements and issuer concentration limits, is a combinatorial problem that arises again and again, and it ranks among the workloads most frequently put forward for near-term quantum optimisation. We created Qollateral, an open benchmark that places the rule book at the heart of that proposal instead of treating it as an afterthought, and we released every number it generates alongside the machinery needed to recompute them.

1.0290

approximation ratio on ibm_kingston, matching the noiseless simulator

0.0034 s

slowest CP-SAT proof of optimality across the grid

20 of 24

QAOA runs returning a certified feasible sample

2.09x

qubits the generic route needs for the same optimum

The failure mode that motivated the build

A hybrid quantum pipeline expresses its business constraints in two places. One encoding sits in the penalty terms of the quadratic unconstrained binary optimisation problem fed to the quantum routine, and the other sits in the classical checker that validates whatever comes back. If people hand-write both encodings from the same prose rule book, a single misunderstanding can live in both, and validation then approves results that are wrong. In earlier register work we observed a dual-computation gate approve figures that were off by a factor of 3.6, since both computation paths had absorbed the same misreading of a source vocabulary. The broader lesson is this: when two implementations agree, what has been checked is the implementation, not the semantics.

One rule book, compiled to both routes

Qollateral eliminates that failure mode by construction. The rule book exists as data, expressed in Turtle under CERO, the Collateral Eligibility Rule Ontology. Each rule states whether it permits an exact quadratic encoding and which algebraic form such an encoding would take, and those encoding forms appear as concepts in a SKOS scheme that records their algebra as data. One compiler consumes the rule book and emits a CP-SAT integer model. A second compiler consumes the same rule book and emits the QUBO. Any rule lacking an exact quadratic encoding is refused at load time. The concentration rule illustrates how this works: a limit of one unit per issuer per obligation compiles exactly into a pairwise penalty, whereas a limit of two possesses no exact quadratic form without auxiliary variables, so a rule book asserting that combination gets rejected before any solver ever runs.

Certification is therefore independent, and it happens twice. A Python certifier re-derives whether every proposed allocation is feasible straight from raw asset and obligation attributes, without referring to either compiler. Independently, each solver run is written out as reified allocation assertions in RDF, and SHACL shapes re-derive the identical verdict from the graph, with one shape per defect class covering double pledge, coverage mismatch, concentration breach and ineligible assignment. A verification script demands that the two verdicts agree on every run and exits non-zero whenever they do not. Eligibility itself gets derived in three ways: by the pruner, by the emitted graph edges, and by a SPARQL query over raw attributes.

What the measurements show

Across the seeded grid of eight instances spanning 8 to 20 binary variables, CP-SAT proved every optimum in no more than 0.0034 seconds. QAOA, executed at depths one to three on a noiseless simulator, with parameters optimised against exact statevector expectations and solutions obtained by sampling transpiled circuits, delivered a certified feasible best sample in 20 of 24 runs and sampled the exact optimum in 11. Four runs yielded no feasible sample whatsoever, and the SHACL layer flagged precisely those four, in full agreement with the Python certifier, working on live solver output rather than a constructed test case.

Share of 4,096 sampled shots that land on a feasible allocation, depth 3
8 variables, depth 3
0.1904
9 variables, depth 3
0.2231
11 variables, depth 3
0.0464
15 variables, depth 3
0.0002
19 variables, depth 3
0.0000
20 variables, depth 3
0.0024

Bars are scaled by feasibility mass in units of one ten-thousandth. The 19 variable instance returned no feasible sample at depth 3, shown at the axis minimum. Feasible states are rare by construction: the 20 variable instance has 66 feasible assignments among 1,048,576.

The sampled feasibility mass dropped from 0.19 at 8 variables down to 0.0002 at 19, whereas routed circuit depth climbed from 43 to 663 and the two-qubit gate count from 42 to 1,873. At 20 variables the QAOA route consumed 330 seconds of wall clock, compared with 0.003 seconds for CP-SAT. Depth and gate counts are measured following transpilation onto a linear coupling map and a native-style basis, which makes them routed numbers rather than abstract circuit counts.

Transpiled two-qubit gate count at depth 3, with wall clock alongside
8 variables: depth 111, 138 two-qubit gates
0.7 s
12 variables: depth 340, 703 two-qubit gates
1.8 s
15 variables: depth 455, 907 two-qubit gates
6.2 s
19 variables: depth 652, 1,778 two-qubit gates
80.0 s
20 variables: depth 663, 1,873 two-qubit gates
330.2 s

Bars show two-qubit gate count after routing to a linear coupling map. Labels show the wall clock of the full depth-3 run, including classical parameter optimisation. CP-SAT solved every one of these instances in under 0.0034 seconds.

The first run on real hardware

On 29 August 2026, version 0.1 of this benchmark executed a nine variable instance on ibm_kingston, an IBM Heron device with 156 qubits, at depth 1 using 2048 shots. Because the parameters had been optimised on the simulator in advance, the processor was used for sampling alone and no variational loop was run against the hardware. The samples returned were processed by the identical Python certifier and the identical SHACL layer 3 shapes applied to every simulator run in this study, and they passed both. That is the headline result and it deserves stating first: the certification path functions end to end on genuine device output, not merely on output we produced ourselves.

On the hardware, the approximation ratio came to 1.0290, exactly matching the noiseless simulator on the same instance, while the sampled feasibility mass reached 0.1079 compared with the simulator's 0.1204. At depth 1, neither run located the exact optimum, a fact the simulator sweep had already established for this instance. What one instance at one depth on one device demonstrates is that the pipeline executes and certifies correctly on real hardware. It demonstrates nothing concerning scaling under noise, and we advance no claim of that kind.

The more transferable finding is the routing comparison, since it contradicts a widely held assumption. When transpiled against the actual heavy-hex coupling map at optimisation level 3, the circuit requires 1.64 times the depth yet only 0.81 times the two qubit gates of the linear coupling map estimate relied upon throughout the simulator study. A linear map is consequently not a conservative proxy in both directions simultaneously: it inflates the entangling gate count while understating depth. Any resource estimate quoted from an idealised topology ought to state which of the two it is optimistic about, as that answer decides whether the circuit fits within a coherence budget or a gate error budget.

Same instance, same depth: real device against the noiseless simulator
Noiseless simulator, feasibility mass
0.1204
ibm_kingston (156 qubit Heron), feasibility mass
0.1079

Instance v9-s2-a14 at depth 1. Feasibility mass is the share of shots landing on a feasible allocation, shown here in units of one ten-thousandth. Both runs were certified by the Python certifier and by SHACL layer 3.

The agreement battery

Outside the grid, an agreement battery swept 120 cells over two rule books, four sizes and fifteen seeds. Across the 98 cells where a feasible instance exists, it detected zero disagreements on any of four properties: the unconstrained QUBO ground state equals the constrained optimum, CP-SAT equals exhaustive enumeration, the CP-SAT solution passes the independent certifier, and the lowest infeasible QUBO energy lies strictly above the highest feasible objective, with a minimum observed separation of 27 cost units. The other 22 cells admit no feasible instance for that combination of size and seed, a fact that is recorded rather than quietly dropped. The second rule book departs from the first in exactly one Turtle value, requiring a currency match in eligibility, and both compilers absorb that change together with no code edit.

What the declaration buys, measured against a general purpose converter

The obvious objection runs like this: a general purpose converter already transforms constraints into a QUBO, so declaring encodability inside an ontology adds ceremony and nothing more. We put that to the test directly. The same problem was constructed as a Qiskit QuadraticProgram and converted with qiskit-optimization's own converters, over fifteen instances spanning five seeds and three sizes. Every Qiskit route is correct on every instance: its QUBO ground state is the constrained optimum each time. What differs is the qubit cost, and whether that cost becomes visible before the model is built.

Qubits needed for the same optimum, relative to the declared exact encoding
Declared exact encoding (this compiler)
baseline
Absorb what fits, slack for the rest
1.43x qubits
Slack variables throughout
2.09x qubits

Median across 15 instances at a concentration bound of one, measured with qiskit-optimization 0.7.0 and pinned by regression test. The slack route ranges from 1.67 to 2.29 times the declared encoding. All routes return the same optimum; on near-term hardware a factor of two in qubits is the difference between runnable and not runnable.

The converter also confirms the declaration itself, which is the more useful half of the result. We count per constraint instead of per instance, since an instance that happens to carry no concentration constraint would otherwise register as a vacuous success: all 46 non-trivial concentration constraints at a bound of one are absorbed into the quadratic penalty with no auxiliary variables. At a bound of two, none of the 11 are, because the converter leaves every one of them for the slack route. That is precisely the boundary the ontology declares, arrived at independently by a tool that has never seen our rule book. Our compiler refuses that rule book at load time instead of discovering the problem downstream, and regression tests pin both regimes.

The baseline a hardware claim now has to clear

At these sizes the classical routes dominate on every measure, and that is the useful result. Advantage, parity, non-competitiveness and uncertainty are each valid outcomes of a fair comparison, and a benchmark able to report only the first of these is not a benchmark. What this one contributes is the frozen protocol: exact compilation of both routes from one rule book, doubled certification, and per-run resource accounting that covers qubits, routed depth, two-qubit gates, shots, optimiser evaluations and wall clock. Any future hardware claim on this workload now has a stated baseline to beat and a stated cost at which to beat it.

Prior art, and the gap

The prior art is real and we credit it. Giron, Korpas, Parvaiz, Malik and Aspman formulated collateral optimisation as MILP and QUBO for NISQ and quantum-inspired computing in IEEE Transactions on Quantum Engineering in 2023. Jin and Florescu published a higher-order QAOA framework for CSA and margin-aware collateral in 2026, featuring a deterministic CP-SAT solver that certifies candidate actions before recommendation, and the concept of a classical arbiter over quantum candidates belongs to them. What Qollateral adds, to the best of our knowledge, is the combination: the rule book as ontology data with per-rule declared encodability, one source compiled to both solver routes, an independent SHACL certification path over reified allocation assertions, and a fully open seeded benchmark whose every headline is computed two ways. We welcome corrections to that claim as repository issues.

Where the method transfers

Every hybrid optimisation pipeline whose constraints originate in a governed document faces this same double-encoding failure mode. Network capacity rules, rostering agreements and grid dispatch limits all share the same shape, and the same remedy applies: render the rule book machine readable, declare encodability rule by rule, compile every route from the one source, and certify results along a path that consulted none of the compilers. The ontology, the shapes, the compilers and the battery all live in the repository under open licences, and the whole result set regenerates from seeds with two commands.

Scope and method

Apart from the ibm_kingston run described above, every figure here is a simulator figure, and parameter optimisation is noiseless throughout, including for that run. The instances are synthetic and sized to allow exhaustive ground truth, which is the design decision that turns route agreement from an assertion into a tested property: with every assignment enumerable, the claim that the QUBO ground state is the constrained optimum gets checked rather than argued. The cost model is a cheapest-to-deliver proxy constructed from liquidity band, currency mismatch and issuer spread. From here the roadmap covers hardware execution of the smallest instances under the same doubled certification, constraint-preserving mixers and warm starts on the quantum side, auxiliary-variable encodings for concentration bounds above one, and an anonymised historical workload with a named data owner.

A bounded first engagement

For a treasury, clearing or collateral technology team, the bounded exercise takes two weeks: formalise one eligibility schedule as a CERO rule book, compile it to your existing optimiser and to a QUBO, and run the agreement battery against your current allocations. What you get back is a machine-readable rule book you own, a defect list wherever the encodings disagree with practice, and a frozen benchmark protocol that any later quantum claim has to clear. Enquiries to fabio@thetesseractacademy.com.