Auditable AI Software Brings Trustworthy Neural Operators to Composite Curing

Manufacturing a carbon-fibre composite part is a delicate thermal balancing act. The resin must be heated along a carefully programmed cycle, and the way heat diffuses through the laminate determines how completely the polymer cures, whether temperatures overshoot their targets, and how steep the conversion gradients become inside the material. High-fidelity simulations of this thermochemical process are indispensable for process design, but they are expensive to run repeatedly. Neural operators—deep learning models that learn mappings between entire functions rather than single values—promise cheap surrogates, and Fourier neural operators in particular have become an influential template. The catch is trust: in a scientific setting, a surrogate that cannot be audited is a surrogate that cannot be adopted.

A team led by Hyojin Park, Nam-Hyun Yoo and Jinhong Yang has now released CD-CureNO, an open-source software package published in the journal SoftwareX that wraps neural-operator surrogates for composite curing in an unusually rigorous verification and provenance framework. The software, versioned at v0.0.3 and archived in Software Heritage under an Apache 2.0 license, is written in Python 3.10 through 3.12 using PyTorch, NumPy, SciPy and pandas, and it runs its audits and test suites on ordinary CPUs, with CUDA reserved for optional model training. What distinguishes the project is not a claim of new mathematics—the authors explicitly disclaim novelty for Fourier operators, joint temperature-and-cure prediction, or physics-based losses—but a domain-specific integration and verification layer built around inspectable scientific controls.

The motivating problem came from a legacy residual Fourier neural operator that stacked up to 51 independently trained positional models for curing analysis. Rather than silently replacing that code, CD-CureNO keeps two reproduction paths separately named: one that reproduces the legacy behavior exactly, and one that corrects known defects. The team regression-tested nine legacy defects, including normalization leakage and incomplete field outputs, so that the historical behavior is documented rather than erased. From that audited foundation, the software extends to joint temperature-and-degree-of-cure fields, causal response, conservative label generation, and transfer of learned knowledge across spatial dimensions.

The architecture is organized around explicit development and validation phases, labeled P0 through P6. P0 audits legacy behavior, P1 reproduces and corrects it, P2 develops joint one-plus-one-dimensional operators over the thickness-time field, P3 supplies a one-dimensional solver stage, P4 generates a true two-dimensional benchmark with two spatial coordinates evolving in time, P5 tests transfer, restriction and causality, and P6 is reserved for a future confirmatory held-out campaign. Each stage emits inspectable artifacts—configuration snapshots, Git and environment records, checkpoints, predictions and machine-readable receipts—that the next stage consumes, with cross-cutting guardrails verified again during postflight aggregation and reporting.

The authors define a result as auditable when its input, code, configuration, split, seed and checkpoint are all identifiable; when its reported metric can be recalculated from saved case outputs; when integrity violations or missing prerequisites fail explicitly; and when every claim can be traced back to those artifacts. Hashes, manifests, tensor mappings and receipts supply the observable evidence. Failed and superseded runs remain on record instead of being replaced by result-selected retries, and complete cure cycles or simulation cases—not individual grid points—define the samples. Crucially, the team distinguishes its independent postflight calculations, which are separate from the training and execution path, from validation by an unaffiliated research group or an independent physical model. A new NumPy-only example verifier imports neither training nor model code and reconstructs metrics from saved fields; a deliberately altered metric is rejected even after its file checksum is updated, and a failed recheck replaces any earlier success receipt.

Two technical contracts give the software its distinctive character. The first is restriction preservation: for laterally uniform coefficients, initial conditions and boundary data with zero lateral flux, an x-independent solution should reduce to the same through-thickness problem at every lateral position. The two-dimensional target therefore implements the lifted one-dimensional field plus a residual correction, with copied source tensors and zero-residual lateral branches that recover the source mapping exactly at initialization up to floating-point ordering. A verifier reconstructs the target state from the checkpoint, since output equality alone would not prove provenance. The second contract is causality: the causal model replaces temporal Fourier transforms with dilated convolutions, and perturbing all future input channels must leave every preceding output field unchanged. A nonnegative latent cure rate guarantees bounded, monotone cure evolution, and finite-volume-compatible fluxes handle material interfaces.

