Truth in the Flip Meets Quantum Randomness: First Light from a Quantis QRNG
After years of working with software-generated and cryptographic random sources…
TruthInTheFlip has crossed a new experimental threshold. The project is now receiving its bits from a physical quantum random number generator.
This is not an announcement that quantum randomness has revealed a predictive edge. It is the story of bringing a new instrument online, integrating it into the existing framework, and examining the first substantial record with the same caution that has guided the project’s recent development.
The instrument is an ID Quantique Quantis PCIe New Generation quantum random number generator. Its first serious TruthInTheFlip run reached more than 557 billion flips while sustaining approximately 11.13 million flips per second.
The result did not settle into a dramatic statistical victory. That is important. It produced excursions, including a lifetime rise beyond Z = +2, but ultimately returned close to equilibrium. In doing so, the run gave the project something more foundational than a headline result: a stable physical baseline and a new field for comparison.
From Software Randomness to a Physical Source
TruthInTheFlip began with a simple question:
Can an anticipation strategy perform better than chance over a sufficiently large record of random bits?
Over time, that question became more nuanced. Long tracker runs showed that a temporary statistical peak is not the same thing as a persistent edge. A process may rise impressively, remain above chance for a time, and then settle back toward equilibrium as the record continues to grow.
This led to a broader interpretive vocabulary:
- Excursion describes how strongly a result can rise locally.
- Settlement describes where it tends to finish.
- Persistence describes how durably it remains above or below its baseline.
The next natural step was to change the source of uncertainty itself.
Previous runs used pseudorandom and cryptographic random-number generators. A Quantis device introduces a physical source whose randomness originates in quantum processes measured by dedicated hardware. The tracker, anticipation system, segmentation, and reporting remain the same. The constraint changes.
This makes the Quantis run valuable whether it rises, falls, or remains neutral. It allows TruthInTheFlip to ask whether a physical quantum source produces a coherence profile that differs from software-based sources under the same analytical framework.
Getting the Hardware Online
The installation was not entirely ceremonial.
The card arrived at a pickup location, and I brought it home by Lyft. During installation, I unknowingly displaced some motherboard jumpers and initially received no power from the workstation. Once that was corrected, the hardware came online successfully under Windows.
Windows introduced its own compatibility constraint. The available Quantis Windows driver and library were from version 20.2.4 and provided only a 32-bit native interface, requiring TruthInTheFlip to run through the 32-bit .NET loader on that platform.
Ubuntu presented a different challenge. ID Quantique’s automated Debian packages installed the user library, headers, DKMS source, and device rules, but the kernel driver had not actually been registered and built for the active kernel.
The package appeared installed:
pcie-chip-unix-dkms 24.4-2
quantis-rng-libs-bundle 24.4-2Yet modinfo could not locate the module, lsmod showed nothing, and the native QuantisCount function reported zero devices.
The missing step was to register and build the supplied source through DKMS. Once the module was added, built, installed, and loaded, the driver announced itself:
quantis_chip_pcie v24.4.2
Firmware version: 19.1.1
Serial number: 2542013A710
RNG MODE (qrng_mode:0)The device node appeared as:
/dev/qrandom0At that point, the managed test advanced all the way into the native read path. The hardware, kernel module, native library, and .NET interop layer were finally connected.
The Stable Quantis API Beneath Changing Drivers
The software history initially looked confusing.
The current Linux package was version 24.4.2, while the Windows package was still based on the older 20.2.x line. Online searches often emphasized newer-looking Qrng* APIs and suggested that the older Quantis* entry points represented a legacy product.
A comparison of archived Quantis.h headers showed a more useful reality: the core handle API has remained stable across the available releases.
The common operations are:
QuantisOpen
QuantisReadHandled
QuantisCloseThe simpler QuantisRead function opens the device, performs a read, and closes it again for every request. That is convenient for occasional calls, but TruthInTheFlip is a continuous consumer. A persistent handle is a better match.
The final architecture therefore uses one maintained path:
Open the Quantis device once
↓
Read repeatedly through QuantisReadHandled
↓
Close the handle during shutdownThis provides one lifecycle model across both Windows and Linux and avoids maintaining a second fallback implementation that would need its own testing and failure behavior.
What the Handle Benchmark Revealed
The difference between repeated open-and-close reads and handled reads was measurable.
Using the original non-handled QuantisRead path, small buffers performed as follows:
1 KiB: 0.62 MiB/s
2 KiB: 0.89 MiB/s
4 KiB: 1.34 MiB/sAt 4 KiB and above, throughput remained almost perfectly flat at approximately 1.34 MiB/s. This appeared to be the sustained generation rate of the hardware and driver rather than a limitation of PCIe transport or managed code.
After moving to QuantisReadHandled:
1 KiB: 0.97 MiB/s
2 KiB: 1.49 MiB/s
4 KiB: 1.34 MiB/sThe 1 KiB case improved by approximately 56 percent, and the 2 KiB case improved by approximately 67 percent. Larger reads remained at the same physical throughput ceiling.
This was exactly the expected pattern. Persistent handles do not make the quantum source generate entropy faster, but they remove a significant fixed cost from smaller calls.
The benchmark therefore validated the architectural decision for two reasons:
- Handled reads are measurably better for low-latency and small-buffer use.
- They provide the cleaner long-lived resource model even when larger reads already saturate the device.
When Whitening Became a Random Source
During the integration, I initially expected the Quantis API to provide separate native calls for raw and conditioned output. The installed library did not export the anticipated QuantisReadRaw entry point, and ID Quantique’s extraction layer appeared to be implemented in another library or statically linked component.
That led to a useful simplification.
If the experimental goal is to compare the native stream with a bias-reduced stream, the whitening algorithm does not need to belong inside the Quantis device abstraction. It can be applied to any random source.
The first implemented transform is a classic von Neumann extractor:
00 → discard
11 → discard
01 → 0
10 → 1For an independent source with a stable bit bias, the unequal pairs 01 and 10 occur with equal probability. The retained output therefore removes simple first-order bias, although it does not claim to eliminate arbitrary serial correlation or certify randomness.
The important architectural move was to make whitening a composed random source rather than a Boolean device setting.
The resulting command-line form is:
TruthInTheFlip -rsource Whiten Quantis PCI 0This means:
Whiten(
Quantis("PCI", 0)
)The command is not interpreted through a custom composite identifier. Instead, the registry parser recognizes that the Whiten function accepts another BitFactory and recursively parses the next source expression as its parameter.
The same mechanism allows:
-rsource Whiten NET1
-rsource Whiten NET2
-rsource Whiten Quantis PCI 0This fits the framework better than a Quantis-specific whitening switch. Quantis remains an entropy source. Whitening becomes a general transformation over sources. The command line becomes a small reflected composition language whose structure corresponds directly to function parameters.
One Device, Multiple Entropy Modules
The Quantis card reports one PCIe device but contains two entropy modules. Its installed-module mask is:
0x3In binary, that is 0011, indicating that modules zero and one are present.
During early testing, the functional status sometimes appeared as 0x1 or 0x2 rather than 0x3. The original managed readiness check interpreted this as a fatal condition because it required every installed module to be simultaneously reported as functional.
A review of ID Quantique’s own read logic showed that the vendor library uses a less restrictive condition. It proceeds whenever the functional status is greater than zero—that is, whenever at least one entropy module is available.
The managed check was therefore stricter than the native read contract.
After a complete power cycle, both modules returned online. This also suggested that the device could retain configuration or initialization state across a warm transition between operating systems. A shutdown that does not fully remove PCIe power is not always equivalent to a cold boot.
The revised policy treats zero functional modules as fatal while preserving partial-module status as diagnostic information. For scientific runs, the installed, functional, and power masks can be recorded with the tracker metadata rather than silently ignored.
First Light: 557.2 Billion Quantum-Backed Flips
The first substantial Quantis-backed run reached:
557,200,000,000 flips
wallclock: 13:54:12
throughput: 11,132,363 flips per secondThe heads distribution remained close to equilibrium:
heads: 50 + 5.8e-05%
ZHeads: +0.3690The anticipation result also finished near neutral:
anticipated: 50 + 2.8e-05%
Z: approximately +0.18This is reassuring from an instrumentation perspective. The new physical source ran continuously, the handled interop path remained stable, the tracker maintained its expected throughput, and no obvious gross bias appeared in the heads distribution.
The lifetime path was more interesting than the endpoint.
During the run, the anticipated result reached a maximum Z above +2:
lifetime maxZ: +2.094914
TrueZ near the strongest excursion: +2.028129But the excursion did not persist. The lifetime report ultimately settled almost exactly at equilibrium:
final z: -0.025006
time above 50%: 52.8356%The initial segmented report contained only six segments, so its metrics remain preliminary. Even so, they described the early profile clearly:
Edge Excursion Score: +0.280187
Edge Settlement Score: -0.708360
Edge Persistence Index: -0.366052In plain language, the run was capable of positive local movement, but those movements generally did not survive to the segment endpoints.
This is not evidence of a persistent predictive edge. It is a useful example of why TruthInTheFlip distinguishes excursion from settlement.
Why the Z = 2 Excursion Is Not the Conclusion
A Z value above 1.96 is conventionally notable when it is the outcome of a single precommitted test. A long tracker run is observed repeatedly across many intermediate points. Under repeated observation, eventually crossing a familiar threshold is less surprising than crossing it once at a predetermined endpoint.
This is why a peak cannot carry the interpretation by itself.
TruthInTheFlip now asks several different questions:
- How high did the process rise?
- How often did similar excursions occur?
- Where did the segments settle?
- How much time did the process spend above chance?
- Did the apparent edge become more coherent or less coherent as the record expanded?
The first Quantis record produced an interesting excursion and a neutral settlement. Both facts belong in the interpretation.
The excursion says that local statistical structure appeared.
The settlement says that the larger record did not preserve it.
Neither observation needs to erase the other.
Constraint, Record, and a New Physical Baseline
Within the language of Constraint-Record Coherence, the Quantis integration changes one major term while preserving the others.
- Constraint: uncertainty is now supplied by a dedicated quantum physical source.
- Record: the tracker still preserves every cumulative and segmented result.
- Coherence: excursion, settlement, and persistence still ask what apparent order survives as the record grows.
The project has therefore not changed its interpretive standards to flatter the new instrument. The Quantis run is read through the same discipline applied to cryptographic and software-generated sources.
A physical source does not make every excursion profound. It makes the comparison deeper.
The first Quantis record now serves as a baseline against which several future experiments can be compared:
Quantis PCI 0
Whiten Quantis PCI 0
NET2
Whiten NET2The comparison need not be limited to final Z values. Different sources may exhibit different profiles of local excursion, segment settlement, persistence, conditional bias, or variance even when all of them ultimately remain consistent with chance.
That comparative profile may become one of the most valuable products of the experiment.
What This Does Not Claim
This first Quantis run does not prove that quantum randomness can be predicted.
It does not establish a durable advantage over chance.
It does not show that cryptographic or quantum random-number generation is broken.
It does not treat a temporary Z = 2 excursion as a final result.
It also does not assume that native Quantis output is completely unprocessed physical entropy. The card and firmware may perform health checking, conditioning, or other internal operations before bytes reach the public API. For that reason, the project currently uses the careful description native Quantis output rather than claiming access to a preconditioned raw quantum signal.
What the run does establish is more modest and more durable:
- The Quantis PCIe hardware is functioning under both Windows and Linux.
- The managed interop layer can consume it through a stable historical handle API.
- The tracker can sustain more than 11 million flips per second from the physical source.
- Random sources can now be recursively composed through the command-line registry.
- Von Neumann extraction is available as a general source transformation.
- The first large Quantis record provides a neutral and technically stable physical baseline.
The Instrument Is Online
TruthInTheFlip had reached a horizon where the next question required new instrumentation.
The instrument is now online.
Its first substantial record did not announce a victory. It showed a balanced heads stream, a stable hardware and software path, an interesting local excursion, and a settlement near equilibrium.
That is not a disappointing first result. It is a disciplined one.
The project now has a physical quantum source, a reusable whitening transform, a recursively composable source registry, and a new baseline from which longer comparisons can grow.
The first light from the Quantis did not reveal a final answer. It illuminated the next field of questions.
The code and continuing experiment are available in the public TruthInTheFlip repository: