Fact-checked by Grok 2 weeks ago

Randomness test

A randomness test, also known as a test for randomness, is a statistical procedure designed to evaluate whether a sequence of data, such as bits or observations, conforms to the properties expected of a truly random process, where each outcome is independent and uniformly distributed.^[1] These tests typically formulate a null hypothesis assuming randomness and compute a test statistic—such as the number of runs or frequency distributions—compared against a reference distribution (e.g., chi-squared or normal) to derive a P-value; if the P-value falls below a significance level like 0.01, the sequence is deemed non-random.^[1]^[2] Randomness tests play a critical role in validating random number generators (RNGs) and pseudorandom number generators (PRNGs), which produce sequences purporting to be unpredictable and uniformly distributed, essential for cryptographic applications like key generation and protocol challenges.^[1] Beyond cryptography, they are applied in quality control to detect trends or cycles in production data, in simulation modeling to ensure unbiased outcomes, and in scientific research to assess experimental variability against systematic errors.^[2] While no suite of tests can fully certify randomness—serving only as a preliminary check against cryptanalysis or deeper analysis—their outputs help identify deviations such as clustering, periodicity, or bias that could compromise security or reliability.^[1] Prominent examples include the run test, which counts sequences of consecutive similar values (e.g., above or below the median) to detect trends or oscillations, and more advanced suites like the NIST Statistical Test Suite, comprising 15 distinct tests such as frequency (monobit), block frequency, longest runs of ones, spectral (discrete Fourier transform), and linear complexity tests.^[2]^[1] These tests operate on binary sequences of sufficient length, typically 1,000,000 bits or more for the NIST suite, and aggregate P-values across multiple sequences to assess overall generator performance, with passing criteria often requiring at least 98% of P-values to exceed the 0.01 threshold.^[1] Developments in randomness testing continue to evolve, incorporating computational advances to handle larger datasets and more sophisticated patterns in modern applications.^[1]

Introduction

Definition and Purpose

A randomness test is a statistical procedure that evaluates the distribution and patterns within a dataset, such as a binary or numerical sequence, to determine whether it deviates significantly from the properties expected under true random behavior.^[1] These tests typically operate under a null hypothesis that the sequence is random, computing a test statistic that measures adherence to theoretical expectations, such as uniformity or independence.^[1] If the resulting p-value falls below a predetermined significance level, the null hypothesis is rejected, indicating potential non-randomness.^[1] The primary purpose of randomness tests is to detect flaws like biases, serial correlations, or periodicities in outputs from pseudorandom number generators (PRNGs), true random number generators (TRNGs), or empirical data sources, ensuring their suitability for applications such as cryptography, simulations, and scientific modeling.^[1] PRNGs, being deterministic algorithms, aim to mimic randomness statistically, while TRNGs draw from physical entropy sources like thermal noise; tests validate both by probing for detectable patterns that could compromise reliability.^[1] For instance, in cryptographic contexts, failing tests might reveal vulnerabilities exploitable by adversaries. A key distinction exists between statistical randomness, which is verifiable through these tests (e.g., passing frequency or runs tests indicates no detectable bias), and true unpredictability, an idealized property of physical processes that defies deterministic prediction even with full knowledge of the system.^[1] While statistical tests assess observable properties like uniformity, they cannot confirm intrinsic unpredictability, as PRNGs may pass all known tests yet remain reproducible from their seed.^[3] In practice, the process involves inputting a sequence—typically at least 1,000,000 bits for robust evaluation—into one or more tests, deriving a p-value from the test statistic's comparison to a reference distribution (e.g., chi-squared), and deciding randomness at a significance level like α = 0.01, where p ≥ α accepts the sequence as sufficiently random.^[1] This threshold balances false positives and ensures high confidence in results for practical use.^[1]

Historical Overview

The foundations of randomness testing trace back to the early 20th century, when statisticians developed methods to assess uniformity in data distributions as a proxy for randomness. In 1900, Karl Pearson introduced the chi-squared goodness-of-fit test, which evaluates whether observed frequencies deviate significantly from expected uniform probabilities, providing an early tool for detecting non-random patterns in categorical data. This test became a cornerstone for frequency-based randomness assessments, influencing subsequent adaptations for sequential and binary data analysis.^[4] By the mid-20th century, attention shifted toward testing independence and ordering in sequences, leading to the development of the runs test. In 1940, Alexander M. Mood published work on the distribution theory of runs, establishing a statistical framework to detect clustering or excessive alternation in binary sequences, thereby assessing deviations from random independence. Concurrently, Abraham Wald and Jacob Wolfowitz proposed a runs test specifically for comparing two samples to determine if they arise from the same random process, further refining tools for sequence randomness. These contributions marked a pivotal advancement in nonparametric methods for empirical randomness evaluation. The late 20th century saw the emergence of comprehensive test batteries tailored for evaluating random number generators (RNGs), particularly in computing. In 1995, George Marsaglia released the Diehard battery of tests, a suite of 15 rigorous statistical procedures designed to probe RNG output for subtle non-random artifacts, such as correlations in high-dimensional spaces, and distributed via CD-ROM for widespread use. Entering the 2000s, the National Institute of Standards and Technology (NIST) published Special Publication 800-22 in 2001, introducing a standardized suite of 16 tests for validating RNGs in cryptographic applications, which was revised in 2010 to 15 core tests by removing the Lempel-Ziv Compression test due to theoretical issues, with improved p-value assessments.^[1] Complementing this, Pierre L'Ecuyer and Richard Simard developed the TestU01 library in 2007, an open-source C implementation offering over 160 empirical tests organized into batteries like SmallCrush and BigCrush for scalable RNG scrutiny. Subsequent extensions and adaptations have addressed evolving RNG technologies. In 2004, Robert G. Brown extended Marsaglia's Diehard into Dieharder, a modular framework incorporating NIST tests and enhancing portability for modern systems.^[5] Post-2015, refinements have focused on quantum RNGs (QRNGs), with NIST's 2015 Bell test experiments confirming quantum sources' inherent unpredictability and prompting adaptations of suites like SP 800-22 to verify post-processing in QRNG outputs against classical biases. As of 2022, NIST announced plans to further revise SP 800-22, incorporating advances such as stochastic models, though no new version has been published as of November 2025.^[6]

Theoretical Foundations

Properties of Random Sequences

