Which Ψ Framework Should You Use? Ψ-NN, Ψ-HDL, Ψ-xLSTM, or Ψ-Vortex?

As the Ψ-family has grown, a practical question has naturally appeared: with several related frameworks now available, which one should you actually use for a particular scientific or engineering problem?

The answer is not simply to choose the newest framework, because these methods are not redundant versions of the same idea. Each one was developed in response to a different limitation that became visible as physics structure-informed learning progressed from relatively simple structure discovery toward compact device modeling, recurrent temporal dynamics, latent-state inference, structural selection, and executable circuit models. Choosing the appropriate framework therefore depends on several factors at once, including the type of physics you want to represent, whether the system can be modeled pointwise or requires temporal state, how much manual structural configuration you want to retain, and whether your final objective is scientific interpretation, predictive modeling, compact-model generation, or deployment in an EDA and SPICE workflow.

There is also an important historical point that should be stated explicitly. This research direction did not begin with the methods I later developed. The conceptual starting point was Ψ-NN, introduced by Liu et al. in October 2025, and discovering that work was an important turning point in my own research because it showed that a physics-informed neural network could be treated not only as a function approximator, but also as a model from which compact structural organization could potentially be extracted. That idea became the foundation from which I began asking a sequence of increasingly engineering-oriented questions: could discovered structure be translated into a usable compact model, could the same principle be extended to systems in which temporal history is essential, and could recurrent structure eventually be selected, validated, compressed, and transferred into an executable circuit representation?

If you want the short answer before reading the full breakdown, the distinction is roughly this: if your problem is relatively simple, mostly steady-state, and your main objective is physics-informed structure discovery, start with Ψ-NN; if you want to convert discovered structure into a compact Verilog-A model for EDA and SPICE workflows, use Ψ-HDL; if the problem is dominated by fast transients, temporal memory, or recurrent dynamics, move to Ψ-xLSTM; and if you need history-dependent modeling together with latent-state inference, validation-controlled structural compression, reduced manual structure selection, and a path toward simulator-executable recurrent compact models within explicitly defined search bounds, then Ψ-Vortex, now published in IEEE Access, is the most appropriate of the four.

Ψ-NN: where the idea begins

The simplest place to start is Ψ-NN, the foundational framework introduced by Liu et al. in 2025, because it establishes the central idea on which the later developments build: instead of viewing a physics-informed neural network only as a flexible numerical approximation to a solution, Ψ-NN asks whether the trained network contains a smaller structural representation that can be identified, extracted, and reconstructed while preserving the relevant learned behavior.

This distinction is useful because conventional physics-informed learning is usually evaluated through quantities such as predictive error, residual satisfaction, or agreement with a reference solution, whereas the Ψ-NN perspective adds another question: after a model has learned the problem, does that model contain structural organization that can be separated from the unnecessary complexity used during training?

For relatively simple systems, especially problems dominated by steady-state, DC, quasi-static, or otherwise weakly history-dependent behavior, Ψ-NN remains the clearest entry point into physics structure-informed learning because it allows the structural-extraction concept to be studied without immediately introducing recurrent states, temporal continuity constraints, circuit-export logic, or a larger validation and structural-selection pipeline.

It is therefore a reasonable starting point when the purpose of the study is primarily to examine whether physics-informed training gives rise to compact internal organization, particularly when strong domain knowledge is already available and the researcher prefers to retain substantial manual control over architecture, hyperparameters, and subsequent structural interpretation.

From my own perspective, Ψ-NN is especially significant because it is where the intellectual lineage of the later Ψ-family begins. Discovering the work of Liu et al. made it possible to formulate the questions that eventually led to Ψ-HDL, Ψ-xLSTM, and Ψ-Vortex, so the later frameworks should be understood as extensions of that original concept rather than replacements for it.

Ψ-HDL: turning discovered structure into an engineering artifact

The next step is Ψ-HDL, which becomes relevant when the purpose of structure discovery is not only scientific interpretation, but also the creation of something that can be used by an engineer inside an established circuit-design workflow.

