There have been several approaches to pseudorandom number generation before the introduction of Machine learning. These traditional PRNGs formed the basis of random number generation today.

Chaos-based pseudorandom number generators (PRNGs) exploit the inherent unpredictability of nonlinear dynamical systems to produce sequences that mimic randomness while remaining deterministic. These systems are characterized by sensitivity to initial conditions, aperiodicity, and complex trajectories in phase space, making them suitable for applications requiring high-security and statistical robustness. Below, we delineate the principal mechanisms underpinning chaos-based PRNGs, emphasizing their mathematical foundations, operational characteristics, and practical implications [25].

This section discusses the various machine learning approaches including the data types required and their respective learning goals.

Atee et al. [37] proposed a Sub Key Generation approach using Extreme Learning Machine (ELM) for neural network hidden layer. Their approach incorporates the Artificial Neural Network topology, seeds for pseudo random number generation and activation function in the primary key. This method begins with defining the key as K={k1,k2,k3,…,kn}, where n is the number of keys (in this case n = 15). The first five elements determine the ELM’s topology, including the number of inputs, outputs, activation function type, hidden layer neurons, and data size. The remaining elements of the key are used as seeds for generating sub-keys in each round. The process involves generating input layer weights using these seeds and calculating output layer elements to form sub-keys. This approach generated sub keys with higher sensitivity and reduced computational time which appears to be efficient but requires more testing within a complete cryptosystem to validate its efficiency.

Lokesh and Kounte [38] proposed a Pseudo random number generator that uses a four–layer neural network with chaotic maps like cubic and piece–wise linear chaotic maps. Their approach initializes weights, generate control paraments and iterate through the neural network to produce the output sequences. This approach is simple and fast, making it suitable for real time applications. However, the complexity of neural networks combined with chaotic systems require high computational resources for implementation.

Machicao and Bruno [39] proposed a generalized method for a reliable Pseudorandom generator based on the digit precision of the chaotic discrete orbit points that is also called Deep-Zoom. Their work improved upon various properties of PRNGs such as uniform distribution, higher length period and randomness to ensure the security of the cryptosystems. Their approach improved the randomness of chaotic maps as compared to some traditional PRNGs, but its efficiency depends on the initial parameter and also requires high precision computing which is difficult to implement.

Gayoso et al. [40] proposed a generalized construction method of Pseudo Random Number Generators in that, each small pseudo generator is considered as a neuron of the Hopfield Neural Network. This approach used the Residue Number System in arithmetic calculations for every feedback line to incorporate nonlinearity in test system and to claim binary representations for small number of bits. The efficiency of this approach lies in the parallel operating property of RNS in various channels without data transformation, which results in higher speed and provides better randomness of PRNGs. But there are implementation challenges due to the introduction of RNS and further analysis need to be done on the practical application for further validation.

De Bernardi et al. [5] presented a new Machine learning based approach which uses the Generative Adversarial Networks to impactfully train the neural network to act as PRNG as shown in Fig. 1. This was done by partly concealing the outcome and training the adversary to map the concealed portion. Thus, the generator learned to generate unpredictable random sequences. The researcher demonstrated that, GAN can effectively train even a small feed-forward fully connected neural network to produce pseudo-random number sequences with good statistical properties. This approach produced sequences that pass around 99% of test instances using the NIST test suit. However, only statistical analysis was used to access the quality of PRNGs and this may require further cryptanalysis of the implementation.