Ideal random sequences exhibit several key mathematical and statistical properties that distinguish them from deterministic or patterned data. These properties form the theoretical basis for evaluating the quality of random number generators and sequences used in simulations, cryptography, and statistical modeling.^[7] Uniformity requires that each possible outcome in the sequence occurs with equal probability. For a binary sequence over the alphabet {0,1}, this means each bit appears with probability 1/2, ensuring no bias toward any particular value. This property is fundamental to applications where balanced distribution is essential, such as Monte Carlo methods.^[1] Independence implies that the occurrence of any element in the sequence does not influence the others, with no correlations between successive or non-adjacent elements. This is quantified by the autocorrelation function, which approaches zero for all non-zero lags in an ideal sequence, confirming the absence of predictable dependencies.^[8] Incompressibility characterizes a sequence as one that cannot be significantly compressed without loss of information, as measured by Kolmogorov complexity—the length of the shortest program that generates the sequence. A truly random sequence has Kolmogorov complexity approximately equal to its length, resisting algorithmic description or pattern extraction.^[9] In pseudorandom generators like linear congruential generators, ideal sequences avoid short repeating cycles by achieving the full possible period, preventing detectable periodicity that would undermine randomness.^[10] For a binary sequence of length n, the ideal Shannon entropy is H = n bits, reflecting maximum uncertainty; any deviation below this value signals structure or non-randomness in the sequence.^[11]

Statistical Framework for Testing