The central shift introduced by Ψ-HDL is that the output of the physics structure-informed learning pipeline does not remain only a compressed or interpretable neural representation. Instead, the discovered structure is carried toward compact device modeling and automated Verilog-A generation, creating a direct connection between scientific machine learning and circuit simulation.

The progression can therefore be viewed as: physics-informed learning → structure discovery → compact representation → Verilog-A → circuit simulation

This transition is important because a model that performs accurately inside a machine-learning environment is not automatically useful to a circuit designer. For many electronic-device applications, the model ultimately needs to be expressed in a form that can participate in DC or transient simulation, interact with other circuit components, and fit naturally into established EDA workflows.

Ψ-HDL therefore becomes especially appropriate when the behavior of interest can be represented without requiring a sophisticated recurrent internal state and when the principal engineering objective is to obtain a compact, deployable behavioral model rather than to maximize complexity in the underlying neural architecture.

It is also useful when model compression and deployment accounting are important design considerations, because the resulting compact representation can be examined not only in terms of numerical fidelity, but also in terms of parameter count, memory requirements, computational effort, and the implications associated with implementing or simulating the generated model.

For systems whose dominant behavior is low-frequency, steady-state, or only mildly history dependent, Ψ-HDL is therefore often the most direct route from a physics-informed neural representation to an engineering artifact. Applications beyond those explicitly demonstrated in the original study should still be evaluated independently, however, rather than assuming that the methodology will transfer without additional validation simply because the target system appears structurally similar.

Ψ-xLSTM: when temporal history becomes part of the model

The motivation for Ψ-xLSTM appears when the assumption that a system can be represented pointwise is no longer adequate, because many electronic devices are intrinsically history dependent and the same instantaneous input can correspond to different outputs depending on the internal state produced by previous excitation.

This becomes particularly relevant in fast-switching systems, transient device behavior, hysteretic systems, and other problems in which useful information is distributed over time rather than contained entirely in the current input sample.

There is also the issue of spectral bias. Standard multilayer-perceptron (MLP) backbones can learn smooth, lower-frequency components relatively efficiently while representing sharp transients or higher-frequency structure less efficiently, which can become a substantial limitation when those transients are central to the device behavior being modeled.

Ψ-xLSTM addresses this by extending the Ψ methodology toward recurrent temporal modeling using xLSTM-based architectures and Recurrent Relation-Aware Distillation, so that the compressed student is encouraged to preserve not only the teacher’s output behavior but also temporal relationships associated with recurrent dynamics.

It is therefore most appropriate when the target problem involves sharp transients, multi-timescale behavior, recurrent internal states, high-frequency dynamics, or temporal dependencies that would be lost if each sample were treated independently.

The trade-off is additional complexity, because recurrent training is computationally more demanding, architecture configuration becomes more consequential, and the structural extraction process still contains choices that require expert input, including aspects such as cluster configuration, matrix rank, and recurrent architecture design.

For that reason, Ψ-xLSTM should not be viewed as automatically preferable to Ψ-HDL whenever a device has a time axis. It becomes justified when temporal history is scientifically or numerically important enough that a pointwise representation would fail to reproduce the relevant dynamics.

If the central challenge is therefore transient fidelity and recurrent representation rather than systematic automation of the complete structural-selection process, Ψ-xLSTM directly targets that regime.

Ψ-Vortex: recurrent inference, validation-controlled structure selection, and circuit execution

Finally, there is Ψ-Vortex, now published in IEEE Access, which extends the recurrent branch of the Ψ-family by asking a more demanding question: if a system contains an internal interaction that is only indirectly observable through history-dependent trajectories, can a recurrent model recover that interaction under a chronology-safe evaluation protocol, can the resulting model be structurally compressed without using test data to make model-selection decisions, and can the selected recurrent representation ultimately be executed inside a circuit simulator?

For this reason, Ψ-Vortex should not be described simply as a more automatic version of Ψ-xLSTM. Its contribution is broader and is centered on making recurrent inference, structural selection, validation, compression, and deployment more explicit, reproducible, and resistant to common sources of leakage or overinterpretation.