Alloun et al. [41] proposed a pseudorandom number generator by fusing the sensitive dynamics of the Lorenz chaotic system and the modelling capacity of an artificial neural network (ANN). They first solve the Lorenz differential equations with a fourth-order Runge–Kutta scheme to create a rich training corpus of state triples (x, y, z). A compact fully connected network (3-8-8-3 topology, ReLU activations, RMSprop optimiser, 10 epochs) is then taught to predict the next Lorenz state from the current one, reaching a validation loss of 2.37 × 10^–7. During sequence generation only the fractional part of each 32-bit floating-point output is retained and concatenated, thereby suppressing amplitude-related correlations and yielding a binary stream. The proposed generator exhibits several notable strengths. Statistically, the bit-stream passes all sub-test in the NIST SP 800-22 battery, from monobit frequency to random-excursions variants. Security-wise, replacing the seven-parameter Lorenz key with 115 learned weights inflates the effective key-space from 2²²⁴ to 2³⁶⁸⁰ which is an increase of roughly 3.6-fold over the best prior Lorenz-ANN design. The authors also argue that the neural surrogate inherits the noise immunity and parallel-friendly nature of ANNs, making the scheme attractive for high-throughput hardware deployments. Because the network is trained on a single set of Lorenz parameters, its unpredictability outside that operating point remains untested as the authors acknowledge residual errors between ANN output and the reference solver (RMSE up to 0.63). Cryptanalytic metrics, such as period length, linear complexity under keyed attack, or resistance to side-channel leakage, are left unexplored. Computational overhead of forward passes and IEEE-754 bit manipulation may offset the statistical gains in resource-constrained environments.

Hu et al. [42] proposed another machine learning based pseudorandom number generator using Cellular Neural Network that possesses hyper chaotic behavior which is ideal for initial parameters to the PRNGs. This approach offers secured randomness, simple operation, increased length of the sequence, and increased search space but also has several chaotic iterations leading to high cost of computation.

Reddy et al. [43] presented a machine learning based cryptographic system that relies on Hybrid Key generation approach and biographically inspired DNA system using genetic encoding, transcription and translation. The researchers made use of a Bidirectional Associative Memory Neural Network (BAMNN) as a memory storage for the generated keys to train the NN and Whale Optimization Algorithm (WOA) for weight factor in the neural network as shown in Fig. 2. This approach enhanced security, but the complexity of the system makes it challenging to implement as it requires high resources for key generation and encryption process.

Pasqualini and Parton [44] developed a Pseudo random generator based on the reinforcement learning method (Fig. 3) and Long-Short Term Memory (LSTM). This approach models the PRNG as a partially observable Markov Decision Process (MDP). This approach improved the properties of the generated sequence as compared to other models, but it involves a highly complex RL algorithms and neural network architecture which makes it challenging to implement. Also, action space grows exponentially with length of generated sequence making scalability difficult beyond certain limits.

Pasqualini and Parton [8] also used a machine learning technique for producing Pseudo Random Number Generator from base level. The researchers used the Reinforcement Learning (RL) approach wherein PRNGs could be learned to improved generated sequence for every iteration that solves N-dimensional navigation problems, where N is the length of the desired sequence to be generated. Their approach improved accuracy and efficiency of predictive models but requires large amount of labeled data and risks overfitting.

Lin et al. [9] developed a scheme of the symmetric cryptography by the integration of Chaotic map and Multilayer Machine Learning Network (MMLN), where the chaotic map proactively generated the dynamic pseudo random sequences with the unique control parameters and provided fastest key generation for the real-world implementations. Their work made an efficient MMLN to train the cipher code protocol by an optimization algorithm to create an encrypted network in cryptosystem with high confidentiality, recoverability and large information transition. But the performance of this model is significantly influenced by the initial parameters used.

Park et al. [6] proposed a Dynamic pseudorandom generator that uses a machine learning technique called Reinforcement Learning to choose the best characters to ensure the random property of the generated number sequences in every possible way by optimization. They incorporated the Long Short-Term Memory (LSTM) to provide the long-term memory to hold the previous patterns and feature vectors that are extracted by convolutional NN to generate the random numbers as shown in Fig. 4. Evaluation of this approach showed improved randomness of generated sequence, but this approach contains complex structures with several parameters which makes it require high computational resources.

Patel and Thanikaiselvan [45] proposed a Pseudo random number generator using Latin Square and Machine learning neural network technique to propose an image encryption algorithm. The researcher made use of Latin square to model cryptographic key images in the finite field then XOR with the input matrices to extract encrypted images and GA to preserve the best encrypted image search. This approach secures multimedia data during transmission and resistant to various attacks. However, the proposed random number generator requires further evaluation to access its efficiency.

