---
title: 'QPP-RNG: Quadratic Permutation Polynomial RNG'
url: https://www.emergentmind.com/topics/qpp-rng
type: topic
---

# QPP-RNG: Quadratic Permutation Polynomial RNG

QPP-RNG (Quadratic Permutation Polynomial Random Number Generator) refers to a family of methodologies and systems that harness the mathematical properties of permutation polynomials—particularly quadratic permutation polynomials (QPP)—to engineer uniform, high-entropy, and cryptographically robust random number generators. QPP-RNG spans both deterministic and quantum (or quantum-inspired) implementations, uniting algorithmic determinism with physical system-level unpredictability for secure random number generation in error-correcting codes, cryptography, and post-quantum systems.

## 1. Mathematical Foundation: Quadratic Permutation Polynomials in Randomization

QPPs are permutation polynomials defined over finite integer rings, commonly given by
$$
T(x) = (q_1 x + q_2 x^2) \bmod L, \quad x \in \{0, \ldots, L-1\}
$$
with integer coefficients $q_1, q_2$ selected so that $T(x)$ is a permutation of the index set. These polynomials are bijective, non-linear mappings that efficiently scramble sequences, making them ideal for generating random permutations required in applications such as turbo code interleaving, cryptographic padding, and entropy amplification [1203.1410], [2303.01315], [2402.01852].

In RNG constructions, QPP enables:
- Large permutation spaces: For $n$-bit systems, the permutation space is $2^n!$, vastly exceeding the $2^n$ state space of Boolean RNGs.
- Shannon entropy scaling as $e \approx 2^n (n - 0.42)$ bits for large $n$, providing strong resistance to brute-force attacks via factorial keyspace expansion [2303.01315], [2402.01852].

## 2. QPP-based Interleaving and RNG in Communication Systems

In turbo coding and error correction, QPP-RNG's primary role is to construct interleavers with highly optimized distance spectra. The methodology, as detailed in [1203.1410], includes:

- Candidate grouping: By leveraging the property that QPPs and their inverses often produce identical distance spectra, the algorithm reduces redundant computations by evaluating only one spectrum per group.
- Early spectrum termination: The method incrementally updates the first $M$ terms of the distance spectrum and computes truncated upper bounds (TUB) on frame error rate (FER) at each stage:
  $$
  \text{TUB(FER)} = \sum_{i=1}^{M} N_i \exp\left(-\frac{d_i E_b}{N_0}\right)
  $$
  Search is pruned if a candidate cannot improve the current best known FER.
- Interleaver classes: The search covers largest spread QPP (LS-QPP), LTE-compliant QPP (DLTE-QPP), and exhaustive QPPs up to $L = 1008$.

Empirical results demonstrate that LS-QPP interleavers deliver superior or equivalent FER performance compared to LTE standards for short lengths. For longer codewords ($L \geq 624$), DLTE-QPPs are preferable, balancing spread parameter $D$ and multiplicity to optimize FER [1203.1410].

## 3. QPP-RNG as a Cryptographic and Quantum Entropy Primitive

The Quantum Permutation Pad (QPP) paradigm extends QPP-RNG uses to cryptographic random number generation and key encapsulation in both classical and quantum regimes. Key properties and operations include:

- Pad construction: QPP pads are assembled as arrays of permutation matrices, typically built via classical algorithms (e.g., Fisher–Yates shuffle) seeded by high-entropy inputs [2303.01315]. In quantum-native setups, pads are mapped to unitary permutation operators acting over $n$-qubit spaces [2402.01852].
- Symmetric encryption: For an $n$-bit plaintext $m$, encryption applies the pad via
  $$
  \widehat{W}_i |m\rangle = |c\rangle
  $$
  Decryption uses the pad's inverse.
- Integration in homomorphic polynomial public-key (HPPK) and key encapsulation (KEM): QPP pads are used to symmetrically permute polynomial coefficients, hiding the mathematical structure of public keys and allowing KEM/DS protocols robust to quantum attacks [2402.01852].

High entropy (e.g., 64 permutation matrices over 8 bits yielding $>10^5$ bits of entropy per pad) and inherent non-commutative confusion due to Galois Permutation Group operations enforce quantum-level secrecy and resistance to algebraic attacks [2402.01852].

## 4. Physical and Hybrid System Implementations: QPP-RNG and System Jitter

Recent QPP-RNG designs exploit the interaction between algorithmic determinism and physical system fluctuations, epitomized by the Quasi-Superposition Quantum-inspired System (QSQS) [2508.01051] and IID-based QPP-RNG [2502.18609]:

