We introduce the random permutation sorting system (rpss), a software-defined framework that generates high-quality, uniform randomness by leveraging a statistical model with properties analogous to quantum ensembles. The RPSS operates as a self-contained entropy engine based on a fundamental pair of conjugate observables: the permutation count (N[over ̂]_{p}) and the elapsed sorting time (T[over ̂]). While the raw distributions of these observables are highly right-skewed and heavy-tailed, we provide a mathematical proof of their synchronous convergence to uniformity. The permutation count distributions follow a negative binomial model, and the observed modes for different repetition parameters m closely match the theoretical predictions, confirming the validity of the model. This convergence arises from the compounded effect of permutation counts on elapsed time and a process of modular uniformization, in which a vast number of microstates-stemming from combinatorial complexity and intrinsic system-level jitter-map onto a finite set of uniform symbols. This mechanism enables the RPSS to function as a true uniform random number generator. We implemented the RPSS as the qpp-rng, a practical software realization that autonomously harvests entropy from a platform's intrinsic microarchitectural dynamics. Unlike prior benchmark-focused studies, this work provides a deep theoretical and experimental investigation of the underlying physical mechanism. Empirical validation confirms our predictions, demonstrating rapid entropy convergence and statistically uniform outputs, as assessed by NIST SP 800-90B min-entropy and χ-squared statistics, consistent with central-limit-theorem expectations. The RPSS establishes a class of quantum-inspired ecocryptosystems, in which randomness is simultaneously harvested from unpredictable hardware behavior and amplified through a combinatorial process. This dual-source approach provides a compact, self-stabilizing entropy engine suitable for foundational applications in cryptography, blockchain protocols, and digital currency systems, offering a robust, platform-agnostic alternative to conventional entropy sources.
We introduce the random permutation sorting system (rpss), a software-defined framework that generates high-quality, uniform randomness by leveraging a statistical model with properties analogous to quantum ensembles. The RPSS operates as a self-contained entropy engine based on a fundamental pair of conjugate observables: the permutation count (N[over ̂]_{p}) and the elapsed sorting time (T[over ̂]). While the raw distributions of these observables are highly right-skewed and heavy-tailed, we provide a mathematical proof of their synchronous convergence to uniformity. The permutation count distributions follow a negative binomial model, and the observed modes for different repetition parameters m closely match the theoretical predictions, confirming the validity of the model. This convergence arises from the compounded effect of permutation counts on elapsed time and a process of modular uniformization, in which a vast number of microstates-stemming from combinatorial complexity and intrinsic system-level jitter-map onto a finite set of uniform symbols. This mechanism enables the RPSS to function as a true uniform random number generator. We implemented the RPSS as the qpp-rng, a practical software realization that autonomously harvests entropy from a platform's intrinsic microarchitectural dynamics. Unlike prior benchmark-focused studies, this work provides a deep theoretical and experimental investigation of the underlying physical mechanism. Empirical validation confirms our predictions, demonstrating rapid entropy convergence and statistically uniform outputs, as assessed by NIST SP 800-90B min-entropy and χ-squared statistics, consistent with central-limit-theorem expectations. The RPSS establishes a class of quantum-inspired ecocryptosystems, in which randomness is simultaneously harvested from unpredictable hardware behavior and amplified through a combinatorial process. This dual-source approach provides a compact, self-stabilizing entropy engine suitable for foundational applications in cryptography, blockchain protocols, and digital currency systems, offering a robust, platform-agnostic alternative to conventional entropy sources.
We present the Random Permutation Sorting System (RPSS), a novel framework for true uniform randomness generation grounded in statistical quantum mechanics. RPSS is built on a pair of conjugate observables, the permutation count and the elapsed sorting time, whose heavy-tailed raw distributions synchronously converge to uniformity through modular reduction. This mathematically proven convergence establishes RPSS as a True Uniform Random Number Generator (TURNG). A practical implementation, QPP-RNG, demonstrates how intrinsic system jitter, arising from microarchitectural noise, memory latency, and scheduling dynamics, interacts with combinatorial complexity to yield a compact, self-stabilizing entropy source. Empirical validation under the NIST SP 800-90B framework confirms rapid entropy convergence and statistically uniform outputs. RPSS thus defines a new class of quantum-inspired entropy engines, where randomness is simultaneously harvested from unpredictable system jitter and amplified by combinatorial processes, offering a robust, platform-independent alternative to conventional entropy sources.
We propose and experimentally demonstrate the quasi-superposition quantum-inspired system (QSQS)-a conceptual quantum system for randomness generation built on measuring two conjugate observables of a permutation sorting process: the deterministic permutation count n_{p} and the fundamentally nondeterministic sorting time t. By analogy with quantum systems, these observables are linked by an uncertainty-like constraint: algorithmic determinism ensures structural uniformity, while system-level fluctuations introduce irreducible unpredictability. We realize this framework concretely as a quantum permutation pad (QPP) random number generator (RNG) or QPP-RNG, a system-embedded, software-based true random number generator (TRNG). In QPP-RNG, real-time measurements of sorting time t-shaped by CPU pipeline jitter, cache latency, and OS scheduling-dynamically reseed the pseudorandom RNG, driving the permutation sequence. This design fuses deterministic and nondeterministic components, so that entropy emerges organically from the quasisuperposition structure of the system. Crucially, the QSQS transforms initially right-skewed raw distributions of n_{p} and t into nearly uniform outputs after modulo reduction. This effect arises from the system's internal degeneracies: many distinct internal states collapse into the same output symbol, effectively flattening biases and filling out the output space. This transformation from biased measurements to uniform randomness is the core principle of the QSQS. Empirical results show that as the repetition factor m increases, output entropy converges toward theoretical maxima: Shannon and NIST SP 800-90B min-entropy values approach 8 bits, chi-squared statistics stabilize near ideal uniformity, and bell curve plots visually confirm the flattening from skewed to uniform distributions. The convergence to uniformity occurs at a rate inversely proportional to the size of the permutation space, making the system both scalable and theoretically grounded. Beyond practical implications, our findings illustrate how the QSQS unifies deterministic algorithmic processes with nondeterministic physical fluctuations in a single framework, offering a physics-based perspective for engineering randomness. In the quantum-safe era, the QPP-RNG can close the entropy gap by embedding true randomness directly into cryptographic modules, reducing reliance on external entropy sources and enabling entropy-rich, self-contained postquantum cryptographic ecosystems.
We propose and experimentally demonstrate the \emph{Quasi-Superposition Quantum-inspired System (QSQS)} -- a conceptual quantum system for randomness generation built on measuring two conjugate observables of a permutation sorting process: the deterministic permutation count np and the fundamentally non-deterministic sorting time t. By analogy with quantum systems, these observables are linked by an uncertainty-like constraint: algorithmic determinism ensures structural uniformity, while system-level fluctuations introduce irreducible unpredictability. We realize this framework concretely as \emph{QPP-RNG}, a system-embedded, software-based true random number generator (TRNG). In QPP-RNG, real-time measurements of sorting time t -- shaped by CPU pipeline jitter, cache latency, and OS scheduling -- dynamically reseed the PRNG driving the permutation sequence. Crucially, QSQS transforms initially right-skewed raw distributions of np and t into nearly uniform outputs after modulo reduction, thanks to internal degeneracies that collapse many distinct states into the same output symbol. Empirical results show that as the repetition factor m increases, output entropy converges toward theoretical maxima: Shannon and min-entropy values approach 8 bits, chi-squared statistics stabilize near ideal uniformity, and bell curves visually confirm the flattening from skewed to uniform distributions. Beyond practical implications, QSQS unifies deterministic algorithmic processes with non-deterministic physical fluctuations, offering a physics-based perspective for engineering true randomness in post-quantum cryptographic systems.
We present a fully digital framework that replicates the statistical behavior of coherent-state quantum random number generation (QRNG) by harnessing system timing jitter through random permutation processes. Our approach transforms computational timing variations from hardware and operating system sources into permutation dynamics that generate Poisson-distributed numbers, accurately reproducing the photon statistics of optical coherent states. The theoretical foundation is established by the Uniform Convergence Theorem, which provides exponential convergence to uniformity under modular projection with rigorous error bounds. Extensive experimental validation across multiple parameter regimes and sample sizes up to 108 bytes demonstrates exceptional performance: Shannon entropy approaching 7.999998 bits/byte and min-entropy exceeding 7.99 bits/byte, outperforming theoretical bounds at scale. The architecture inherently resists side-channel attacks through compound timing distributions and adaptive permutation behavior, while operating without classical cryptographic post-processing. Our results establish that coherent-state QRNG functionality can be entirely realized through classical computational processes, delivering mathematically provable uniformity and practical cryptographic security without quantum photonic hardware.
We propose a groundbreaking random number generator that achieves truly uniform, independent, and identically distributed (IID) randomness by integrating Quantum Permutation Pads (QPP) with system jitter-derived entropy, herein called IID-based QPP-RNG. Unlike conventional RNGs that use raw timing variations, our design uses system jitter solely to generate ephemeral QPP pads and derives 8-bit outputs directly from permutation counts, eliminating the need for post-processing. This approach leverages the factorial complexity of permutation sorting to systematically accumulate entropy from dynamic hardware interactions, ensuring non-deterministic outputs even from fixed seeds. Notably, IID-based QPP-RNG achieves a min-entropy of 7.85-7.95 bits per byte from IID minentropy estimate, surpassing ID Quantique's QRNG (7.157042 bits per byte), which marks a breakthrough in randomness quality. Our implementation employs a dynamic seed evolution protocol that continuously refreshes the internal state with unpredictable system jitter, effectively decoupling the QPP sequence from the initial seed. Cross-platform validation on macOS (x86 and ARM) and Windows (x86) confirms uniformly distributed outputs, while evaluations compliant with NIST SP 800-90B show a Shannon entropy of 7.9999 bits per byte. Overall, IID-based QPP-RNG represents a significant advancement in random number generation, offering a scalable, system-based, software-only, postquantum secure solution for a wide range of cryptographic applications.
This paper explores the potential of harnessing quantum mechanical principles, specifically superposition and entanglement, to generate truly random numbers. Current classical random number generators rely on entropy sources that, while statistically random, are fundamentally predictable. We propose a novel algorithmic approach termed "Quantum-Inspired Algorithmic Randomness Generation" (Q-IARG) that utilizes controlled quantum decoherence and measurement processes to generate high-entropy random numbers. The core concept involves mapping the probabilistic outcomes of these processes—defined by equations and mathematical models—to a sequence of random numbers. This approach moves beyond merely simulating quantum phenomena and aims for a practically demonstrable improvement in randomness quality. The system is envisioned as a hybrid hardware/software solution, offering a pathway to surpass the limitations of traditional entropy sources. The system's effectiveness will be assessed through the analysis of the statistical properties of the generated sequences, focusing on metrics such as entropy, autocorrelation, and uniformity. This work provides a foundational framework for exploring quantum-inspired randomness generation and its potential applications.