The final framework combines chronologically ordered recurrent learning, source-disjoint training, validation, and test partitions, controlled recurrent-state handling, Recurrent Relation-Aware Distillation, a differentiable BIC-inspired complexity regularizer, validation-only cluster selection, bounded architecture evaluation, symmetry analysis, latent-coupling inference, and stateful Verilog-A export. The framework deliberately operates inside user-specified boundaries rather than claiming unrestricted automatic model discovery, which means that the physical problem definition, available data, candidate search space, training budget, operating regime, and validity boundaries remain explicit scientific choices.

One of the strongest methodological features is that recurrence is not assumed to be necessary simply because a recurrent architecture was selected in advance. Ψ-Vortex tests that assumption directly by comparing chronological recurrent learning against controls that deliberately remove the temporal information a genuinely history-dependent solution should require.

In the final study, chronological Ψ-Vortex passes all three nominal runs at the principal α=0.08 latent-coupling condition, while the state-reset, shuffled-order, and pointwise controls collectively pass none of nine runs. A chronological vanilla LSTM also performs strongly across the broader coupling sweep, passing 14 of 15 conditions, which leads to an important interpretation: the experimental evidence supports recurrence as the decisive property for the tested latent-coupling problem, rather than demonstrating that one specific recurrent cell is uniquely required.

This conclusion is more useful scientifically than claiming that only Ψ-Vortex’s particular recurrent architecture can solve the problem, because it separates the requirement for temporal state from the choice of recurrent implementation.

Latent thermal coupling within a bounded regime

Ψ-Vortex is motivated by a physical problem that becomes increasingly relevant in three-dimensional neuromorphic structures, namely the possibility that activity in one layer influences neighboring layers through thermal interactions that evolve over time and may not be directly observable through electrical terminals.

The broader motivation includes developments in massive multilayer printed structures, including demonstrations of signal transmission across very large numbers of layers, but this technological motivation must remain clearly separated from what the Ψ-Vortex experiments themselves evaluate.

The actual latent-coupling benchmark is a calibrated synthetic two-layer driver-victim scenario, representing an effective interaction between neighboring layers rather than an experimental reconstruction of an entire 1000-layer architecture.

Within this controlled synthetic benchmark, the model attempts to infer an effective thermal-coupling parameter from chronologically ordered electrical trajectories, and the resulting evidence deliberately defines a bounded validity range rather than implying universal recovery. Across the declared sweep, only α=0.05 and α=0.08 pass every seed, which means that the demonstrated result is latent-coupling recovery within specific tested conditions rather than a guarantee across arbitrary coupling strengths, device geometries, or multilayer configurations.

This distinction is essential because successful recovery of an effective latent parameter in a calibrated synthetic experiment does not automatically establish experimental identification of microscopic thermal interactions inside fabricated multilayer hardware.

Ψ-Vortex therefore demonstrates history-dependent latent-coupling inference within a bounded synthetic pairwise regime, while direct thermal-coupling validation on fabricated multilayer stacks remains an experimental step for future work.

Structural compression without test-set selection

Another important part of Ψ-Vortex is the way in which the compact recurrent student is selected, because model compression becomes scientifically difficult to interpret when the held-out test set indirectly influences decisions about architecture, cluster count, regularization strength, or other structural choices.

Ψ-Vortex instead uses validation data for structural selection and materializes the selected representation before final held-out testing and model export, thereby separating model selection from the evidence used to assess final generalization.

In the canonical synthetic experiment, the recurrent teacher is reduced from 26,273 expanded parameters to 273 expanded student parameters, corresponding to a 98.96% reduction in expanded parameter count, while the selected representation contains 16 centroid values.

Those 16 centroids require careful interpretation because they represent groups of shared learned parameter values inside the compressed recurrent model, but they do not establish the existence of 16 physical resistors, capacitors, thermal elements, or other equivalent-circuit components. Centroid count, expanded parameter count, memory requirements, serialized model size, and physical circuit topology are therefore different quantities and should be reported and interpreted separately. A compact neural representation can provide useful evidence about parameter organization and learned structural regularity without automatically providing a one-to-one decomposition of the physical system into individual circuit elements.

Measured-device validation answers a different scientific question