Okada et al. [7] presented a Learned pseudorandom number generator using Wasserstein Generative Adversarial Network (WGAN) and Mersenne Twister (MT) pseudorandom generator. The researchers used the MT to generate an inexhaustible sequence of random numbers to train the WGAN model. The learning is done without any arithmetic programming code implementations. The experimental results show improved randomness and robustness of the proposed learned PRNG, and that enhances unpredictability for the safety information systems. But this approach is prone to overfitting after 450,000 iterations after extensive training with huge amounts of data.

Traditional algorithmic PRNGs (e.g., linear congruential generators or Mersenne Twister) are well-studied and generally provide high-quality uniform randomness for simulation purposes. They have long been tuned to pass standard statistical test suites (with Mersenne Twister achieving a period of 219937−1 and excellent distribution properties). However, some simpler traditional generators exhibit statistical biases or correlations, and even high-quality classical PRNGs are deterministic, making them predictable if an adversary can infer their internal state. Chaos-based PRNGs leverage nonlinear dynamical systems (such as logistic maps or chaotic oscillators) to generate complex, ergodic sequences that appear random. Many chaos-based generators have demonstrated good statistical randomness (often able to pass NIST and Diehard tests) when carefully parameterized, essentially treating the chaotic trajectory as a source of pseudorandom bits [47]. ML-based PRNGs are a recent innovation; studies have shown that they can achieve randomness quality on par with or even surpass classical algorithms. For example, De Bernardi et al. [5] trained a neural network via a Generative Adversarial Network (GAN) to behave as a PRNG, and the resulting generator passed ~98% of NIST test suite evaluations – outperforming several standard non-cryptographic PRNGs. Similarly, reinforcement learning approaches have been used to evolve PRNGs that maximize statistical randomness. Park et al. [6] report that their LSTM–CNN–based RL generator achieved higher NIST scores for 800-bit sequences than a baseline method, with the generated sequences exhibiting extremely low inter-sequence correlation (~19% maximum similarity). Such results underscore that ML-based methods can produce output sequences indistinguishable from ideal randomness in standard statistical metrics. Nonetheless, pure statistical testing is not a sufficient validation of randomness quality for all purposes especially cryptographic ones, so these outcomes, while promising, must be interpreted in context.

Despite high aggregate test scores, each paradigm has nuances in randomness quality. Traditional PRNGs are designed with mathematical guarantees for distribution uniformity and long periods, but their linear structures can cause subtle patterns (e.g., the spectral patterns in linear congruential generators). Chaos-based generators introduce nonlinearity and high sensitivity to initial conditions, which generally enhances unpredictability; yet finite-precision implementations of chaotic maps can sometimes lead to short cycles or mild biases if not designed carefully. Indeed, the chaotic “randomness” is contingent on system parameters – poorly chosen parameters can degrade randomness, while well-chosen chaotic systems yield competitive randomness suitable even for encryption and image processing applications [47]. ML-based PRNGs, being data-driven, do not rely on explicit formulae at all—they learn to emit statistically random sequences. This data-driven nature means they can, in theory, approximate extremely complex distributions. Empirical evidence (e.g., GAN-based generators) shows that a sufficiently trained neural model can reproduce the statistical properties of true random sources or robust classical PRNGs [5]. One advantage is that ML methods can be trained or tuned to target the passing of specific randomness test batteries, effectively “learning” to avoid known statistical pitfalls. However, there is also a danger of overfitting to test suites. A model might learn to pass known tests while still harboring undetected patterns. Overall, all three approaches can achieve excellent randomness quality with careful design, but ML-based methods are notable for achieving this without requiring an explicit algorithmic structure, instead leveraging the capacity of neural networks to mimic randomness.