The verification evidence is unusually detailed. A GitHub Actions run on Ubuntu 24.04 passed 224 tests with 30 explicitly documented skips in about 42 seconds, and a fresh Windows run on a separate commit passed the same counts in about 48 seconds; continuous integration even exposed an input-stride-dependent CPU rounding difference, fixed by making shared target channels contiguous, with a new regression test added. The historical two-dimensional benchmark holds 512 temperature-and-cure cases of roughly 918 megabytes, anchored by 27 prespecified solver checks, zero failed cases, a maximum relative global energy residual of 1.345 times ten to the minus twelve, and exact float32 slice-hash replay for selected cases. Fresh regeneration of all 512 cases took 214.5 seconds on the documented Windows machine, and independent hashing confirmed that all eight output arrays match the frozen originals byte for byte. The team is candid that strict Linux plan validation rejected 33 heat-transfer values differing from the frozen Windows plan by at most 2.842 times ten to the minus fourteen, so canonical replay requires the documented compatible environment.

New in the revision is an independent mathematical verification of the production solver against elementary continuous reference solutions. Four synthetic case families—an anisotropic insulated transient, steady manufactured fields exercising all four Robin boundary faces with uniform and then discontinuous conductivity, and a solvable cure specialization coupled to reaction heating—were specified in an archived protocol with acceptance criteria fixed before execution. All 17 scheduled configurations and 72 recorded acceptance items passed. Measured spatial convergence orders clustered near two, temporal orders near one, consistent with backward Euler, and the synthetic cure equation gave orders near four, consistent with the production fourth-order Runge-Kutta update. Finest temperature relative errors ranged from 5.82 times ten to the minus five to 5.10 times ten to the minus four, and the finest cure maximum error was 1.80 times ten to the minus eight. The authors stress the boundaries: these studies verify anisotropic diffusion, boundary treatment and a special reaction-heat coupling, but not general kinetic validity, proprietary solver parity or experimental validation.

A fully public end-to-end example demonstrates the entire workflow without any private data or checkpoints. It generates eight true two-dimensional cases with laterally varying Robin coefficients, trains production causal operators with a fixed seed for 32 source and 48 target epochs, transfers knowledge through tensor copying and zero-residual initialization, and then recomputes held-out metrics in a separate NumPy-only postflight process. The two held-out cases yielded temperature relative errors of 0.006408 and 0.009741, temperature root-mean-square errors of 2.199 and 3.385 kelvin, and cure errors near 0.028, with future-prefix change exactly zero and independently recomputed metrics agreeing to within 4.44 times ten to the minus sixteen. The complete run took under ten seconds on a desktop CPU. The authors deliberately label this a functionality example, not evidence of superiority, and the figures show visible prediction errors rather than flattering comparisons.

Looking forward, the team has published a registered plan for a confirmatory P6 campaign: 40 held-out out-of-distribution cases across five target seeds, paired with a generic causal transfer baseline and analyzed with 10,000 crossed paired bootstrap replicates. A confirmatory claim would require a registered positive 95 percent improvement-interval bound, at least a 10 percent case-median improvement, physical-error guardrails and complete verified execution without test-based selection—and the authors note plainly that 40 cases across five seeds are not 200 independent cases and do not guarantee adequate statistical power. That discipline is the real story of CD-CureNO. In a field where surrogate models often arrive with cherry-picked demos and unverifiable numbers, the package demonstrates that neural operators for manufacturing can ship with the same provenance discipline as the experiments they hope to replace: every number traceable to a run, every failed attempt preserved, and every claim bounded by the evidence that produced it.

Subject of Research: Auditable restriction-preserving causal neural operators for thermochemical composite curing simulation

Article Title: CD-CureNO: Auditable software for restriction-preserving causal neural operators in composite curing

Article References: Park, H., Yoo, N.-H., & Yang, J. (2026). CD-CureNO: Auditable software for restriction-preserving causal neural operators in composite curing. SoftwareX, 36, Article 103086. https://doi.org/10.1016/j.softx.2026.103086

Image Credits: AI Generated

DOI: Not provided

Keywords: neural operators, composite curing, Fourier neural operator, software verification, reproducibility, provenance, causality, thermochemical modeling, surrogate models, manufacturing simulation, open-source software, convergence testing