The final Ψ-Vortex study also evaluates the recurrent compact-modeling pipeline on three independent measured graphene-oxide/polyelectrolyte memristive devices, which provides an important second category of evidence because it tests whether the methodology continues to perform when it leaves the synthetic latent-coupling generator and is applied to real experimental device trajectories.

The measured-device experiments produce very strong held-out correlations and also include cross-device and cross-rate transfer tests, supporting the conclusion that recurrent compact modeling can reproduce and transfer measured memristive dynamics under the evaluated conditions.

However, these experiments should not be described as experimental validation of thermal-coupling inference, because the measured dataset does not contain a known thermal-coupling coefficient against which latent recovery can be evaluated.

The two experimental blocks therefore answer different questions: the synthetic benchmark evaluates whether an effective hidden coupling can be recovered when the relevant latent parameter is known and the history-dependent interaction is controlled, whereas the measured-device benchmark evaluates whether recurrent compact-model fidelity and transfer remain strong on independently measured device data.

Keeping these claims separate avoids the incorrect implication that high predictive accuracy on measured memristors constitutes evidence for thermal-coupling discovery.

From learned recurrence to executable Verilog-A

The final stage of Ψ-Vortex is particularly relevant from an engineering perspective because the selected recurrent students are not left only as PyTorch models.

They are exported into stateful Verilog-A representations, compiled using OpenVAF-reloaded, and executed through ngspice so that the recurrent behavior can be evaluated inside an actual circuit-simulation environment rather than only inside the original machine-learning implementation.

Five declared simulator stimuli pass the consistency tests, with the worst reported OSDI-versus-PyTorch absolute error remaining below the specified tolerance, which provides evidence that the selected recurrent equations survive the transition from the learned representation to compiled circuit execution.

This is stronger than merely demonstrating that Verilog-A source code can be generated, because the exported model is actually compiled and executed while its numerical behavior is compared against the learned implementation.

The scope should nevertheless remain precise. These tests establish equation-level circuit-simulator consistency within the declared conditions, rather than PDK qualification, industrial foundry validation, or universal validity for fabricated devices outside the evaluated regime.

The significance of this step is that it closes the methodological chain from ordered trajectory learning, through validation-controlled structural compression, to executable compact circuit simulation.

Automation in Ψ-Vortex is deliberately bounded

Another reason to distinguish Ψ-Vortex from an unrestricted AutoML system is that the framework does not attempt to eliminate expert scientific decisions.

It reduces manual intervention in several parts of the pipeline by introducing BIC-inspired structure regularization, clustering, validation-based model selection, symmetry analysis, and automated export, but the researcher still defines the experimental data, physical scenario, candidate architecture family, search boundaries, training budget, operating conditions, and the interpretation of the resulting learned structure.

This bounded approach is useful scientifically because physical interpretation often depends on knowledge that cannot be recovered from optimization alone, and allowing the search procedure to choose everything without declared constraints would make the resulting structure more difficult to interpret and reproduce.

The physics-aware initialization follows the same principle because it is treated as a tested initialization prior rather than as a universal physical law or guaranteed acceleration mechanism. Its usefulness is task dependent, and the final study explicitly reports that it provides a substantial acceleration in one declared shared-target printed-sequence experiment while producing worse thermal-test MSE than random initialization in another setting.

The appropriate interpretation is therefore not that physics-aware initialization is universally superior, but that an initialization informed by the target structure can provide benefits under some conditions and should be evaluated empirically for the specific problem being studied.

Newer does not automatically mean better

The existence of Ψ-Vortex does not make Ψ-NN, Ψ-HDL, or Ψ-xLSTM obsolete because each framework occupies a different point on the trade-off between simplicity, temporal expressiveness, structural automation, computational cost, interpretability, and deployment requirements.

If the system is predominantly steady-state and the scientific objective is primarily to determine whether compact structural organization can be extracted from a physics-informed model, Ψ-NN may already provide everything that is required.

If the main objective is to generate a compact engineering model that can be translated into Verilog-A and used in an EDA or SPICE workflow, while sophisticated recurrent state is unnecessary, Ψ-HDL is likely to be the more efficient choice.