- Two conjugate observables: permutation count $n_p$ (deterministic, modulo-reduced) and sorting time $t$ (measured real-time, subject to microarchitectural noise).
- Uncertainty-like constraint: $[ \hat{N}_p, \hat{T}_p ] \neq 0$ reflects the non-commutation akin to quantum observables, ensuring that repeated measurement collapses different internal states to a uniform output.
- Entropy amplification: Internal degeneracies ensure that despite right-skewed raw distributions for $n_p$ and $t$, their reduced forms ($n_p \bmod 2^n, t \bmod 2^n$) empirically approach uniformity for moderate $m$ (cycle repetition factor), yielding Shannon/min-entropy $\to 8$ bits and $\chi^2$ statistics near theoretical uniform values [2508.01051].
- Dynamic reseeding: Real-time measurements of $t$ dynamically reseed the PRNG driving the permutation process, decoupling the generator's state from any fixed seed and accumulating entropy from hardware-level jitter [2502.18609], [2508.01051].

This approach enables software-only, high-quality, post-quantum secure randomness generation without the need for physical QRNG circuitry.

## 5. Entropy, Statistical Validation, and Uniformity Properties

QPP-RNG systems are validated using rigorous statistical tests:

- Shannon entropy and NIST SP 800-90B min-entropy converge to 7.99–8.0 bits/byte for high $m$ [2502.18609], [2508.01051].
- Output distributions demonstrate $\chi^2$ values and standard deviations (e.g., $\sigma \approx 63.6$ for $2^{20}$-byte samples over 256 bins) indistinguishable from theoretical uniformity.
- IID properties: Empirically, system outputs consistently pass NIST, Dieharder, and ENT tests, outperforming hardware QRNGs such as ID Quantique in both min-entropy and uniformity [2502.18609].

A summary of empirical metrics (for $n=8$ bits, $m \geq 4$) is as follows:

| Metric                  | Value (QPP-RNG, $m=4$) | Theoretical Uniform |
|-------------------------|------------------------|--------------------|
| Shannon Entropy         | 7.9998 bits            | 8.0 bits           |
| NIST SP 800-90B Min-Ent | 7.92–7.93 bits         | 8.0 bits           |
| Chi-squared $\chi^2$    | 250–300                | 255.0              |
| Std Dev (per bin)       | 63–65                  | 63.6               |

The min-entropy per byte in IID-based QPP-RNG (7.85–7.95 bits) exceeds leading commercial QRNGs (e.g., 7.16 bits for ID Quantique) [2502.18609].

## 6. Applications and Cryptographic Implications

QPP-RNG methods support a range of modern cryptographic applications:

- Turbo code interleaver design in wireless and error-correcting coding: Enabling robust turbo code construction in LTE and next-generation standards by optimized, low-complexity QPP interleaver searches [1203.1410].
- Symmetric-key encryption, key encapsulation, and digital signatures: Quantum permutation pads act as high-entropy, non-commutative OTPs, providing Shannon secrecy extended to quantum settings and resilience to algebraic or quantum attacks [2303.01315], [2402.01852].
- Post-quantum cryptography: Software-only QPP-RNG implementations (e.g., IID-based QPP-RNG, hybrid QSQS) deliver platform-agnostic, embedded randomness for post-quantum key generation, minimizing reliance on external or hardware entropy sources [2502.18609], [2508.01051].
- Hardware and OS-level randomness: QPP-RNG schemes are suitable for inclusion in OS kernels, embedded devices, and as entropy boosters/whiteners for physical RNGs.

## 7. Future Directions and Broader Context

Prospective research avenues indicated in the literature include:

- Scaling QPP and QSQS models to large $n$ for maximal scalability while preserving statistical uniformity and entropy convergence [2508.01051].
- Integration into homomorphic public key, key encapsulation, and hybrid quantum-classical cryptographic frameworks [2402.01852].
- Further optimization of physical–algorithmic entropy coupling and dynamic reseeding to strengthen forward secrecy and adversarial unpredictability [2502.18609], [2508.01051].
- Expansion of QPP-RNG-inspired randomization mechanisms across distributed systems, edge devices, and quantum communication protocols.

QPP-RNG's hybrid of mathematically grounded permutation complexity and physics-inspired entropy accumulation marks it as a foundational building block for secure, future-proof randomness in advanced communications and cryptography.

Source: https://www.emergentmind.com/topics/qpp-rng