In video games, randomness is produced by invisible mechanisms — a seed, a pseudo-random generator, a probability table, a server call — whereas in physical games the draw has a visible, contestable “stage”. As soon as a game becomes a competition, and in esports in particular, this opacity ceases to be a mere design question and becomes a question of integrity: who generated the randomness, when, from which source, under which transformation, and with which verifiable guarantees? This paper argues that competitive games and cyber-physical competitions need an explicit randomness infrastructure, distinct from the statistical quality of the entropy source alone. Using the case study Quantum Tetris — a Tetris written in Rust/Bevy/WebAssembly whose stochastic decisions are delegated to simulated quantum circuits — we show that a good entropy source does not guarantee fairness: the bias of the “T” tetromino, induced by a 3-bit-to 7-piece mapping table, arises in the transformation layer and not in the source. We then decompose competitive randomness into six layers (entropy source, extraction, distribution policy, mapping function, cryptographic receipt, audit journal) and discuss the realistic contributions of quantum randomness (QRNG, certification via Bell-inequality violation) as well as the cryptographic tools of auditability (verifiable random functions, randomness beacons, verifiable delay functions, signed journals). We finally propose an architecture applicable to esports, competitive online games and cyber-physical games such as autonomous drone racing, and we implement its auditability layers in Quantum Tetris — hash-chained receipts and a commit-reveal journal — whose overhead we measure: on the order of a microsecond per draw, i.e. practically free auditability for a game of this class.
In video games, randomness is produced by invisible mechanisms — a seed, a pseudo-random generator, a probability table, a server call — whereas in physical games the draw has a visible, contestable “stage”. As soon as a game becomes a competition, and in esports in particular, this opacity ceases to be a mere design question and becomes a question of integrity: who generated the randomness, when, from which source, under which transformation, and with which verifiable guarantees? This paper argues that competitive games and cyber-physical competitions need an explicit randomness infrastructure, distinct from the statistical quality of the entropy source alone. Using the case study Quantum Tetris — a Tetris written in Rust/Bevy/WebAssembly whose stochastic decisions are delegated to simulated quantum circuits — we show that a good entropy source does not guarantee fairness: the bias of the “T” tetromino, induced by a 3-bit-to 7-piece mapping table, arises in the transformation layer and not in the source. We then decompose competitive randomness into six layers (entropy source, extraction, distribution policy, mapping function, cryptographic receipt, audit journal) and discuss the realistic contributions of quantum randomness (QRNG, certification via Bell-inequality violation) as well as the cryptographic tools of auditability (verifiable random functions, randomness beacons, verifiable delay functions, signed journals). We finally propose an architecture applicable to esports, competitive online games and cyber-physical games such as autonomous drone racing, and we implement its auditability layers in Quantum Tetris — hash-chained receipts and a commit-reveal journal — whose overhead we measure: on the order of a microsecond per draw, i.e. practically free auditability for a game of this class.
Randomness is a scarce and precious resource: cryptography, scientific simulation, gambling regulation, and even foundational physics all depend on being able to produce numbers that no one — not even the generator itself — could have predicted in advance. Classical computers cannot create such numbers on their own, because they are deterministic machines; every pseudorandom number generator (PRNG) is, in principle, a fixed algorithm whose entire output is fixed the moment a seed is chosen. Quantum random number generators (QRNGs) promise something categorically different: unpredictability guaranteed by the indeterminism of quantum measurement itself. This paper examines whether “true” randomness is achievable at all, surveys the physical arguments (rooted in Bell's theorem) that quantum measurement outcomes are not merely unknown but undetermined, and then asks a narrower, more computational question: can a machine-learning model tell the difference between the output of a well-designed PRNG and genuine entropy? We built and tested a small experimental pipeline comparing a deliberately flawed linear-congruential generator, a mildly weak variant, two industry-standard PRNGs (Mersenne Twister and PCG64), and operating-system entropy (as an accessible proxy for physically-sourced randomness). Gradient-boosted and logistic-regression classifiers detected the flawed generator with 100% accuracy but could not beat chance (49–51%) against modern PRNGs, mirroring published results in the cryptographic and quantum-optics literature. We conclude that while true randomness is very plausibly achievable through quantum processes certified by Bell-inequality violation, no black-box statistical or machine-learning test — however sophisticated — can, on principle, certify the difference between a good PRNG and true randomness from output alone; the distinction is one of provenance and physical mechanism, not detectable pattern.
Randomness is a necessary ingredient in various computational tasks and especially in Cryptography, yet many existing mechanisms for obtaining randomness suffer from numerous problems. We suggest utilizing the behavior of humans while playing competitive games as an entropy source, in order to enhance the quality of the randomness in the system. This idea has two motivations: (i) results in experimental psychology indicate that humans are able to behave quite randomly when engaged in competitive games in which a mixed strategy is optimal, and (ii) people have an affection for games, and this leads to longer play yielding more entropy overall. While the resulting strings are not perfectly random, we show how to integrate such a game into a robust pseudo-random generator that enjoys backward and forward security.
Physical and quantum random number generators (QRNGs) do not emit uniform bits: detector bias, dead time, after-pulsing, and environmental drift leave their raw output biased, correlated, and partially predictable to an adversary who models the device. Deployable generators therefore include a conditioning (randomness-extraction) stage that distils near-uniform keys from a source of certified min-entropy, and the cryptographic workhorse of that stage is the Leftover Hash Lemma (LHL). This paper analyses two ways in which real deployments depart from the textbook LHL. First, a physical source has no fixed min-entropy: continuous health tests, as standardised in NIST SP 800-90B, produce a runtime lower-bound estimate that varies from block to block and can occasionally be optimistic. Driving the extractor output length from this estimate, we prove an online adaptive extraction theorem whose security bound cleanly composes the estimator soundness error with the extractor error, yielding a (δ+ε)-secure key and separating how often the entropy estimate is optimistic from how uniform the hash output is, as two independently tunable budgets. Second, for settings that publish or reuse the extractor seed — public randomness beacons, reproducible pipelines, and seed-constrained devices — we prove that publishing the seed costs nothing, since this is the defining property of a strong extractor, and that reusing a single seed across m independent source blocks costs at most mε in statistical distance. A corollary bounds the security loss when the extracted key is consumed by a downstream symmetric primitive, and a worked instantiation with realistic QRNG parameters reports the achievable secret-key rate. A reproducible numerical simulation on a synthetic biased source corroborates all four claims. Throughout, we are explicit about the single load-bearing unproven premise — empirical min-entropy certification of the physical device — which belongs to entropy-source validation and lies outside the scope of the analysis.
Random beacons—services that periodically emit public, unpredictable, and unbiasable random values—underpin blockchains, lotteries, sharding, and cryptographic parameter generation. To remove single points of trust, modern beacons are distributed, but they rest on classical hardness assumptions that quantum computers threaten. Quantum random beacons instead draw unpredictability directly from quantum mechanics and are quantum-safe by construction. Existing systems sit at two extremes: single-device protocols based on random circuit sampling trust one quantum server, while device-independent beacons require entangled measurement stations and do not fit the commercial quantum cloud. We present QuoRand, a quantum random beacon that combines m mutually distrusting quantum servers into one publicly verifiable source of certified randomness through a fully distributed classical protocol with no trusted party. QuoRand introduces (1) a Certified-Randomness Oracle (CRO) abstraction that captures RCS-, LWE-, and low-depth-unitary instantiations uniformly, so all guarantees hold independently of the quantum-advantage assumption; (2) a hash-chained challenge derivation that self-bootstraps each round from the previous output, removing the trusted coordinator of prior designs; and (3) a verifiable-delay-function audit lottery, drawn only after all servers commit, that renders any spoofing server accountable while amortizing verification across rounds. We prove QuoRand is unpredictable and bias-resistant under an anytrust assumption—a single honest server suffices—accountable under an honest majority, and live under partial synchrony, and confirm the soundness-cost trade-off with lightweight simulations.
Randomness certification aims to guarantee that the output of an untrusted quantum device contains genuine randomness that remains unpredictable even given quantum side information held by an adversary. For a classical verifier interacting with a single quantum device, such a guarantee cannot rely on the physical separation underlying standard Bell tests and must instead follow from computational restrictions on the prover. Building on the framework of Computational Bell Inequalities, we distinguish classical and quantum virtual-input hiding, showing that the former suffices for proofs of quantumness, whereas the latter enables randomness certification against quantum side information.
Our main technical contribution is to establish quantum virtual-input hiding for a commitment-based protocol derived from the proof of quantumness from one-way-functions by Morimae and Yamakawa. We show that statistical hiding together with ordinary computational binding against quantum polynomial-time senders suffices, without requiring stronger quantum binding notions such as sum-binding or collapse-binding. This yields a randomness-certification protocol from post-quantum statistically hiding bit commitments. In particular, existing constructions of such commitments from post-quantum one-way permutations imply that post-quantum one-way permutations suffice for randomness certification.
We further instantiate our construction using quantum-secure trapdoor claw-free functions, obtaining an efficient classical verifier, and in the quantum random oracle model, obtaining randomness certification without additional computational assumptions but with an inefficient verifier. These instantiations separate the cryptographic properties sufficient for randomness certification from the additional structure required for efficient verification within our commitment-based framework.
Random numbers (RNs) have applications in many areas: lottery games, gambling, computer simulation, and, most importantly, cryptography [N. Gisin et al., Rev. Mod. Phys. 74 (2002) 145]. In cryptography theory, the theoretical security of the system calls for high quality RNs. Therefore, developing methods for producing unpredictable RNs with adequate speed is an attractive topic. Early on, despite the lack of theoretical support, pseudo RNs generated by algorithmic methods performed well and satisfied reasonable statistical requirements. However, as implemented, those pseudorandom sequences were completely determined by mathematical formulas and initial seeds, which cannot introduce extra entropy or information. In these cases, “random” bits are generated that are not at all random. Physical random number generators (RNGs), which, in contrast to algorithmic methods, are based on unpredictable physical random phenomena, have attracted considerable research interest. However, the way that we extract random bits from those physical entropy sources has a large influence on the efficiency and performance of the system. In this manuscript, we will review and discuss several randomness extraction schemes that are based on radiation or photon arrival times. We analyze the robustness, post-processing requirements and, in particular, the extraction efficiency of those methods to aid in the construction of efficient, compact and robust physical RNG systems.