If fast transient behavior, internal temporal state, or multi-timescale dynamics are central to the problem and the priority is recurrent fidelity rather than systematic automation of the complete structure-selection pipeline, Ψ-xLSTM is directly targeted at that regime.

Ψ-Vortex becomes most useful when several requirements appear simultaneously, particularly when the problem is genuinely history dependent, latent-state inference is scientifically relevant, structural choices need to be made without test leakage, compactness is an explicit design objective, and the final representation should eventually execute in a circuit simulator.

Using the most complicated framework on a simple pointwise problem would therefore add computational and methodological machinery without necessarily producing additional scientific value.

How the Ψ-family evolved

A useful way to understand the relationship between the frameworks is to view them as a sequence of increasingly demanding questions rather than as competing versions of a single method.

Ψ-NN, introduced by Liu et al., established the foundational question of whether physics-informed neural networks can reveal compact internal structure rather than merely approximate a solution. Ψ-HDL then extended that idea by asking whether the discovered structure could be converted into an engineering representation that a circuit simulator can execute. Ψ-xLSTM addressed the next limitation by asking how the approach should change when the system cannot be treated pointwise because useful information is carried by temporal history, recurrent state, fast transients, or multiple timescales. Ψ-Vortex then brings those directions together under a stricter experimental protocol by asking whether recurrent latent structure can be inferred from chronologically valid trajectories, whether recurrence can be verified through destructive controls, whether compact structure can be selected without test-set leakage, and whether the resulting recurrent equations can be transferred into compiled circuit simulation. The progression can therefore be summarized as: structure discovery → engineering deployment → recurrent temporal modeling → validation-controlled recurrent inference and circuit execution

Seen in this way, each framework occupies a distinct role, and each remains useful when the corresponding degree of methodological complexity is justified by the scientific or engineering problem. Note: The technical rationale document can be read here.

Quick reference table

One important caveat about Ψ-Vortex

The strongest way to describe Ψ-Vortex is also the most precise one: it does not establish thermal-coupling discovery in fabricated multilayer memristor stacks, but it does establish a controlled methodological pathway for evaluating whether such history-dependent latent interactions can be inferred.

The thermal-coupling experiment is based on a calibrated synthetic two-layer driver-victim scenario, and the supported recovery regime is explicitly bounded rather than extrapolated to arbitrary coupling strengths or layer counts. The independent measured-device experiments provide complementary evidence by showing that recurrent compact-model fidelity and transfer remain strong on real memristive measurements, but those experiments do not contain thermal-coupling ground truth and therefore cannot be used as evidence for experimental thermal-coupling identification.

Similarly, the Verilog-A experiments demonstrate that the selected recurrent equations can be exported, compiled, and executed consistently in ngspice under the declared stimuli and numerical tolerance, but this should be described as circuit-simulator consistency rather than PDK qualification or industrial compact-model certification.

These limitations do not reduce the usefulness of the framework. Explicitly defining the boundary between demonstrated capability and future experimental validation makes it clearer which conclusions are supported by the current evidence and which questions remain open.

Final rule of thumb

If you are entering physics structure-informed learning for the first time, or if your problem is relatively simple and predominantly steady-state, Ψ-NN provides the clearest starting point because it exposes the original structural-discovery principle without adding unnecessary recurrent or deployment complexity.

If you already know that the final output should be a compact engineering model capable of entering a Verilog-A and SPICE workflow, while the relevant device behavior can still be represented without sophisticated recurrent state, Ψ-HDL is probably the most direct choice.

If the device behavior is dominated by fast transients, temporal memory, or multi-timescale dynamics, and preserving recurrent fidelity is a primary requirement, Ψ-xLSTM is designed specifically for that situation.

If the problem combines genuine history dependence with latent-state inference, structural compression, validation-controlled model selection, explicit recurrence testing, and a requirement to carry the learned representation into executable circuit simulation, Ψ-Vortex provides the most complete pipeline of the four.

The objective, however, should never be to choose the framework with the largest number of components simply because it is the newest one. A better principle is to use the simplest framework that still represents the actual physics, temporal dependencies, validation requirements, and engineering constraints of the problem you are trying to solve.