The complexity of PRNG design and its computational efficiency vary greatly across the three paradigms. Traditional PRNGs are typically lightweight in terms of algorithmic complexity. They often consist of simple arithmetic or bitwise operations (e.g., linear recurrences, bit shifts, or Xorshift operations), making them extremely fast and resource-efficient. This simplicity translates to low computational overhead per random number generated—a crucial factor for applications requiring billions of random samples. Because their behavior is well-understood, traditional generators can be implemented in hardware or optimized at the instruction level to further improve throughput. The trade-off for this simplicity is that the generator’s statistical properties are fixed once the algorithm is chosen; improving their randomness often requires deep mathematical analysis or developing a new algorithm altogether. Chaos-based PRNGs tend to be more complex in design, as they derive from nonlinear iterative equations or differential equations. Implementing a chaotic map like the logistic map or a higher-dimensional chaotic system involves iterative floating-point computations. In practice, a chaos-based generator might require multiple iterations per output or high-precision arithmetic to maintain chaotic behavior, making them moderately more computationally expensive than linear PRNGs. However, many chaotic maps are still relatively simple functions (e.g., polynomial maps, piecewise linear functions), so software implementations can often generate millions of values per second, and hardware implementations (analog or digital) can exploit inherent parallelism. The complexity here lies more in analysis—understanding and tuning the chaotic system— than in runtime cost. ML-based PRNGs, on the other hand, introduce significant complexity both in design and execution. Designing an ML-based generator involves training a neural network or reinforcement learning agent, which is a computationally intensive process requiring large datasets of random numbers or numerous training episodes. References [8,9] noted that their deep reinforcement learning approach had to navigate a huge search space and was limited by training instability for long sequences, ultimately managing sequences up to 1000 bits long in their recurrent model [44]. The generation phase of an ML-based PRNG (after training) involves forward passes through a network (e.g., an RNN or GAN generator). This is markedly slower than a few arithmetic operations; for instance, generating a single number might require matrix multiplications and nonlinear function evaluations in a neural net. Reference [7] report that although their WGAN-based generator could produce high-quality outputs, the model began to overfit after ~450,000 training iterations. An indication of the immense training effort and the delicate balance in model complexity. Thus, while runtime generation from a trained model can be made reasonably fast with modern hardware (potentially leveraging GPU parallelism to produce many random numbers in batch), it is still generally less efficient than traditional PRNGs, especially on general-purpose CPU architectures.

Scalability is another critical aspect. The ability of a PRNG to produce long sequences (or many parallel sequences) without degradation. Traditional PRNGs excel in this regard—algorithms like Mersenne Twister are explicitly engineered for astronomically long periods, and multiple independent streams can be created via different seeds or algorithmic variants. They also have well-understood scaling in parallel environment. For example, leap-frog or sequence splitting techniques allow traditional generators to be used in multi-threaded simulations with minimal overlap. Chaos-based PRNGs can also produce long sequences, but their effective period is bound by the precision of the arithmetic and the nature of the map. A chaotic sequence in real arithmetic never repeats, but in finite precision it will eventually cycle. In practice, well-designed chaotic systems can achieve very long cycle lengths (comparable to traditional PRNG periods) if implemented with high precision or by combining multiple chaotic elements. Recent work has explored coupled map lattices and higher-dimensional chaotic systems to boost complexity and reduce the likelihood of short cycles [47], Still, ensuring truly long-term decorrelation in chaos-based generators can be challenging without resorting to large state representations (akin to large PRNG state in classical methods). ML-based PRNGs face unique scalability challenges. A neural network has a fixed number of parameters and (for many designs) a fixed input size, which might implicitly limit the period or the amount of randomness it can produce before repeating patterns. Recurrent neural network-based PRNGs, like the one by Pasqualini & Parton, effectively carry state in their hidden layers, but as noted, the model they used did not scale well beyond sequences of 1000 bits without retraining [44]. This suggests that scaling an ML-based PRNG to arbitrarily long sequences could require increasing model complexity (more layers or neurons) or using streaming strategies. On the upside, some GAN-based approaches operate in an “end-to-end” fashion and can generate outputs of arbitrary length by sequentially applying the network to generate blocks of bits, though ensuring that the concatenated output remains random over very long stretches is an open question. Another aspect of scalability is the ability to produce many random streams in parallel: an ML model could in principle be replicated or vectorized to produce multiple streams, but this multiplies the resource usage (memory for multiple models or larger batch computations). Researchers are beginning to address this. For example, Kim et al. [48] integrated an RNN-based generator into an edge computing platform, demonstrating that with model optimization, even resource-limited devices (like those in Internet-of-Things scenarios) can run ML-based PRNGs efficiently. Such efforts indicate that while ML-based PRNGs are currently heavier, there is room for optimization (pruning, quantization, or specialized hardware acceleration) to narrow the efficiency gap. In summary, traditional PRNGs offer simplicity and speed with proven large-scale performance, chaos-based PRNGs introduce moderate complexity with acceptable efficiency and unique state-space properties, and ML-based PRNGs incur high complexity and computational cost but open the door to generating randomness through learned behavior–at the expense of careful scaling considerations.