The statistical framework for testing randomness in sequences, such as binary strings from random number generators, relies on classical hypothesis testing to assess whether the data conform to the expectations of true randomness. The null hypothesis H_0 posits that the sequence is random, meaning it consists of independent and uniformly distributed bits (or symbols).^[1] In contrast, the alternative hypothesis H_1 asserts that the sequence exhibits non-random characteristics, such as bias toward certain values or dependencies between bits.^[1] This setup allows tests to quantify deviations from ideal randomness empirically. Central to this framework is the test statistic, a numerical measure derived from the sequence that summarizes its adherence to H_0. For instance, in frequency-based assessments, the chi-squared statistic \chi^2 = \sum \frac{(O_i - E_i)^2}{E_i} is computed, where O_i are observed frequencies and E_i are expected frequencies under uniformity.^[1] The distribution of the test statistic under H_0 is typically known asymptotically (e.g., chi-squared with degrees of freedom equal to the number of categories minus one), enabling the calculation of a p-value. The p-value represents the probability of obtaining a test statistic at least as extreme as the observed one, assuming H_0 is true; if the p-value falls below a pre-specified significance level \alpha (commonly 0.01), H_0 is rejected in favor of H_1.^[1] This threshold \alpha controls the Type I error rate, the risk of falsely rejecting a truly random sequence.^[1] When applying a suite of multiple tests, the multiplicity problem arises, increasing the chance of false positives across the battery. A widely adopted correction is the Bonferroni adjustment, which divides the overall significance level by the number of tests (e.g., \alpha' = \alpha / k for k tests) to maintain control over the family-wise error rate.^[12] This conservative approach is particularly relevant in cryptographic randomness validation, where test batteries like those in NIST SP 800-22 are used, though some suites assess overall performance via p-value uniformity or pass proportions instead.^[12]^[1] The power of a randomness test—the probability of correctly rejecting H_0 when H_1 is true—depends on factors like the specific non-random deviation, the test's sensitivity, and the sequence length n. Seminal suites recommend large sample sizes, often n \geq 10^6 bits, to achieve adequate power against subtle patterns, as smaller sequences may fail to detect deviations reliably.^[1] For example, many NIST tests require at least 100 sequences of $10^6 bits each to evaluate p-value distributions robustly.^[1]

Categories of Randomness Tests

Frequency-Based Tests

Frequency-based tests evaluate the uniformity of symbol occurrences within a random sequence, serving as a fundamental check for global or local biases in the distribution of elements, such as zeros and ones in binary data. These tests assume that in a truly random sequence, each symbol should appear with equal probability, and deviations from this balance may indicate non-randomness due to generator flaws or deterministic patterns. By focusing on marginal frequencies rather than sequential dependencies, they provide an initial assessment of balance before more complex analyses.^[13] The monobit test, also known as the frequency test, counts the number of ones (or zeros) in a binary sequence of length n and assesses whether this proportion approximates $1/2. The test statistic is computed as z = \frac{|\sum (2\epsilon_i - 1)|}{\sqrt{n}}, where \epsilon_i represents the i-th bit (0 or 1), equivalent to z = \frac{|\text{ones} - n/2|}{\sqrt{n/4}}. Under the null hypothesis of randomness, this statistic follows a standard normal distribution for large n, and the p-value is derived using the complementary error function: p = \text{erfc}(z / \sqrt{2}). A sequence passes if p > 0.01, rejecting non-uniformity at the 1% significance level; this test is sensitive to overall imbalance but insensitive to local clustering.^[13] The block frequency test extends the monobit approach by partitioning the sequence into N non-overlapping blocks of length M (typically M = 128 bits and N \approx n/M) and verifying uniformity within each block. For each block i, the proportion of ones \pi_i is calculated, and the chi-squared statistic is \chi^2 = 4M \sum_{i=1}^N (\pi_i - 1/2)^2. This follows a chi-squared distribution with N degrees of freedom, with p-value p = \text{igamc}(N/2, \chi^2 / 2), where igamc is the incomplete gamma function complement. The test passes if p > 0.01; it detects localized biases that the global monobit test might overlook, such as periodic fluctuations.^[13] The poker test groups the sequence into non-overlapping words of 5 bits each, examining the frequency distribution across the 32 possible patterns (though often simplified to 16 equivalence classes based on pattern types for computational efficiency). Observed frequencies f_i for each pattern i are compared to expected uniform frequencies e_i = n/32, yielding the chi-squared statistic \chi^2 = \sum (f_i - e_i)^2 / e_i with 31 degrees of freedom (or 15 for grouped classes). The p-value is obtained from the chi-squared cumulative distribution function, and the test passes if p > 0.01. Originally proposed for decimal digits, this test has been adapted for binary sequences to detect deviations in pattern uniformity, revealing biases in symbol combinations.^[14] The monobit test and block frequency test identify both global and local non-uniformities, with thresholds like p > 0.01 commonly used to determine pass/fail criteria across implementations. While primarily designed for binary data, adaptations for non-binary alphabets involve generalizing the expected frequencies to $1/|\Sigma| per symbol, though such extensions require careful adjustment of block sizes and degrees of freedom to maintain statistical validity.^[13]

Pattern and Independence Tests

Pattern and independence tests assess whether elements in a random sequence exhibit dependencies or non-random patterns, such as consecutive repetitions or correlations at specific lags, which would violate the assumption of statistical independence required for true randomness. These tests are essential for detecting subtle temporal structures that frequency-based tests might overlook, as they examine the sequential arrangement rather than marginal distributions. By focusing on runs, overlaps, and autocorrelations, this category helps identify periodicities or biases in pseudorandom number generators and cryptographic outputs.^[13] The runs test, originally developed as the Wald-Wolfowitz runs test, evaluates the randomness of a binary sequence by counting the number of runs—sequences of consecutive identical bits (e.g., strings of 0s or 1s)—and comparing this to the expected distribution under randomness. For a sequence of length n with n_0 zeros and n_1 ones, the test typically focuses on up-and-down runs or total runs, where the test statistic is standardized as z = \frac{R - \mu}{\sigma}, with mean \mu = \frac{2n_0 n_1}{n} + 1 and variance \sigma^2 = \frac{2n_0 n_1 (2n_0 n_1 - n)}{n^2 (n-1)}, following a normal distribution for large n. A significant deviation from the expected number of runs indicates clustering or alternation patterns inconsistent with independence. Variants, such as the longest run of ones test, measure the maximum length of consecutive 1s and compare it to thresholds derived from the binomial distribution to detect excessive streaks that suggest non-randomness.^[13] The serial test, also known as the overlap test, probes for independence by analyzing the frequencies of overlapping digrams (pairs of bits) or trigrams in the sequence, using a chi-squared statistic on a $2^k \times 2^k contingency table for blocks of size k. Proposed by Good, this test assesses whether the joint distribution of consecutive bits matches the product of marginals under independence, with the null hypothesis rejected if the observed frequencies deviate significantly from uniform expectations. It is particularly sensitive to local dependencies in short substrings, making it useful for early detection of generator flaws.^[13] Autocorrelation tests measure linear dependencies between the sequence and its lagged versions, computing the coefficient \rho_k = \frac{\sum_{i=1}^{n-k} (x_i - \mu)(x_{i+k} - \mu)}{\sum_{i=1}^n (x_i - \mu)^2} for lag k, where \mu and the denominator approximate the mean and variance; under randomness, \rho_k should be near zero, with significance tested via z-scores or bounds like |\rho_k| < \frac{1.96}{\sqrt{n}} for 95% confidence. This approach effectively uncovers periodic structures, as non-zero correlations at specific lags signal hidden cycles in the generator.^[15] The runs test and serial test collectively detect periodicities by flagging deviations in run distributions, overlap frequencies, or lag correlations that binomial or chi-squared thresholds would highlight as improbable under independence.^[13] Modern extensions of these tests address high-dimensional data, where sequences may span multiple dimensions or variables; for instance, multivariate runs tests generalize the Wald-Wolfowitz framework to vector-valued observations, defining runs based on orderings or distances and deriving asymptotic normality for the test statistic to handle dependencies across dimensions. Such variants are crucial for applications in big data and machine learning, where traditional univariate tests underperform due to increased complexity in pattern detection.^[16]

Major Test Suites

Diehard and Dieharder Tests

The Diehard battery of tests, developed by George Marsaglia in 1995, comprises 15 simulation-based statistical tests aimed at rigorously evaluating the quality of random number generators by simulating real-world scenarios that expose non-random patterns. Sponsored by the National Science Foundation, the suite was first distributed on a CD-ROM containing random number datasets and the test software, emphasizing the need for generators to withstand extensive scrutiny beyond simple statistical measures. Key tests include the birthday spacings test, which generates uniform random points on a large interval and analyzes the spacings between sorted values to verify exponential distribution under uniformity; the overlapping permutations test, which examines sequences for unexpected repetitions in digit orders; and the ranks of matrices test, which assesses the linear independence of rows and columns in randomly filled binary matrices of varying sizes.^[17] Among the suite's distinctive tests are the monkey tests, which interpret long bit streams as text produced by monkeys typing randomly on keyboards, checking for improbable word formations or patterns that indicate correlations; the 3D spheres test, which places spheres of random radius at random centers in a 3D lattice and counts enclosed points to probe multidimensional uniformity; and the squeezing test, which repeatedly extracts and shifts bits from overlapping blocks to detect hidden dependencies in the generator's output. These tests collectively require processing approximately 10^9 to 10^12 bits, making Diehard particularly suited for identifying subtle flaws in pseudo-random number generators (PRNGs) that might pass basic checks but fail under prolonged simulation.^[17]^[18] Dieharder, an extension created by Robert G. Brown starting in 2004, builds on the original suite by integrating its 15 tests with additional ones from sources like the NIST statistical suite, resulting in over 30 tests in total. It introduces support for parallel execution across multiple processors or clusters, enabling efficient testing of high-volume streams from modern generators, and aggregates multiple p-values from repeated trials using the exponential distribution assumption for uniformity assessment via the Kolmogorov-Smirnov test. Like its predecessor, Dieharder targets weak PRNGs by demanding large sample sizes—often around 10^9 bits—and provides detailed diagnostics to pinpoint failures, though it has seen limited documented integrations with contemporary cryptographic RNGs in recent literature.^[5]^[19] For the birthday spacings test, m random values are generated within a range of size n (typically m ≈ 512, n = 2^{24}), sorted to obtain spacings d_i (with sum d_i = n), and the test statistic is computed as ∑ -ln(d_i / n), which asymptotically follows a chi-squared distribution with 2m degrees of freedom under the null hypothesis of perfect randomness.

NIST Statistical Test Suite

The NIST Statistical Test Suite, formally known as NIST Special Publication 800-22 Revision 1a, was originally published in 2001 and revised in April 2010 to provide a standardized set of statistical tests for assessing the randomness of binary sequences produced by random and pseudorandom number generators (RNGs and PRNGs) intended for cryptographic applications. This suite supports compliance with Federal Information Processing Standard (FIPS) 140-2 by evaluating whether generators produce sequences that are statistically indistinguishable from true random bits, thereby ensuring their suitability for secure key generation and other cryptographic functions. Authored by a team including Andrew Rukhin, Juan Soto, and Elaine Barker, the document outlines a battery of 15 tests designed for sequences of at least 100 bits, with recommendations for testing multiple sequences to achieve reliable results. The core tests in the suite target various aspects of randomness, including uniformity, independence, and absence of patterns. Key tests include the Frequency (Monobit) Test, which assesses the balance between zeros and ones in the sequence; the Block Frequency Test, which checks the proportion of ones within fixed-length blocks; the Cumulative Sums (Cusum) Test, which detects gradual deviations from expected balance; the Runs Test, which evaluates the number of alternating runs of identical bits; the Longest Run of Ones in a Block Test, which measures the maximum consecutive ones in blocks; the Binary Matrix Rank Test, which examines linear dependencies in decomposed matrices; the Universal Test (Maurer's), which gauges sequence compressibility as a proxy for randomness; the Approximate Entropy Test, which quantifies predictability by comparing overlapping block frequencies; the Serial Test, which tests the uniformity of overlapping bit pairs or tuples; and the Discrete Fourier Transform (Spectral) Test, which identifies periodic structures through spectral analysis. These tests, along with five others (non-overlapping and overlapping template matching, linear complexity, and random excursions variants), form a comprehensive battery tailored for binary data in cryptographic contexts. A representative example is the Cumulative Sums (Cusum) Test, which models the binary sequence as a random walk to detect biases. The sequence bits b_i (0 or 1) are mapped to X_i = 2b_i - 1 (yielding +1 or -1), and partial sums are computed as S_k = \sum_{i=1}^k X_i for k = 1 to n, where n is the sequence length. The upper sum is S^+ = \max_{1 \leq k \leq n} S_k and the lower sum is S^- = \min_{1 \leq k \leq n} S_k, capturing the maximum excursions above and below zero. The test statistic is then

z = \frac{\max(|S^+|, |S^-|)}{\sqrt{n}},

which under the null hypothesis of randomness follows a standard normal distribution for large n. The p-value is computed as p = \text{erfc}(z / \sqrt{2}), where erfc is the complementary error function; a low p-value indicates significant deviation, suggesting non-randomness. Each test in the suite generates a p-value representing the probability that a truly random sequence would produce a test statistic at least as extreme as observed, assuming the null hypothesis of randomness. Sequences pass individual tests if the p-value \geq 0.01 (corresponding to a 1% significance level), with the suite recommending at least 100 test sequences per generator to estimate pass rates reliably—typically requiring about 96-99% success across tests for validation. Due to potential inter-test dependencies (e.g., correlations between Cusum and Runs tests identified via principal component analysis), the suite advises running tests in a specific order, starting with the Frequency Test, and considering multivariate adjustments to avoid over-rejection of marginally random sequences, though minimal redundancy is observed overall. In the 2020s, the suite has seen applications in validating quantum random number generators (QRNGs) for post-quantum cryptographic systems, where high-entropy sources are critical to resist quantum attacks, and NIST initiated a revision process in 2022 to incorporate new research on stochastic models and test enhancements.^[20] This builds briefly on earlier exploratory suites like Diehard, adapting rigorous statistical methods for modern cryptographic needs.

TestU01

TestU01 is a software library for empirical statistical testing of uniform random number generators, developed by Pierre L'Ecuyer and Richard Simard and first released in 2007. Implemented in ANSI C, it provides a comprehensive framework with utilities to generate test sequences and apply hundreds of statistical tests, focusing on detecting dependencies, patterns, and deviations from uniformity and independence in RNG outputs. The library includes predefined batteries of tests: SmallCrush (10 tests), Crush (68 tests), and BigCrush (160 tests), which combine classical tests with specialized ones for lattice structures, serial correlations, and collision detection, making it suitable for thorough validation of PRNGs in simulations and cryptography.^[21]^[22] TestU01's tests cover a broad spectrum, including collision tests, birthday spacings variants, matrix rank tests, and spectral tests, often requiring large sample sizes (up to 10^{12} or more) to expose subtle weaknesses. Unlike binary-focused suites like NIST, TestU01 operates primarily on floating-point uniform [0,1) sequences but supports adaptations for binary data. It has become a standard tool in academic research for RNG assessment, with ongoing updates and integrations in open-source projects, though it demands significant computational resources for full execution. As of 2025, TestU01 remains actively maintained and recommended for advanced testing beyond basic suites.

Applications

Cryptographic Validation

In cryptographic systems, randomness tests play a critical role in validating the output of random number generators (RNGs) and pseudorandom number generators (PRNGs) to ensure unpredictability and uniformity, thereby mitigating risks such as bias exploitation that could compromise key generation and enable attacks like predictable nonce reuse or signature forgery.^[23] These tests assess whether generated sequences exhibit no discernible patterns or deviations from ideal randomness, which is essential for protocols relying on secure randomness, including encryption, digital signatures, and authentication mechanisms.^[1] Failure to verify these properties can lead to vulnerabilities where adversaries predict or bias outputs, undermining the security assumptions of cryptographic primitives.^[24] Standards such as FIPS 140-3, published in 2019, mandate validation of cryptographic modules, including RNGs, through NIST's Cryptographic Algorithm Validation Program (CAVP), which incorporates statistical testing requirements for entropy sources as outlined in SP 800-90B to confirm compliance with security levels.^[25] Similarly, the ECRYPT II project, focused on stream ciphers, recommends applying statistical randomness tests to evaluate keystream quality, emphasizing tests for uniformity and independence to ensure suitability for cryptographic use in synchronous stream ciphers.^[26] These standards prioritize tests that detect deviations exploitable in real-world deployments, such as those in secure communication protocols. A practical example involves testing AES in counter mode (AES-CTR) as a PRNG, where the block cipher is used to generate keystreams from an initial counter and key; randomness tests, including those from the NIST suite, are applied to verify the output's indistinguishability from true randomness, confirming its resistance to bias in applications like key derivation.^[27] Another illustration is the spectral test, which detects linear weaknesses in PRNGs by analyzing the discrete Fourier transform of sequences to identify periodic structures or correlations that could reveal exploitable patterns in cryptographic generators.^[1] Non-passing tests signal potential vulnerabilities, as exemplified by the Dual_EC_DRBG, revealed in 2007 to contain a backdoor that introduced bias, causing it to fail statistical tests for randomness, including those assessing independence, which highlighted flaws in its elliptic curve-based design.^[28] Post-2010, NIST's Deterministic Random Bit Generator (DRBG) validation system, updated under SP 800-90A Revision 1 in 2012, shifted focus to known-answer tests for algorithmic correctness while recommending supplementary statistical evaluations to ensure robust security in approved implementations.^[29]

Simulation and Modeling

Randomness tests are integral to validating random number generators (RNGs) in Monte Carlo methods and scientific simulations, where they ensure unbiased sampling by detecting deviations from ideal uniformity and independence. In particle physics, for instance, these tests assess RNGs used in event generators to simulate high-energy collisions, confirming that generated particle trajectories avoid artificial patterns that could bias cross-section calculations.^[30] In financial modeling, randomness tests evaluate RNGs for stochastic processes in derivative pricing, safeguarding against correlated outputs that might underestimate market risks in value-at-risk computations.^[31] In machine learning, particularly neural networks, randomness tests scrutinize RNGs employed in techniques such as stochastic gradient descent, dropout, and data augmentation, as weaknesses in randomness can enable attacks or compromise model performance.^[32] Deficient randomness introduces systematic errors, such as correlated samples that inflate variance estimates in simulation outputs; for example, in Monte Carlo integrations for molecular systems, poor RNGs have been shown to yield incorrect densities and energies by up to 10-20% due to hidden dependencies mimicking physical artifacts. This underscores the importance of rigorous testing to maintain simulation fidelity.^[33] To integrate these tests effectively, pre-simulation validation using suites like TestU01 is standard practice, where RNGs undergo batteries such as [Big Crush](/page/Big Crush) to confirm statistical properties before deployment in computationally intensive runs. Post-hoc analysis in ensemble simulations further examines output sequences for emergent correlations, allowing researchers to refine RNG selection and mitigate biases in fields from physics to machine learning.^[34]^[35]

Implementations and Tools

Open-Source Libraries

TestU01 is a widely used open-source C library developed in 2007 by Pierre L'Ecuyer and Richard Simard for empirical statistical testing of uniform random number generators.^[21] It includes over 100 tests organized into batteries: SmallCrush with 10 tests for quick validation, Crush with 96 tests for more thorough assessment, and BigCrush with 160 tests for extensive evaluation.^[34] The library supports user-defined RNG plugins through a modular interface, allowing integration of custom generators, and provides tools for generating p-values and visualizing results.^[22] Available under a permissive license, TestU01 is accessible via its official repository on GitHub and has been cited in numerous studies for its robustness in detecting non-random patterns.^[36] Dieharder, released under the GNU General Public License, extends the original Diehard test suite with over 30 additional tests, totaling more than 50 statistical assessments for random number generators.^[5] Developed by Robert G. Brown, it offers a command-line interface for testing binary data streams from software or hardware RNGs, supporting input from files, standard input, or built-in generators like those from the GNU Scientific Library. Key features include automated p-value reporting, performance benchmarking, and compatibility with the original Diehard tests, making it suitable for both research and practical validation.^[19] The source code and documentation are hosted on the developer's site, with packages available in major Linux distributions.^[37] The NIST Statistical Test Suite (STS), provided as an official open-source C implementation by the National Institute of Standards and Technology, corresponds to Special Publication 800-22 Revision 1a and includes 15 core tests for assessing the randomness of binary sequences in cryptographic contexts.^[38] Released around 2010 with updates as recent as 2014, it features automation scripts for batch processing, frequency analysis, and graphical output of results, emphasizing hypothesis testing via p-values.^[39] The suite is downloadable from the NIST Computer Security Resource Center and is designed for sequences of at least 100 bits, with recommendations for multiple runs to ensure reliability.^[1] For simpler analyses, ENT, a lightweight pseudorandom number sequence test program created by John Walker in 1998, performs basic entropy estimation, chi-squared distribution tests, arithmetic mean checks, and serial correlation analysis on byte streams. Written in C and available as a standalone executable under a permissive license, it processes files or piped input and outputs summary statistics, making it accessible for quick entropy evaluations without requiring compilation. The tool's source code is hosted on Fourmilab, and it remains a staple for preliminary randomness checks due to its minimal dependencies.^[40] In statistical computing environments, the R package randtests, maintained on CRAN since 2010 with updates through 2024, implements several nonparametric tests for randomness in numeric sequences, including runs, poker, and coupon collector tests.^[41] It provides functions for hypothesis testing with p-value computation, integrating seamlessly with R's data analysis workflow for sequences up to moderate lengths.^[42] Licensed under GPL-2, the package is installable via CRAN and includes vignettes for usage examples.^[43] More recent developments in the 2020s include Python implementations like randomness_testsuite, an open-source package replicating the NIST STS for binary data analysis, available on GitHub under MIT license.^[44] Similarly, diehardest, a Rust crate introduced in 2016, offers a modern approach to randomness testing with tools for rating pseudorandom stream quality through advanced statistical metrics.^[45] These libraries address gaps in older suites by providing language-specific bindings and easier integration into contemporary software ecosystems.^[46]

Integrated Software Suites

Integrated software suites provide comprehensive platforms that combine multiple randomness tests into accessible, often graphical environments, facilitating analysis for researchers, engineers, and certification bodies without requiring extensive programming expertise. These tools typically integrate established test batteries like Dieharder or NIST suites, automate data processing, and generate reports for validation in fields such as cryptography and simulation. The RDieHarder package serves as an integrated R interface to the Dieharder randomness test suite, enabling seamless execution of over 30 tests within R's statistical ecosystem for tasks like hypothesis testing and data visualization. Developed by Dirk Eddelbuettel, it supports input from various random number generators and outputs p-values and diagnostics directly in R scripts or interactive sessions, making it ideal for reproducible workflows in academic and applied statistics.^[47] The BSI's AIS 20/31 evaluation framework includes a dedicated software tool for assessing true random number generators (TRNGs), focusing on noise source validation, post-processing entropy estimation, and compliance with functionality classes like PTG.2 for cryptographic use. This tool performs statistical tests on bit sequences, calculates proportions of passing trials, and supports certification under German Federal Office for Information Security (BSI) guidelines, with the framework updated to version 3.0 in September 2024 aligning it further to international standards like NIST SP 800-90B.^[48]^[49] Cloud-based analyzers, such as RANDOM.ORG's statistical test suite introduced in the post-2010 era, allow users to upload bitstreams for automated evaluation using tests including frequency (monobit), runs, and serial analyses, with results visualized in graphs and tables for quick interpretation. Powered by atmospheric noise entropy, this web tool emphasizes accessibility for non-experts while providing detailed p-value distributions.^[50] MATLAB's Statistics and Machine Learning Toolbox incorporates built-in randomness tests, notably the runstest function for detecting non-random ordering in sequences via Wald-Wolfowitz runs analysis, and spectral tools like periodogram for Fourier-based periodicity detection in pseudorandom data. These functions integrate with MATLAB's broader environment for simulation and modeling, allowing users to apply tests alongside entropy estimation and visualization without external dependencies.^[51]^[52] For quantum random number generation in the 2020s, ID Quantique's Quantis product line features integrated software suites, such as the Quantis QRNG SDK and appliance interfaces, that embed NIST SP 800-22 and Dieharder test execution for real-time validation of quantum entropy sources. These tools support hardware-software co-analysis, including self-testing protocols for photon-based QRNGs, ensuring compliance in high-security applications like quantum key distribution.^[53]^[54]

Challenges and Future Directions

Interpretation and Limitations

Interpreting results from randomness tests requires careful consideration of statistical principles to avoid misleading conclusions. A primary challenge is the occurrence of false positives, or Type I errors, which arise when multiple tests are applied to the same sequence. Each test carries an inherent risk of incorrectly rejecting the null hypothesis of randomness (typically at significance level α = 0.01), and performing k independent tests inflates the overall false positive rate to approximately 1 - (1 - α)^k. For instance, in the NIST SP 800-22 suite with 15 tests, this can exceed 14% without correction. Mitigation strategies include adjusting α via the Bonferroni correction (dividing by the number of tests) or combining p-values using methods like Fisher's exact test, where the statistic -2 ∑ ln(p_i) follows a χ² distribution with 2k degrees of freedom under the null hypothesis.^[1] Dependencies among tests further complicate interpretation, as many suites assume independence that does not hold in practice. In the NIST SP 800-22, tests such as the frequency test and runs test are correlated, with some serving as prerequisites for others, leading to redundant assessments and inflated confidence in passing results. Over-reliance on correlated tests can produce misleading passes, where a sequence fails to detect subtle dependencies; empirical analyses show pairwise correlations up to 0.3 between certain tests like cumulative sums and runs. To address this, users should evaluate test redundancy via correlation matrices or principal component analysis rather than treating all p-values equally.^[1]^[55] Sample size profoundly influences test power and reliability, as most statistical tests rely on asymptotic approximations that fail for short sequences. The NIST suite recommends minimum lengths varying by test—e.g., 10^6 bits for overlapping template matching and random excursions—but sequences under 10^6 bits often yield low power, missing deviations like weak correlations. For small n, p-value distributions deviate from uniformity, increasing both false positives and negatives. Users must ensure adequate length to validate asymptotic assumptions, particularly for high-stakes applications.^[1]^[56] No single randomness test can comprehensively verify a sequence, necessitating test batteries like Dieharder or NIST for broader coverage; however, even passing an entire suite only confirms statistical indistinguishability from randomness, not "true" randomness immune to all flaws. These tests detect specific patterns under the independent and identically distributed (i.i.d.) uniform bit assumption but cannot rule out undiscovered dependencies or non-statistical issues like predictability from side information.^[1] In the quantum era, true random number generators (TRNGs) introduce additional limitations, particularly non-stationarity where output statistics vary over time due to environmental drifts or device instabilities. Standard tests assume i.i.d. bits and may fail to detect temporal correlations in quantum sources like photon detection, where dead times or noise fluctuations violate stationarity; NIST SP 800-90B includes dedicated IID tests, but their rejection thresholds can miss subtle drifts without ongoing monitoring. This underscores the need for adaptive validation in quantum TRNGs to maintain entropy guarantees.^[11]^[57]

Advances in Testing Methods

Recent advances in randomness testing have addressed the challenges posed by novel random number generators (RNGs), particularly those producing non-independent and identically distributed (non-IID) outputs, such as quantum RNGs (QRNGs). Traditional tests assume IID conditions, but QRNGs often exhibit correlations due to physical noise sources like photon detection or vacuum fluctuations. To handle this, the National Institute of Standards and Technology (NIST) developed SP 800-90B, which provides standardized entropy estimation methods for non-IID sources, including Most Common Value Estimate, Collision Estimate, and Markov Estimate, tailored for sources with limited independence.^[11] These techniques quantify min-entropy by analyzing statistical properties across multiple estimators, ensuring at least 1 bit of entropy per output bit for cryptographic use; for instance, they have validated QRNG chips like ID Quantique's Quantis, confirming full entropy compliance in operational ranges.^[58] A 2025 analysis confirmed the robustness of these estimators for QRNGs, though they may underestimate entropy in highly correlated quantum data, prompting ongoing refinements.^[59] Machine learning (ML) approaches, emerging post-2015, enhance detection of subtle patterns overlooked by classical statistical tests, which rely on predefined hypotheses like uniformity or independence. Neural networks, such as convolutional neural networks (CNNs) and long short-term memory (LSTM) models, treat randomness testing as a classification or predictability task, training on labeled sequences to identify non-random artifacts like serial correlations or biases. For example, a 2025 deep learning framework uses CNN-LSTM hybrids to evaluate true RNGs (TRNGs) and pseudo-RNGs (PRNGs), achieving higher sensitivity to deviations than NIST SP 800-22 by scoring predictability on binary streams, with reported accuracy exceeding 95% in distinguishing random from patterned data.^[60] Similarly, 2024 studies applied neural networks to assess QRNG raw outputs, quantifying vulnerability to prediction attacks before post-processing, where classical tests passed but ML detected residual predictability at rates up to 10% above baseline.^[61] These methods complement suites like Dieharder by flagging anomalies in high-entropy but subtly structured sources, though they require large training datasets to avoid overfitting. High-dimensional testing has evolved to validate vector RNGs used in multidimensional simulations, extending classical spectral tests—which measure lattice structure in linear congruential generators (LCGs)—to multivariate cases. In low dimensions, the spectral test computes the maximum discrepancy between generated points and a hyperplane, but for vectors in dimensions d > 10 (common in Monte Carlo simulations), direct computation becomes infeasible due to exponential complexity. Recent extensions, such as those for MIXMAX PRNGs, adapt the test by projecting onto subspaces or using Fourier analysis to assess uniformity in up to d=100, revealing hyperplane clustering that indicates poor randomness; for instance, these methods confirmed MIXMAX's superior performance over Mersenne Twister in 12-dimensional uniformity, with spectral figures of merit improved by factors of 10.^[62] Multivariate generalizations incorporate principal component analysis to detect correlations across vector components, ensuring suitability for applications like financial modeling where non-uniformity amplifies error in high-d spaces.^[63] Post-processing validation has become essential for verifying extractors like von Neumann debiasers, which mitigate biases in raw RNG outputs by pairing bits and discarding unequal pairs, yielding unbiased but lower-rate streams. Testing focuses on confirming independence and uniformity after extraction, using suites like NIST SP 800-22 on debiased data; a 2024 study implemented von Neumann and other extractors on RNG outputs, evaluating improvements in statistical properties via NIST tests, with extraction efficiencies up to 50% for certain sources.^[64] These validations ensure post-processing does not introduce new dependencies, as seen in high-throughput variants achieving gigabit rates while maintaining statistical randomness.^[65] In the 2020s, hybrid suites integrating classical and AI methods have emerged as AI-augmented test batteries, combining statistical batteries with neural predictors for comprehensive evaluation. These frameworks run parallel assessments—e.g., spectral and entropy tests alongside ML predictability scores—enhancing detection in complex sources. For blockchain RNG validation, advances incorporate verifiable random functions (VRFs) like Chainlink's, tested via hybrid methods to ensure on-chain randomness resists manipulation, with statistical suites confirming uniformity in decentralized outputs for applications like lotteries.^[66]

References

[1]
[PDF] A Statistical Test Suite for Random and Pseudorandom Number ...
The NIST Statistical Test Suite supplies the user with nine pseudo-random number generators. A brief description of each pseudo-random number generator follows.
[2]
21.2 - Test for Randomness | STAT 415
A common application of the run test is a test for randomness of observations. Because an interest in randomness of observations is quite often seen in a ...
[3]
[PDF] Randomness and Pseudorandom Number Generators
Nov 7, 2023 · First, we will begin by exploring what it means to be a random number and what it means to be a pseudorandom number. Then, we will extend this ...
[4]
Karl Pearson and the Chi-Squared Test | SpringerLink
This historical and review paper is in three parts. The first gives some brief details about Karl Pearson. The second describes in outline the 1900 paper.
[5]
Robert G. Brown's General Tools Page - Duke Physics
Dieharder: A Random Number Test Suite. Version 3.31.1. Robert G. Brown (rgb). Dirk Eddelbuettel. David ...
[6]
[PDF] Analysis of Statistical Properties of Inherent Randomness - OSADL
An ideal random number generator is characterized by the property that the random numbers it gener- ates are independent and uniformly distributed on a finite ...Missing: uniformity | Show results with:uniformity
[7]
The Art of Computer Programming: Random Numbers - InformIT
Jun 23, 2014 · Knuth introduces the concept of random numbers and discusses the challenge of inventing a foolproof source of random numbers.
[8]
[PDF] CS 252, Lecture 4: Kolmogorov Complexity
Feb 6, 2020 · A string x is incompressible or Kolmogorov random if K(x) ≥ |x|. Note that there exist incompressible strings of every length: there are 2n ...
[9]
[PDF] Linear congruential generators do not produce random sequences
) Knuth (Vol. 2) contains an elaborate discussion of linear congruential generators. (LCG). The sequences produced by LCG's have been shown to satisfy ...
[10]
[PDF] Recommendation for the Entropy Sources Used for Random Bit ...
The initial entropy estimate of the noise source is calculated as HI = min (Horiginal, n×Hbitstring,. Hsubmitter) for non-binary sources and as HI = min ( ...
[11]
[PDF] Statistical Testing of Cryptographic Randomness - DergiPark
A randomness test of an RNG is conducted at two stages. At the first stage ... The most common solution of multiplicity problem is to use a Bonferroni correction ...
[12]
https://dergipark.org.tr/tr/download/article-file/461466
[13]
https://doi.org/10.6028/NIST.SP.800-22r1a
[14]
[PDF] JDiehard: An implementation of Diehard in Java
George Marsaglia's Diehard battery of tests are widely used to certify random number generators as being worthy of use in serious research. They became well ...
[15]
[PDF] DieHarder: - GitHub Pages
For roughly a decade, the most often cited test suite of this sort is one developed by George Marsaglia known as the “Diehard Battery of Tests of Randomness”[?] ...Missing: 1995 | Show results with:1995
[16]
Decision to Revise NIST SP 800-22 Rev. 1a
Apr 19, 2022 · NIST plans to include an emphasis on stochastic models in later revisions of the SP 800-90 series. The effort to revise SP 800-22 will follow ...Missing: 2020s | Show results with:2020s
[17]
Raw QPP-RNG randomness via system jitter across platforms - Nature
Jul 29, 2025 · High-quality randomness is fundamental to the security of modern cryptographic systems ... bias exploitation. As part of this effort, the Quantum ...
[18]
[PDF] Implementation Guidance for FIPS 140-3
Sep 21, 2020 · Depending on the guidance, testing may be targeted to a subset of the physical test requirements for the claimed security level. In such ...
[19]
FIPS 140-3, Security Requirements for Cryptographic Modules | CSRC
The security requirements cover areas related to the secure design, implementation and operation of a cryptographic module. These areas include cryptographic ...Missing: RNG statistical suite passage
[20]
[PDF] Statistical Analysis of Synchronous Stream Ciphers - ECRYPT
In this study, six new statistical randomness tests are proposed, four of them are applied to the synchronous ciphers presented for ECRYPT. Some deviations ...
[21]
[PDF] Testing the Randomness of Cryptographic Function Mappings
Jan 23, 2019 · Widely used statistical test suites include Diehard. [16], Dieharder ... block test's log odds ratios and reports the sum as the test result.
[22]
[PDF] NIST Cryptographic Standards and Guidelines Development Process
Jul 14, 2014 · In 2006, researchers showed that the output of DUAL_EC was biased so that DUAL_EC failed to pass statistical tests for randomness. This ...
[23]
[PDF] The NIST SP 800-90A Deterministic Random Bit Generator ...
Oct 29, 2015 · The DRBGVS consists of a single test that determines if the DRBG implementation produces the expected random bit output given a set of entropy ...Missing: 2010 | Show results with:2010
[24]
[2409.11539] Effects of the entropy source on Monte Carlo simulations
Sep 17, 2024 · In this paper we show how different sources of random numbers influence the outcomes of Monte Carlo simulations.Missing: tests | Show results with:tests
[25]
Properties making a chaotic system a good pseudo random number ...
Jul 29, 2005 · ... molecular dynamics ... In particular we will discuss the connection between correlation functions and the spectral test for random sequences
[26]
[PDF] arXiv:nlin/0503035v2 [nlin.CD] 12 Aug 2005
In most scientific uses of numerical computations,. e.g. Montecarlo simulations and molecular dynamics, ... functions is the spectral test. We start defining the ...<|separator|>
[27]
Climate‐change modelling at reduced floating‐point precision with ...
Feb 17, 2023 · Furthermore, since stochastic rounding naturally requires random number generation, it is likely more expensive than a deterministic process.
[28]
[2306.14043] Machine Learning needs Better Randomness Standards
Jun 24, 2023 · Randomness supports many critical functions in the field of machine learning (ML) including optimisation, data selection, privacy, and security ...
[29]
Quality of random number generators significantly affects results of ...
We have simulated pure liquid butane, methanol and hydrated alanine polypeptide with the Monte Carlo technique using three kinds of random number generators.
[30]
[PDF] TestU01: A C Library for Empirical Testing of Random Number ...
We introduce TestU01, a software library implemented in the ANSI C language, and offering a collection of utilities for the empirical statistical testing of ...
[31]
[PDF] identifying quality mersenne twister streams for parallel stochastic ...
In this paper, we have selected the TestU01 Big Crush test battery. We will use TestU01 tests for either sequences of uniform random numbers in [0,1] (as ...
[32]
TestU01: A C library for empirical testing of random number generators
We introduce TestU01, a software library implemented in the ANSI C language, and offering a collection of utilities for the empirical statistical testing of ...
[33]
TestU01
Aug 18, 2009 · TestU01 is a software library, implemented in the ANSI C language, and offering a collection of utilities for the empirical statistical testing of uniform ...Missing: pre- simulation validation
[34]
umontreal-simul/TestU01-2009 - GitHub
Aug 18, 2009 · This is the 2009 version of TestU01, a software library, implemented in the ANSI C language, and offering a collection of utilities for the ...Missing: pre- simulation validation
[35]
Debian -- Details of package dieharder in sid
Random-number generator test front-end. dieharder is a fairly involved random number/uniform deviate generator tester. It can either test any of its many ...<|separator|>
[36]
SP 800-22 Rev. 1, A Statistical Test Suite for Random and ...
This paper discusses some aspects of selecting and testing random and pseudorandom number generators. The outputs of such generators may be used in many ...
[37]
Documentation and Software - Random Bit Generation | CSRC
April 27, 2010: NIST SP 800-22rev1a (dated April 2010), A Statistical Test Suite for the Validation of Random Number Generators and Pseudo Random Number ...
[38]
Ent (GNU cryptographic primitives and tools, version 2.0.0)
crypto.tool. Class Ent ... This is a Java implementation of Ent (A Pseudorandom Number Sequence Test Program) developed by John Walker) which applies various ...
[39]
CRAN: Package randtests
Apr 23, 2024 · randtests: Testing Randomness in R. Provides several non parametric randomness tests for numeric sequences. Version: 1.0.2. Published: 2024-04 ...
[40]
[PDF] randtests: Testing Randomness in R
Testing randomness in R. Description. The package randtests implements several nonparametric randomness tests of hypothesis. Details. Package: randomtests. Type ...
[41]
randtests package - RDocumentation
Jun 20, 2022 · randtests (version 1.0.1). Testing Randomness in R. Description. Provides several non parametric randomness tests for numeric sequences.
[42]
stevenang/randomness_testsuite: This is a Python ... - GitHub
This is a Python implementation of NIST's A Statistical Test Suite for Random and Pseudorandom Number Generators for Cryptographic Applications.
[43]
diehardest - Rust - Docs.rs
A new approach to randomness testing. Diehardest is a small library providing strong tools to rate quality of pseudorandom streams.
[44]
A python tool used to run statistical tests on random data. - GitHub
Random Test Tool (also refered RTT) is a Python script designed for testing the randomness of sequences of integers or bits.
[45]
RDieHarder: R Interface to the 'DieHarder' RNG Test Suite
Jun 1, 2007 · The RDieHarder package provides an R interface to the DieHarder suite of random number generators and tests that was developed by Robert G.Missing: integrating | Show results with:integrating
[46]
[PDF] A Proposal for Functionality Classes for Random Number Generators
Sep 2, 2022 · 4 This document is the mathematical-technical reference of both AIS 20 [AIS20] and AIS 31 [AIS31]. It is intended for developers, evaluators ...
[47]
Statistical Analysis - RANDOM.ORG
RANDOM.ORG is a true random number service that generates randomness via atmospheric noise. This page describes the statistical analyses that have been ...
[48]
runstest - Run test for randomness - MATLAB - MathWorks
This MATLAB function returns a test decision for the null hypothesis that the values in the data vector x come in random order, against the alternative that ...
[49]
Statistics and Machine Learning Toolbox - MATLAB - MathWorks
Statistics and Machine Learning Toolbox provides functions and apps to describe, analyze, and model data. You can use descriptive statistics, visualizations ...
[50]
Quantis QRNG PCIe - Random Number Generator - ID Quantique
Quantis QRNG PCIe is a high performance PCIe Quantum Random Number Generator, with embedded NIST compliant post-processing.Missing: 2020s | Show results with:2020s<|control11|><|separator|>
[51]
Quantum Random Number Generation (QRNG) - ID Quantique
Quantum Random Number Generation (QRNG) generates random numbers with a high source of entropy using unique properties of quantum physics.Missing: 2020s | Show results with:2020s
[52]
Further analysis of the statistical independence of the NIST SP 800 ...
Dec 15, 2023 · This paper describes a series of experiments aimed at scrutinizing dependencies among the statistical tests in the NIST SP 800-22 suite.
[53]
[PDF] Study on upper limit of sample size for a two-level test in NIST ...
A practical upper limit of the sample size is proposed in this two-level test for pseudorandom number generators, for each of six tests appeared in SP800-22 ...
[54]
None
Summary of each segment:
[55]
Quantis QRNG Chip receives NIST Entropy Source Validation (ESV ...
Sep 20, 2023 · NIST has verified that the random bits produced by the Quantis QRNG chips are independent and uniformly distributed. The independence property ...Missing: guidelines | Show results with:guidelines
[56]
Observations on NIST SP 800-90B entropy estimators
Jan 30, 2025 · This paper evaluates the effectiveness and limitations of the SP 800-90 methods by exploring the accuracy of these estimators using simulated random numbers ...
[57]
A novel deep learning-based statistical randomness evaluation test ...
Oct 17, 2025 · Although the present study focuses on evaluating the randomness of TRNG and PRNG outputs using deep learning models, the conceptual parallels ...
[58]
https://www.idquantique.com/qrng-chip-nist-certification/
[59]
[PDF] Spectral Test of the MIXMAX Random Number Generators - arXiv
Nov 19, 2018 · The test is aimed at answering the question of distribution of the generated pseudo-random vectors in dimensions d that are larger than the ...Missing: multivariate | Show results with:multivariate
[60]
[PDF] Testing Random Number Generators - Winter Simulation Conference
Repeat n times and compare the distribu- tion of those n values of r with the theoretical distribution via a chi-squared test. ... The birthday spacings test is ...<|control11|><|separator|>
[61]
High-throughput Von Neumann post-processing for random number ...
Jun 5, 2018 · This paper presents the improvement and implementation of N bits Von Neumann (VN_N) post-processing technique, which is used to produce ...
[62]
35+ Blockchain RNG Use Cases Enabled by Chainlink VRF
May 20, 2024 · A collection of use cases across blockchain gaming, NFTs, and DeFi powered by Chainlink VRF's fair and transparent RNG.