IID-based QPP-RNG: Quantum Permutation Pad RNG

• IID-based QPP-RNG is a quantum-inspired, cryptographically robust random number generator that combines deterministic permutation sorting with hardware jitter to produce IID uniform outputs.
• It converts heavy-tailed distributions from permutation counts and sorting times into uniform outputs using modular reduction, ensuring nearly identical distribution across cycles.
• Dynamic seed evolution via system jitter guarantees forward secrecy and robust entropy, with empirical benchmarks demonstrating near-maximal Shannon entropy and post-quantum security.

An IID-based QPP-RNG (Quantum Permutation Pad Random Number Generator) is a cryptographically robust random number generator achieving independent and identically distributed (IID), provably uniform random outputs by synthesizing combinatorial complexity via random permutation sorting and harnessing microarchitectural system jitter as an entropy source. This class of generators formalizes a quantum-inspired paradigm in which algorithmically deterministic structures and irreducible hardware unpredictability are mathematically unified. The operating principle centers on (i) two conjugate observables—permutation count and sorting time—whose raw, heavy-tailed distributions are mapped to uniform outputs via modular reduction, and (ii) dynamic seed evolution, where system jitter continually re-randomizes the internal generator state, decoupling output sequences from initial conditions (Kuang, 12 Sep 2025, Kuang et al., 25 Feb 2025, Kuang, 1 Aug 2025).

1. Theoretical Foundations: Conjugate Observables and Quantum Permutation Pads

The QPP-RNG exploits the quantum-inspired Random Permutation Sorting System (RPSS), whose state is specified by a pair of non-commuting observables:

• Permutation count ($N_p$): Number of random permutations applied until a target configuration is achieved (specifically, the $m$-th “success” wherein applied permutations invert the unknown target permutation).
• Elapsed sorting time ($T$): Wall-clock time to perform the $N_p$ permutations, accumulating system jitter effects.

The distributions governing these observables are:

• $N_p$ follows a negative-binomial law,

$$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$

In the $M \gg 1$ regime, this approaches an exponential distribution, $E[N_p] \sim M$.

• $T$ is a sum of $N_p$ i.i.d. samples of permutation execution times ($m$0), capturing system-dependent microarchitectural noise:

$m$1

The joint state-vector exhibits a formal analogy to quantum superposition, with the marginals $m$2 and $m$3 linked via an uncertainty-like tradeoff—fixing one maximizes variance in the other (Kuang, 12 Sep 2025, Kuang, 1 Aug 2025).

The Quantum Permutation Pad (QPP) leverages the combinatorial entropy inherent in the symmetric group $m$4 of $m$5 distinct $m$6-bit permutation matrices, yielding entropy $m$7 (Kuang et al., 2023). This ensures extremely high entropy for moderate $m$8.

2. Modular Reduction: From Heavy-Tailed to Uniform Distributions

Both $m$9 and $T$0 possess right-skewed, heavy-tailed distributions due to the underlying combinatorial landscape and stochasticity of system execution. Uniform output is achieved via modular reduction:

• $T$1, $T$2, with $T$3.
• The composite extractor outputs $T$4.

Uniformity arises from the degeneracy of the modular map: each raw value $T$5 is folded modulo $T$6, with the number of preimages of each residue guaranteed to be nearly equal for $T$7 by theorems:

• Theorem 1: For $T$8 with mean $T$9, $N_p$0.
• Theorem 2: If $N_p$1 is a sum of i.i.d. nonlattice times and $N_p$2, $N_p$3.

Thus, $N_p$4 is within $N_p$5 of being uniform (Kuang, 12 Sep 2025). Internal degeneracies from the factorial search space ensure effective flattening of output histograms (Kuang, 1 Aug 2025).

3. Proof of IID Uniformity and Empirical Validation

The IID-based QPP-RNG achieves strict independence and identical distribution via two mechanisms:

• Per-cycle uniformity: The modular reduction of heavy-tailed observables yields outputs indistinguishable from uniform. For each cycle $N_p$6, $N_p$7 up to negligible discrepancies ($N_p$8).
• Inter-cycle decorrelation: Each round, the LCG/QPP-GEN seed is refreshed using jitter-derived residues (typically $N_p$9 or $N_p$0), rapidly washing out memory of any initial state. The design accommodates both software-only cycling and integration with true or hardware-based entropy (Kuang, 12 Sep 2025, Kuang et al., 25 Feb 2025).