Security, meaning resistance to prediction or manipulation is a crucial consideration for PRNGs, especially in cryptographic contexts. Traditional PRNGs vary widely in security. Non-cryptographic PRNGs (like linear congruential or Mersenne Twister) are not intended to be secure. Their internal state can often be inferred from a segment of output (for example, observing 624 outputs of Mersenne Twister allows exact prediction of all future outputs, due to its linear structure). Cryptographically secure PRNGs (CSPRNGs), on the other hand, are designed so that predicting future bits is computationally infeasible without knowing a secret seed. They achieve this by using one-way functions or cryptographic primitives, e.g., using block cipher or hash function outputs as the random sequence. These are still “traditional” in design but sacrifice some performance for security guarantees. Chaos-based PRNGs were once hoped to naturally provide cryptographic-strength secrecy because chaos is unpredictable in theory. However, practical analyses have revealed that deterministic chaotic systems can still be attacked if an adversary has partial information. According to Al-Daraiseh et al. [47], Yeniçeri et al. [49] demonstrated a concrete attack on a time-delay chaos-based RNG by synchronizing to its trajectory—effectively predicting future values by coupling a replica system once a few outputs were known. Other cryptanalyses of chaos-based schemes have identified weaknesses such as short cycles, phase space leakage, or insufficient complexity, and have broken proposed chaotic ciphers by exploiting those flaws. These findings underscore that chaos alone does not guarantee security; a chaotic PRNG must be carefully analyzed just like any other, and often additional techniques (e.g., perturbing the chaotic process with external entropy or using compound chaos systems) are needed to approach cryptographic security. Recent chaos-based designs have started to incorporate such improvements. For instance, using multiple coupled chaotic maps with adaptive parameters to expand the key space and thwart synchronization attacks. The explainability of traditional and chaotic PRNGs is relatively high. Their mechanisms are given by mathematical formulas, so one can in principle trace how an output is produced from the seed and analyze the transformation. This transparency aids in security analysis (finding linearity, biases, etc.). At the same time, that transparency can be a double-edged sword as it makes it easier for attackers to understand the generator’s structure. Security for classical PRNGs thus comes from proven difficulty of inverting or analyzing the function (as in CSPRNGs), rather than secrecy of the algorithm.

