Quantum honesty: the I-Ching × quantum RNG algorithm.

On ezagor.com, the catalog mentions an I-Ching × Quantum honesty algorithm — "a honesty algorithm for wheels of fortune that want to prove they don't lie." I've been refining this design for several years and shipped pieces of it across small RNG-dependent systems I've operated quietly. This is the first time I'm writing it up in one place. It is not, today, a GOGOGO LLC product — it sits on the ezagor handle, in the long catalog of things that got built in the dark.

The problem it solves is real, though, and I think the design is worth publishing. Provably-fair RNG matters anywhere you have outcomes whose value depends on the audience trusting the randomness — gambling, raffles, NFT mints, content recommendation slot-filling, A/B test assignment with adversarial stakes.

Why classical PRNG isn't enough

Classical pseudo-random number generators are deterministic. Given the seed, the entire stream is reproducible. The standard "provably fair" trick is to commit to a hashed seed before the round, reveal the seed after, and let the player verify. The audit works mathematically. It does not work emotionally — most players have no idea what a hash is and are being asked to trust the operator regardless.

What I wanted instead was randomness that:

1. Is non-deterministic at source. Not derivable from a seed, even in principle. Hardware quantum gives you this.
2. Is independently verifiable. A second observer can derive a matching result from a separate quantum source plus public ceremony state.
3. Has a symbolic surface. The result is also a reading — a hexagram with meaning — not just a bare integer. This is the part that lets non-technical users feel they understand what happened, even if they don't understand quantum mechanics.

The I-Ching observation

The I-Ching is a 4,000-year-old divination system built around 64 hexagrams (六十四卦). Each hexagram is six stacked binary lines — yin (broken) or yang (solid). 2⁶ = 64. The system is, mechanically, a uniform sample over a 6-bit space. The classical method is throwing yarrow stalks or coins six times.

Two properties make it useful for our purpose. First, the underlying mechanism is binary randomness — exactly what hardware quantum sources produce natively. Second, each of the 64 outcomes has 4,000 years of accumulated commentary attached to it. The result is not just an integer between 1 and 64; it is also a poem and a piece of advice. That is the symbolic surface most players need to feel that randomness has spoken, not just been generated.

The algorithm, in one paragraph

For each round: (1) the operator publishes a salt — usually a hash of the round identifier plus the participant list. (2) The operator queries a hardware quantum random source for 6 bits of entropy. (3) The 6 bits are XOR-mixed with the salt's first 6 bits. (4) The resulting 6-bit string is mapped onto the I-Ching hexagram table (with a canonical ordering — King Wen sequence is the standard). (5) The hexagram number becomes the round's raw result. The operator publishes the raw quantum bytes from the QRNG provider plus the salt. The participant can verify the XOR-mix and the hexagram mapping independently. The hexagram's traditional commentary becomes the round's narrative surface.

Where you get the quantum bits

Hardware QRNG providers exist as a commodity in 2026. Quantinuum, IDQ, ANU's quantum-numbers service, AWS Braket's QRNG endpoint, and several others publish high-rate (~Mbps) quantum streams via TLS APIs. Most are cheap. The provider's job is to give you signed, audited entropy; the operator's job is to combine it with the public salt and map it via the canonical table.

For decentralized settings, you can also use distributed beacon protocols — drand, the League of Entropy — that produce verifiable random bytes from threshold signatures. The same algorithm applies; just substitute the hardware QRNG step with a drand round.

Why this isn't a toy

Three real properties this design has that ordinary provably-fair RNG doesn't:

Property 1 — Statistical uniformity

Hardware QRNG plus salt-XOR produces a uniform distribution over 64 outcomes. We've run hundreds of thousands of rounds through this pipeline (small private deployments) and the chi-squared test on outcome frequency stays inside its 95% confidence band consistently. The randomness is real, not just claimed.

Property 2 — Audit transparency

Every round publishes (salt, raw quantum bytes, hexagram). Any participant can independently reproduce the mapping with a single XOR and a lookup. No proprietary algorithm to trust. The audit is doable from a phone.

Property 3 — Symbolic legibility

This is the part that distinguishes it from regular cryptographic RNG and the part that gets dismissed by engineers. The result is a named pattern with traditional commentary. Players don't experience it as a number — they experience it as a reading. That changes what "fairness" feels like, even though mechanically nothing has changed. The symbolic surface is the user interface for honesty.

What this is good for, and what it isn't

Good fits: small-stakes games of chance with culturally engaged audiences; NFT trait assignment where the result wants narrative; lottery / raffle systems; ceremonial randomness; ML A/B assignment with public audit needs. Bad fits: extremely high-stakes financial randomness where the symbolic surface would be misread as predictive (people will interpret the hexagrams; this is a feature for ceremony and a bug for finance); cryptographic key generation (use proper KMS); cases where the audience genuinely doesn't want randomness.

“Cryptographic randomness solved the mathematical problem of trust decades ago. It didn't solve the emotional one. Layering symbolic interpretability on top of provable randomness doesn't change the math. It changes how the math is felt. For games of chance that's the whole game.”

Why I'm writing this now

I built versions of this for personal projects, friend operators, and one small consortium over the years. It's the kind of work that lives on the ezagor handle — the shadow stage — not on GOGOGO LLC's product page. But the algorithm is small enough and the use-case is real enough that I want it documented somewhere a teammate or a customer could find it.

If you want to discuss provably-fair RNG, hexagram-mapping edge cases, or quantum-source selection, I'm easy to reach. atakanozalan.com or ezagor for the handle.