Empirical benchmarks, including NIST SP 800-90B min-entropy and Shannon entropy assessments, demonstrate output qualities:

Mode	Shannon Entropy (bits/byte)	Min-Entropy (bits/byte)	$N_p$1 Statistic (ideal 256)
QPP-RNG ($N_p$2)	$N_p$3–$N_p$4	$N_p$5–$N_p$6	$N_p$7 250–280
ID Quantique QRNG	—	$N_p$8	—

IID-based QPP-RNG passes all NIST SP 800-90B/22 and ENT suites under desktop and mobile environments, with autocorrelation and spectral coefficients vanishing ($N_p$9), confirming no detectable statistical dependencies (Kuang et al., 25 Feb 2025, Kuang, 1 Aug 2025).

4. Implementation Protocols and System Jitter Integration

Practical realization is fully software-based:

1. Initialization: Seed an LCG (or fast PRNG) using a pool (e.g., $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$0 bits) of measured system jitter bytes, such as $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$1 for eight consecutive sorting cycles (Kuang et al., 25 Feb 2025).
2. Ephemeral QPP Pad Generation: Use the seeded LCG to drive Fisher–Yates shuffles on $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$2-element arrays, producing secret permutations per round.
3. Sorting and Output Extraction: In each round, permutation sorting is repeated $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$3 times (searching for $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$4-th inverse success). The permutation count $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$5 is taken, and the output is $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$6.
4. Dynamic Jitter Reseeding: Each round, the observed $$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$7 is incorporated into the seed via

$$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$8

ensuring fresh entropy injection.

The architecture is robust to adversarial attempts at seed prediction and attacks exploiting initial deterministic bias, as the re-randomization protocol ensures rapid loss of seed state memory and forward secrecy (Kuang et al., 25 Feb 2025).

Microarchitectural jitter contributions originate from sources such as CPU pipeline turbulence, cache and DRAM accesses, frequency scaling, IRQs, context switches, and are measured at nanosecond (or finer) granularity (Kuang, 12 Sep 2025, Kuang et al., 25 Feb 2025).

5. Statistical and Security Properties

The entropy bottleneck is eliminated by (i) the factorial scaling of QPP pad space ($$\Pr[N_p = k] = \binom{k-1}{m-1} (1-p)^{k-m} p^m, \text{ with } p = 1/M, M = m\cdot N!$$9), (ii) the uniformization properties of modular reduction, and (iii) continuous hardware entropy injection. Distinct advantages include:

• Fast entropy convergence: Empirical uniformity is attained once $M \gg 1$0; e.g., $M \gg 1$1 (Kuang, 12 Sep 2025, Kuang, 1 Aug 2025).
• High entropy per byte: Empirical min-entropy ($M \gg 1$2–$M \gg 1$3 bits) exceeds that of commercial quantum RNGs, with Shannon entropy ($M \gg 1$4) near theoretical maximality.
• Platform independence: Uniformity and independence properties are verified on multiple x86 and ARM platforms, including different OS and timing granularities.
• Post-quantum security: An $M \gg 1$5-bit QPP pad provides a key space of $M \gg 1$6; Grover-type quantum search does not apply due to the combinatorial explosion of possible pads, and permutation-pad recovery is intractable for Shor-class algorithms (Kuang et al., 25 Feb 2025, Kuang et al., 2023).

IID-based QPP-RNG is suitable for session key generation, quantum-safe nonce construction, seeding of higher-level CSPRNGs, and entropy boosting or whitening for hardware or quantum RNGs (Kuang et al., 2023).

6. Design Recommendations and Typical Performance

Implementation guidelines to ensure provable IID uniformity:

• Select $M \gg 1$7 and $M \gg 1$8 such that $M \gg 1$9.
• Employ high-resolution timers capable of capturing low-level jitter.
• Use modular reduction for both $E[N_p] \sim M$0 and $E[N_p] \sim M$1; their combination further boosts output flatness.
• Maintain dynamic seed evolution by incorporating observed jitter into PRNG seeds each cycle.

Achievable throughput is high—modern CPUs exceed $E[N_p] \sim M$2 GB/s, as each output byte requires only a shuffle, modulo computation, and a seed update.

The unique use of permutation group structure and dynamic system noise establishes a new class of software-only, physics-grounded RNGs, bridging quantum-mechanical concepts and practical entropy extraction without the need for dedicated quantum hardware (Kuang, 12 Sep 2025, Kuang et al., 25 Feb 2025, Kuang, 1 Aug 2025, Kuang et al., 2023).