ML-based PRNGs introduce new dynamics for security and explainability. On one hand, they are black boxes by nature—a neural network’s logic is encoded in millions of weights rather than a simple formula, which can obscure any underlying patterns. Proponents of ML-based PRNGs have argued that this complexity can enhance security: the generator may have no simple mathematical structure to exploit, and if the model is large and proprietary, an adversary would find it hard to reverse-engineer. For example, Park et al. [6] assert that tracking the operations of their deep learning model (with parameters adaptively changing via reinforcement learning) is practically impossible, hence the pattern of random bits cannot be discerned by an attacker. ndeed, an RL-based approach that continually updates its parameters could thwart an adversary’s attempt to lock onto a moving target. Additionally, De Bernardi et al. [5] took an adversarial training approach to security by concealing a portion of the generator’s output bits and training a discriminator to predict them, they forced their GAN-based generator to produce outputs that an AI adversary could not reliably predict. This innovative method essentially built a cryptographic mindset into the training process, aiming to maximize unpredictability, not just match a distribution. These examples show how ML methods can be tailored for security considerations in ways that classical PRNGs are not. However, caution is warranted. The lack of explainability of ML models makes it difficult to prove any security property. A neural network might inadvertently learn some subtle internal pattern or state cycling that is not obvious to developers but could be learned by an attacker with enough samples. For instance, one could imagine training a secondary machine learning model on the outputs of a supposedly random generator to see if it can distinguish it from true random as a form of ML-based cryptanalysis. If that secondary model finds a predictor, it would indicate a flaw. At present, ML-based PRNGs have not undergone the decades-long scrutiny that traditional cryptographic PRNGs have. There is also the issue of the seed and model secrecy: if an adversary somehow obtains the trained model (weights) of an ML PRNG, the security might be compromised similarly to knowing the algorithm of a classical PRNG. The model could be simulated to predict future outputs unless it incorporates a hidden secret. This suggests that for an ML PRNG to be cryptographically secure, it might need to combine with traditional techniques. For example, using a secret cryptographic key either as part of the input or embedded in the network initialization so that even knowledge of the architecture doesn’t allow prediction without the key. As for explainability, ML models are currently largely opaque, which complicates both trust and debugging. Users and developers might not know why an ML-based generator produces a given sequence or how close it is to failing a certain randomness test. This stands in contrast to chaos-based systems, where one can often relate statistical properties to known chaotic parameters, or classical ones where theoretical analysis is possible. The community is beginning to address this by exploring interpretable models (e.g., smaller networks or ones with constrained structures) and by applying formal analysis to neural networks. For example, some researchers apply explainable AI techniques to gauge which parts of a network contribute to randomness, but this is an emergent area. In summary, ML-based PRNGs may ameliorate some traditional security issues (by embedding unpredictability in complex models) but lack the transparency that engineers and cryptographers are accustomed to, meaning extensive testing and new analysis methods are needed before they can be trusted in high-security applications [7]. At present, they should be used with caution in security-critical contexts until more cryptographic validation is performed.

Modern pseudorandom number generators (PRNGs), be they traditional, chaos-based, or machine learning–driven are evaluated not merely by their statistical performance but by how effectively they withstand adversarial scrutiny. This section provides an overview of the cryptanalytic challenges each PRNG category faces.

Deploying ML-based PRNGs in sensitive applications raises some ethical and practical considerations. The trustworthiness of randomness underpins fairness and security in many systems (lotteries, encryption, scientific experiments). If an ML-based PRNG has an undetected flaw, the impact could be severe. For example, an encryption system could be weakened without anyone realizing it because the randomness source was assumed to be secure. Ethically, developers have a responsibility to ensure that any AI-driven component (including PRNGs) is thoroughly vetted and monitored. There is also the aspect of accountability: if a cryptographic breach occurs due to an ML-generated sequence being predictable, who is accountable? The complexity of the model can make it hard to assign blame or to understand the failure. In applications like online gambling or lotteries, using an opaque ML-based RNG might lead to public mistrust, even if it’s technically sound, because stakeholders cannot easily verify its fairness. Transparency, or at least rigorous certification by independent parties, will be key in such domains.

Another ethical aspect is the potential for bias. While randomness by definition should be free of bias, a learned model might inadvertently incorporate biases from its training setup. For instance, if it was trained mostly to output certain patterns, it might unknowingly favor those. This is more relevant for pseudo-randomness when used in simulations or procedural generation (e.g., AI-based RNG in game content generation) – biases could skew results. Ensuring a broad and unbiased training input (potentially combining multiple randomness sources, including quantum or hardware randomness if available, to train the model) could mitigate this.

Finally, one might consider the ethical use of resources: training a large model to do what a few lines of code could already do (generate random numbers) might seem wasteful. In a time where energy efficiency is important, justifying the use of heavy computation for PRNGs requires that it offers a clear benefit (like significantly better security). This isn’t a traditional ethical issue, but it’s a practical one when considering deploying ML at scale.

The convergence of traditional, chaos-based, and ML-based PRNG research opens several promising paths. Going forward, researchers should aim to combine the strengths of these approaches while mitigating their weaknesses.

One challenge for ML-based PRNGs is their computational cost. Future work can focus on optimizing neural PRNG models for speed and low power usage, enabling deployment on IoT and edge devices. Techniques such as model pruning, quantization, and efficient hardware implementations (FPGA or ASIC designs for neural generators) could significantly reduce the gap in performance per bit generated. Recent results in deploying PRNGs on edge AI platforms suggest that even deep models can be trimmed or adapted for real-time use. Similarly, chaos-based generators can be optimized through digital hardware design or by identifying simpler chaotic functions that still provide strong randomness. Achieving near-real-time ML-based randomness without heavy hardware will broaden the applicability of these methods.

Rather than view the three categories in isolation, future PRNG designs might integrate them to leverage complementary advantages. For example, a hybrid generator could use a fast classical PRNG as a backbone and then feed its output into a chaotic or neural network transformation to “randomize the random”, adding an extra layer of nonlinearity and complexity to eliminate any residual structure. Conversely, chaos could be used as an inspiration for network design (e.g., neural networks that emulate chaotic maps) or as part of the training regime for ML models. Pasqualini and Parton [8] hint that their reinforcement learning formulation scales better with recurrent structures, which could be combined with chaos-based state updates to extend the period and complexity. There is also potential in evolutionary algorithms or genetic programming to evolve new PRNG algorithms (including neural network architectures) that human designers might not conceive, blending human insight with automated search. Additionally, a two-stage system could be envisioned: one stage (possibly chaos-based or classical) provides a stream of entropy, which a second stage (ML-based) adapts or enhances. This might ensure that even if one stage has weaknesses, the combination remains robust. Coupling mechanisms (such as feeding back output to adjust parameters on the fly) could also create a moving-target PRNG that is harder to analyze or predict. The challenge in hybrid approaches will be to keep the designs analyzable, hence balancing complexity with transparency.

As ML components become more common in PRNG design, improving their explainability will be crucial. Future research may explore interpretable ML models for randomness, For instance, using smaller networks with structure that can be mathematically related to known PRNG constructs. Another approach is to develop theoretical frameworks for analyzing the randomness of neural networks. This could involve treating a neural generator as a high-dimensional nonlinear dynamical system and studying its behavior with tools from chaos theory or information theory. By bridging the gap between the black-box nature of ML and the analytical rigor of traditional PRNG theory, we can build trustworthy random generators. Efforts like the adversarial training by De Bernardi et al. [5] highlight one path: using one part of the model to test another. Extending this, research could integrate real-time statistical testers or predictors into the PRNG system that continually ensure the output has no detectable patterns (an idea of self-monitoring PRNGs). Moreover, publishing negative results (e.g., discovered weaknesses of ML-based PRNGs) will be as important as positive results, to truly understand the failure modes and guide the design of explainable models.

Perhaps the most significant future direction is the rigorous cryptographic evaluation of novel PRNGs. For chaos-based and ML-based generators to be adopted in security-sensitive applications, they must undergo extensive testing beyond standard statistical suites. This includes cryptanalytic attacks: attempting to predict outputs, find correlations, or recover seeds using advanced methods. ML-based PRNGs present a new frontier for cryptanalysis—attackers might use machine learning themselves to find shortcuts or patterns. Future studies should simulate such scenarios: e.g., training a neural network to predict another neural network’s outputs, or using evolutionary strategies to search for weak seeds in a chaotic PRNG. In addition, formal proofs or reductionist security arguments (even limited ones) would greatly enhance confidence. This might involve proving that an ML-based PRNG, under certain assumptions, is equivalent to a known secure construction or does not reduce to a simpler predictable process. Validation standards may need to evolve as well. Just as the community developed the NIST test suite for statistical randomness, one could envision a benchmark suite for cryptographic randomness of ML/chaos PRNGs—including tests for sequence duplication (period finding), spectral analysis, mutual information, and resistance to ML-driven prediction. Cross-disciplinary collaboration between cryptographers, chaos theorists, and ML experts will be vital here. Park, Kim [6] and others have begun to claim cryptographic-level unpredictability for their methods, but independent verification and possibly certification (similar to FIPS certification for PRNGs) will be needed before widespread adoption. Future research might also explore post-quantum aspects of PRNGs—ensuring that the generator’s security holds even against quantum adversaries—an angle where chaotic and ML systems could offer new insights due to their complexity.