Search Site
Ask LENRBot

Solid-State Fusion Primers  |  Condensed Matter Nuclear Science

SOFTWARE V&V & DATA INTEGRITY

The Instrument Is the Code

If solid-state fusion turns out to be real, it would be among the most significant clean-energy discoveries in history. Whether it is real depends, at the first level of inquiry, on whether anyone can trust the number a calorimetry experiment returns. That number is not measured; it is computed. And a computation can be debugged.

College Level
Expert Level

Introduction: What the Number Actually Is

Start with what the number actually is. Imagine you are writing a data-processing pipeline. Sensors in a lab — thermocouples, current meters, voltage meters — sample readings every few seconds over several days. At the end, your pipeline subtracts the electrical input from the heat output, fits a calibration curve, corrects for baseline drift, and integrates the whole time series. The resulting number, in milliwatts, is the claimed “excess power.” No instrument ever showed a watt of excess energy on a dial. A calculation did.1

This matters because in solid-state fusion (SSF) research — the scientific field sometimes called “cold fusion” — the central claimed anomaly is exactly that excess power reading. The disputed quantity is a derived quantity. It lives in an analysis pipeline, and a pipeline is software, with every failure mode software has.

For someone with a CS background, that reframing should feel less like a strange physics controversy and more like a familiar debugging problem. “Is the excess heat real?” breaks into a stack of narrower questions, several of which you already have tools for. Does the code compute what the calorimetry model specifies — that is, is it correctly implemented? Is the model the right one for this apparatus? Can a second party re-derive the number from the archived raw data? Where in the analysis were choices made that could defensibly have gone the other way? None of these is a nuclear physics question. Together, they decide whether the nuclear physics question can even be asked cleanly.

The Signal Is Buried in the Noise

Reproducibility is difficult everywhere. It is worse when the effect you are hunting is roughly the same size as your own measurement errors.

A 2016 study illustrates the problem. A group set out to replicate a specific, well-documented experiment — the Letts dual-laser protocol, which had reported frequency-specific excess power in palladium loaded with deuterium. Across 231 trials at roughly 10 watts of input power, they measured an average excess of 6.1 ± 21.6 milliwatts. The uncertainty is larger than the mean: the honest reading is no effect detected. The revealing numbers are the ones they reported about their own instrument — spurious heat signals of 130 to 460 milliwatts from calibration errors, and 135 to 324 milliwatts from mechanical instability in a loose calorimeter cap, with one temperature excursion worth about 400 milliwatts.2

Think of it this way: if your API’s typical latency jitter is 200 milliseconds, a 6-millisecond regression is undetectable. The noise floor swamps the signal. That is the situation these experiments are in. When the error floor stands one to two orders of magnitude above the effect you are trying to measure, the instrument is the dominant variable, not the physics.

That is an important boundary, and this piece holds it. The artifact floor is a hardware problem: thermocouples, loose mechanical parts, calibration drift. No amount of software validation moves those numbers. What software validation governs is everything above that floor — whether the derived number is computed correctly, whether the analysis choices were locked in before the answer was known, and whether an outside party can reconstruct the result from the records. Both halves matter. This piece is about the half a software engineer can actually move.

One more complication: where excess heat is reported at all, it tends to appear only at extreme conditions — a very high ratio of deuterium to palladium atoms in the experimental cell (roughly 0.85 to 0.90). Even hitting that target does not guarantee the effect. And the loading ratio itself is not directly measured; it is inferred from the electrical resistance of the material.3 A narrow, hard-to-reach, hard-to-measure setpoint that does not guarantee a result even when you hit it explains a lot of experimental disagreement without any unusual physics. Ordinary measurement variance will do it.

This is not unique to SSF. A 2016 Nature survey of 1,576 researchers found that over 70 percent had failed to reproduce another scientist’s experiment, and more than half had failed to reproduce one of their own.4 A Google-convened team that spent several years revisiting the cold-fusion claims with modern instrumentation did not reproduce excess heat, but it did report something more useful than a verdict: the materials science of reaching and holding extreme loading was under-characterized, and the older data were not good enough to settle anything.5

One distinction needs to stay clear. “Excess heat was observed” and “the heat is nuclear in origin” are separate claims backed by different evidence. The strongest objection to a nuclear explanation has nothing to do with software: a fusion-scale energy source should produce a corresponding amount of nuclear reaction products — neutrons, tritium, helium. That signature has not reliably appeared.6 Validating a software pipeline speaks only to the first claim, the heat measurement. It cannot make heat nuclear. It can only make the measurement trustworthy enough to be worth arguing about.

Verification and Validation: Different Jobs

The most useful distinction for this problem comes straight from software engineering. Verification asks: did we build the thing right? Validation asks: did we build the right thing?7 They fail independently, and the second failure is the dangerous one.

Applied to a calorimetry analysis pipeline, verification is the tractable half. The baseline-subtraction routine, the calibration fit, the numerical integration — these are functions with definable correct behavior. You can test them against synthetic inputs whose answers you already know. Feed the pipeline a simulated dataset containing exactly zero excess power and confirm it returns zero. Feed it a known injected heat pulse and confirm it recovers the right integral. This is just unit testing. Very little scientific analysis code is tested this way, in this field or any other.

Validation is harder and matters more. A pipeline can be perfectly implemented and still encode the wrong physical model — the wrong assumption about where heat escapes, or a calibration constant fitted under conditions that no longer apply when the real experiment runs. Correct code running the wrong model returns a number that is precise, repeatable, and wrong. Think of it as the difference between “my code does what the spec says” and “the spec describes what actually happens in the real world.” Verification catches the first failure. Only physical cross-checks catch the second.

Aviation software standards (DO-178C) already have a vocabulary for scaling rigor to stakes.8 Every requirement traces to the code that implements it and the test that exercises it; the depth of required assurance rises with how bad the failure would be. SSF calorimetry does not need avionics-grade process. It does need the core idea: a result that might one day underwrite a new energy technology should rest on analysis code where every step traces to a stated requirement and a passing test.

Data Integrity: Can Anyone Else Get Your Number?

Suppose the code is verified and the model validated. There is still the question a regulator would ask first: can someone who was not in the room reconstruct the result from the raw data?

In pharmaceutical and clinical research, this requirement is codified as ALCOA+: data must be attributable, legible, contemporaneous, original, and accurate — and further complete, consistent, enduring, and available.9 Stripped of the compliance framing, it is a single engineering demand: preserve the raw data stream and every transformation applied to it, so the final number can be re-derived rather than merely asserted.

For a computed result, provenance is the whole game. The reproducible-research movement in computational science has made this standard practice: publish the code and data together, version-controlled, so the path from raw signal to reported value is open to inspection and re-execution.10 An SSF result reported as “780 mW excess” is an assertion. The same result shipped with the raw time series, the exact analysis code at a pinned version, the calibration files, and the parameter set is a computation anyone can run. The difference costs no new physics and no new hardware. Among the upgrades available on the software side, this is the cheapest one that carries real weight — and it is squarely within reach of anyone who writes software.

Git for your data and your analysis code. Tagged releases, not “final_v2_FINAL.py.”

Locking the Analysis Before You Look at the Answer

The reproducibility movement in empirical science has spent a decade converting good intentions into concrete process, and the lessons transfer almost without modification.11

The central uncomfortable finding is this: honest, competent researchers, given normal latitude over which data to exclude, which baseline window to use, and when to stop collecting, can arrive at a statistically convincing effect that is not there. Simmons and colleagues showed that undisclosed flexibility in analysis can make almost anything look statistically significant.12 This happens quietly, one defensible choice at a time, which is why discipline alone does not fix it.

Experimental physics converged on a structural fix: blind analysis. The team freezes every analysis choice while the answer is hidden — by adding a secret offset to the data, masking a subset of results, or working on scrambled events — and unblinds only once, after the method is locked.13 Particle physics uses this routinely because the stakes and the temptations are both high. Some SSF groups are beginning to adopt it. Extending the practice to the calorimetry itself requires inventing nothing: settle the baseline model, the outlier rule, and the integration window on masked data, then unblind.

A lighter version is preregistration: write down the experimental and analysis plan in enough detail to execute it, before the data exist.14 “We found excess heat” and “we specified in advance how we would measure excess heat, and here is what that fixed procedure returned” are different claims. The second is immune to the objection that the analysis was shaped by the answer. For a field whose results have been dismissed on exactly that basis, preregistration is close to a free win.

Think of it as the difference between writing tests before your code versus after, when you already know what the code does.

What SSF Gives Software Engineering in Return

The exchange is not one-directional. SSF is a punishing validation environment: low signal-to-noise, weeks of streaming data with genuine baseline drift, a signal at the artifact floor, and an audience actively trying to find the flaw. A pipeline-validation methodology that holds up here will hold up almost anywhere.

It also surfaces a problem many software engineers underestimate. Re-running the same code is not guaranteed to produce the same answer. Floating-point addition is not associative: summing a long noisy time series in a different order — across a different thread count, on different hardware, against a different version of a math library — can shift the result in the least-significant bits.15 For a short calculation this is invisible. For a multi-week integration of a drifting signal near the artifact floor, that kind of algorithmic non-reproducibility can look like physical non-reproducibility. Telling them apart requires controlled, deterministic numerics — ordinary software engineering doing something the physics genuinely needs.

The gold standard has a name in software standards already: independent verification and validation (IV&V), where a separate team, reporting through a separate chain, re-implements the analysis from the specification and runs it against the same raw data.16 NASA has run a dedicated IV&V program for flight software for decades. Apply the same idea to an SSF result: two independent implementations that agree on the number are far more convincing than one; two that disagree have located a bug or an ambiguity in the method, which is progress either way. Cross-implementation agreement is the software analogue of the cross-method corroboration physicists already trust.

None of these skills is exotic. Data provenance, reproducible pipelines, deterministic numerics, and independent V&V are the same competencies now in demand across regulated software, machine-learning reproducibility, and scientific computing broadly. Learning to make an adversarially scrutinized, low-signal-to-noise measurement reproducible is learning something the rest of the industry is still working out.

Why Bother

The honest state of this field is neither vindication nor dismissal. It is a poorly characterized region of experimental space with a handful of persistent, unexplained signals and a long history of measurements nobody else could repeat. In 2023 ARPA-E committed roughly $10 million across eight teams — including groups at MIT, Stanford, and Lawrence Berkeley National Laboratory — to bring modern instrumentation to that region and either find the effect or close the book.17 Whichever way it falls, the answer will only be trusted if the measurement chain behind it can be trusted.

That is where the field’s problem stops being someone else’s and becomes partly yours. A software engineer’s role here is not to endorse the physics or to dismiss it. It is to make the derived number and the analysis behind it trustworthy enough that the result — in either direction — is one a skeptic has to engage.

One honest caveat: a clean pipeline makes a null result decisive only when the measurement was sensitive enough to have caught the effect if it existed. When the claimed signal sits at or below the instrument’s error floor, even a flawless analysis returns “no effect detected” — which is absence of evidence at low statistical power, not evidence of absence. The useful deliverable is a result with its sensitivity stated: an anomaly that survives a validated, blinded pipeline and demands an explanation, or a null at a detection limit high enough to have seen the effect, which genuinely closes a corner of the map.

A well-characterized null of that kind is worth far more than another number nobody can check. The instrument is the code, and it is also the thermocouples. Today the code is the less-tested part. Fixing that is work for people who build and validate software, and it is available.

Editorial note: This primer presents a scholarly synthesis of solid-state fusion's relationship to software verification, validation, and data integrity, written for a college-level audience. The underlying nuclear claims of SSF/LENR remain scientifically contested. Evidence tiers (A = replicated/consensus, B = single peer-reviewed source, C = preliminary/contested) are noted inline. Readers are directed to primary experimental literature for empirical evaluation.

References & Footnotes

  1. Excess power in these experiments is a derived quantity: it is computed from measured temperatures, currents, and voltages through a calorimetric model, not read directly off an instrument. For the standing of excess heat as the field’s central reported anomaly, see Edmund Storms, The Science of Low Energy Nuclear Reaction (Singapore: World Scientific, 2007). Tier C for the SSF-specific empirical record (single-community synthesis, replication limited); the description of calorimetry as a computed quantity is standard measurement practice. ↩
  2. M. J. Guffey, Y. Tang, and P. J. King, “Attempted Replication of Excess Heat in the Letts Dual-laser Experiment,” Journal of Condensed Matter Nuclear Science 20 (2016): 1–28. Across 231 trials at ~10 W input the measured excess averaged 6.1 ± 21.6 mW. The authors attribute their artifacts to apparatus design rather than analysis code: calibration artifacts of 130–460 mW and cap-instability temperature artifacts of 135–324 mW, with a single excursion worth ~400 mW. This is the best current published evidence on that specific protocol, and it is null. ↩
  3. M. C. H. McKubre et al., “Using Resistivity to Measure H/Pd and D/Pd Loading: Method and Significance,” in Condensed Matter Nuclear Science (ICCF-12 Proceedings) (Singapore: World Scientific, 2006). Establishes the resistance-ratio loading diagnostic and the clustering of excess-heat reports at high loading (D/Pd ≈ 0.85–0.90, approximate); high loading is treated as necessary but not sufficient. ↩
  4. Monya Baker, “1,500 Scientists Lift the Lid on Reproducibility,” Nature 533 (2016): 452–454. Survey of 1,576 researchers. ↩
  5. Curtis P. Berlinguette et al., “Revisiting the Cold Case of Cold Fusion,” Nature 570 (2019): 45–51. The team did not reproduce excess heat but identified extreme-loading materials science as an under-explored parameter space. ↩
  6. U.S. Department of Energy, Report of the Review of Low Energy Nuclear Reactions (Washington, DC, December 2004). The absence of a commensurate, energy-matched flux of nuclear products is an independent objection to a nuclear origin; the 2004 reviewers split on the excess-heat and helium evidence. The general-absence argument is well established (tier A); specific positive product reports are single-community and contested (tier C). ↩
  7. IEEE Std 1012-2016, IEEE Standard for System, Software, and Hardware Verification and Validation (New York: IEEE, 2017). Source of the verification/validation distinction and of independent verification and validation (IV&V) as an activity carried out by a party technically, managerially, and financially separate from the developers. ↩
  8. RTCA DO-178C, Software Considerations in Airborne Systems and Equipment Certification (Washington, DC: RTCA, 2011). Requires bidirectional traceability from requirements to code to tests; design assurance levels A–E scale required rigor to the consequence of failure. ↩
  9. Medicines and Healthcare products Regulatory Agency (MHRA), ‘GXP’ Data Integrity Guidance and Definitions, Revision 1 (March 2018). Defines the ALCOA and ALCOA+ data-integrity principles. ↩
  10. Roger D. Peng, “Reproducible Research in Computational Science,” Science 334 (2011): 1226–1227. Argues for publishing analysis code and data together so computational results can be independently re-executed. ↩
  11. Marcus R. Munafò et al., “A Manifesto for Reproducible Science,” Nature Human Behaviour 1 (2017): 0021. Consolidates preregistration, blinding, open data and code, and reporting standards into a single reform program. ↩
  12. Joseph P. Simmons, Leif D. Nelson, and Uri Simonsohn, “False-Positive Psychology: Undisclosed Flexibility in Data Collection and Analysis Allows Presenting Anything as Significant,” Psychological Science 22 (2011): 1359–1366. ↩
  13. Joshua R. Klein and Aaron Roodman, “Blind Analysis in Nuclear and Particle Physics,” Annual Review of Nuclear and Particle Science 55 (2005): 141–163. ↩
  14. Brian A. Nosek et al., “The Preregistration Revolution,” Proceedings of the National Academy of Sciences 115 (2018): 2600–2606. ↩
  15. David Goldberg, “What Every Computer Scientist Should Know About Floating-Point Arithmetic,” ACM Computing Surveys 23, no. 1 (1991): 5–48. Floating-point addition is not associative; summation order and parallel reduction can change a result in its least-significant bits. ↩
  16. Independent verification and validation is defined in IEEE Std 1012-2016 (see note 7) as V&V performed by an organization technically, managerially, and financially separate from the development organization. NASA maintains a dedicated Independent Verification and Validation Program for mission and flight software. ↩
  17. Advanced Research Projects Agency–Energy (ARPA-E), “U.S. Department of Energy Announces $10 Million in Funding to Projects Studying Low-Energy Nuclear Reactions,” February 2023. Eight teams, including groups at MIT, Stanford, and Lawrence Berkeley National Laboratory. ↩

Introduction: What the Number Actually Is

Start with what the number actually is. When a solid-state fusion (SSF) cell is reported to produce a watt of excess power, no instrument measured a watt. The instruments measured voltages: thermocouple readings, cell current, cell voltage, bath temperature, sometimes a coolant flow rate, sampled every few seconds for days or weeks. The watt is the output of a calculation run over that stream. Subtract the electrical input. Fit the calibration. Correct for baseline drift. Model the heat leaking to the surroundings. Integrate. Somewhere in that chain, in code, the excess appears, or it does not.1

This is not an indictment of the field. It is how modern calorimetry works, here and everywhere else that has to measure a small thermal signal. But it carries a consequence the long argument over cold fusion has mostly talked past. The disputed quantity is a computed quantity. It lives in an analysis pipeline, and an analysis pipeline is software, with every failure mode software has.

For a software engineer that reframing should feel less like a scientific controversy and more like a familiar ticket. “Is the excess heat real?” breaks into a stack of narrower questions, and several of them are ones you already have tools for. Does the code compute what the calorimetry model specifies (verification)? Is that model the right one for this apparatus (validation)? Can a second party re-derive the number from the archived raw data (provenance and reproducibility)? Where in the analysis were choices made that could just as defensibly have gone the other way (researcher degrees of freedom)? Not one of these is a nuclear physics question. Together they decide whether the nuclear physics question can even be asked cleanly.

The Signal Sits at the Artifact Floor

Reproducibility is hard everywhere. It is brutally hard when the effect you are chasing is the same size as the errors your own apparatus produces. That is the situation SSF calorimetry is in.

The clearest illustration is a negative result. In 2016 a group set out to reproduce a specific, well-known stimulation experiment, the Letts dual-laser protocol, which had reported frequency-specific excess power in loaded palladium. Across 231 trials, at roughly 10 watts of input power, they measured an average excess of 6.1 ± 21.6 milliwatts. The uncertainty is larger than the mean, so the honest reading is “no effect detected.” The numbers that matter more here are the ones they reported for their own artifacts: spurious heat signals of 130 to 460 milliwatts from calibration, and 135 to 324 milliwatts from mechanical instability in the calorimeter cap, with a single bad temperature excursion worth about 400 milliwatts.2 When the error floor stands one to two orders of magnitude above the signal you are hunting, the apparatus has stopped being a passive readout. It is the dominant variable in the experiment.

Here is the honest boundary, and it is the one this piece has to respect. Every one of those artifacts is hardware. They came from thermocouples, a loose cap, and calibration drift, not from a bug in anyone’s code, and no amount of verification, provenance tracking, or blinded analysis would have moved that 6.1-milliwatt figure, because the noise lived in the instrument rather than the pipeline. The authors also reported all of it plainly, which is a small rebuke to the idea that the field never does. So let me narrow the claim the title makes. Software verification and data integrity cannot lower a calorimeter’s error floor. What they govern is the layer above it: whether the derived number is computed correctly, whether the analysis choices were fixed before the answer was known, and whether a stranger can reproduce the result from the records. The instrument is the code, and it is also the thermocouples. This piece is about the half a software engineer can actually move.

The operating point makes it worse. Where excess heat is reported at all, it tends to appear only at extreme hydrogen loading, above a deuterium-to-palladium ratio of roughly 0.85 to 0.90, and even then high loading looks necessary rather than sufficient. Loading is not measured directly either; it is inferred from the cathode’s electrical resistance.3 A narrow, hard-to-reach, hard-to-measure setpoint that does not guarantee the effect even when you hit it is exactly the condition under which two competent labs, each convinced it is running the same experiment, get different answers. Nothing nuclear is needed to explain that. Ordinary measurement variance will do it.

None of this is peculiar to fusion. When Nature surveyed 1,576 researchers in 2016, more than 70 percent had tried and failed to reproduce another scientist’s experiment, and more than half had failed to reproduce one of their own.4 SSF is an acute case of a chronic, cross-disciplinary condition. And when a Google-convened team spent several years and real money revisiting the cold-fusion claims with modern instrumentation, it did not reproduce excess heat, but it did report something more useful than a verdict: the materials science of reaching and holding extreme loading was under-characterized, and the older data were not good enough to settle anything.5

One boundary has to be drawn clearly and then kept. “Excess heat was observed” and “the heat is nuclear in origin” are different claims resting on different evidence. The strongest objection to a nuclear explanation has nothing to do with software: a fusion-scale heat source should come with a commensurate, energy-matched flux of reaction products (neutrons, tritium, helium, gammas), and that signature has not reliably appeared.6 Validating the analysis pipeline speaks only to the first claim, the heat number itself. It cannot make heat nuclear. It can only make the measurement trustworthy enough to be worth arguing about.

Verification and Validation Are Two Different Jobs

The home field’s founding distinction is the one most useful here. Verification asks whether you built the thing right. Validation asks whether you built the right thing.7 They fail independently, and the second failure is the dangerous one.

Applied to a calorimeter, verification is the tractable half. The baseline-subtraction routine, the calibration fit, the numerical integration: these are units of code with definable correct behavior, and they can be tested against synthetic inputs whose answers you know in advance. Feed the pipeline a simulated dataset containing exactly zero excess power and confirm it returns zero. Feed it a known injected heat pulse and confirm it recovers the right integral. Very little scientific analysis code is tested this way, in this field or any other.

Validation is harder and matters more. A calorimetry pipeline can be flawless as code and still encode the wrong physical model of the cell: the wrong assumption about where heat escapes, or a calibration constant fitted under conditions that no longer hold. Correct code computing the wrong model returns a number that is precise, repeatable, and false. That is the regime in which an apparent “excess” can be manufactured, or a real one erased, without a single buggy line. Verification will never catch it. Only validation against independent physical checks will.

Safety-critical software engineering already has a vocabulary for scaling rigor to stakes. Under DO-178C, the standard for airborne software, every requirement traces to the code that implements it and the test that exercises it, and the depth of assurance rises with the consequence of failure, from level E up to level A.8 SSF calorimetry does not need avionics-grade process. It does need the core idea: a claim that might one day underwrite an energy technology should rest on analysis code whose every step traces to a stated requirement and a passing test. The signal is small enough that nothing looser is safe.

Data Integrity: Can Anyone Else Get Your Number?

Suppose the code is verified and the model validated. There is still the question a regulator would ask first: can someone who was not in the room reconstruct the result from the records?

In pharmaceutical and clinical data this is codified as ALCOA+, the requirement that data be attributable, legible, contemporaneous, original, and accurate, and further complete, consistent, enduring, and available.9 Stripped of the compliance framing, it is one engineering demand: preserve the raw stream and every transformation applied to it, so the final number can be re-derived rather than merely re-asserted.

For a computed result, provenance is the whole game. Peng’s prescription for computational science is now ordinary practice in the fields that took reproducibility seriously: publish the code and the data together, versioned, so the path from raw signal to reported value is open to inspection and re-execution.10 An SSF result reported as a bare “780 mW excess” is an assertion. The same result shipped with the raw time series, the exact analysis code at a pinned version, the calibration files, and the parameter set is a computation a stranger can run. The difference costs no new physics and no new hardware. It will not, on its own, lower the calorimeter’s error floor, which stays the field’s largest and most expensive problem. But among the upgrades available on the software side, this is the cheapest one that carries real weight, and it is squarely within the reach of people who write software for a living.

Closing the Forking Paths

The reproducibility movement in the empirical sciences has spent a decade turning good intentions into concrete process, and its playbook transfers almost unchanged.11 Its central finding is uncomfortable and well-documented: honest, competent researchers, given the normal latitude over which data to exclude, which baseline window to use, and when to stop collecting, can arrive at a statistically compelling effect that is not there. Simmons and colleagues named these researcher degrees of freedom and showed that undisclosed flexibility in analysis can present almost anything as significant.12 The forking happens quietly, one defensible choice at a time, which is why willpower does not fix it.

Experimental physics converged on a structural fix decades ago. In a blind analysis, the team freezes every analysis choice while the answer is hidden, by adding a secret offset, masking a subset of the data, or working on scrambled events, and unblinds only once, after the method is locked.13 Particle and nuclear physics use it precisely because the stakes and the temptations run high. Some SSF groups have begun to move toward this kind of rigor: the 2019 Google-convened reassessment built its case on carefully instrumented, openly reported calorimetry, and the current ARPA-E cohort is assembling modern, better-characterized platforms. Extending that turn to blind analysis of the calorimetry itself requires inventing nothing: settle the baseline model, the outlier rule, and the integration window on masked data, then unblind.

Its lighter cousin is preregistration: write down the experimental and analysis plan, in enough detail to be executable, before the data exist.14 The effect is to convert “we found excess heat” into “we specified in advance how we would measure excess heat, and here is what that fixed procedure returned.” The second statement is the one a skeptic cannot wave away by pointing to hidden flexibility, because there was none. For a field whose results have been dismissed for exactly that reason, it is close to a free win.

What SSF Gives Back to Software Engineering

The bridge carries traffic both ways, and the return cargo is real. SSF is a punishing validation benchmark: low signal-to-noise, long-duration streaming data with genuine baseline drift, a signal sitting at the artifact floor, and an audience actively hunting for the flaw. A pipeline-validation methodology that holds up under those conditions will hold up almost anywhere. If you wanted to stress-test a framework for trustworthy scientific computation, you could hardly design a harder case.

It also surfaces a problem software engineers tend to underestimate: re-running the same code is not guaranteed to give the same answer. Floating-point addition is not associative, so summing a long noisy series in a different order, across a different thread count, on different hardware, or against a different math library, can shift the result in the low bits.15 For a short calculation this is invisible. For a multi-week integration of a drifting signal near the artifact floor, algorithmic non-reproducibility can masquerade as physical non-reproducibility. Telling the two apart, through controlled, deterministic numerics, is ordinary software engineering doing something the physics genuinely needs.

The most valuable contribution has a name in the standards already: independent verification and validation, in which a separate team, reporting through a separate chain, re-implements the analysis from the specification and runs it against the same raw data.16 NASA has run a dedicated IV&V program for flight software for decades. Point it at an SSF result and the logic is clean. Two independent implementations that agree on the number are far more convincing than one; two that disagree have localized a bug or an ambiguity in the method, which is itself progress. Cross-implementation agreement is the software analogue of the cross-method corroboration physicists already trust.

None of these skills is exotic, and all of them travel. Data provenance, reproducible pipelines, deterministic numerics, and independent V&V are the same competencies now in demand across regulated software, machine-learning reproducibility, and scientific computing broadly. An engineer who learns to make an adversarially scrutinized, low-SNR measurement reproducible has learned something the rest of the industry is still reaching for.

Why Take This On

The honest state of the field is neither vindication nor dismissal. It is a poorly instrumented region of parameter space with a handful of persistent, unexplained signals and a long history of measurements no one else could repeat. In 2023 the U.S. Advanced Research Projects Agency–Energy committed roughly $10 million across eight teams, including groups at MIT, Stanford, and Lawrence Berkeley, to bring modern instrumentation to that region and either find the effect or close the book.17 Whichever way it falls, the answer will only be believed if the measurement chain behind it can be trusted.

That is where the field’s problem stops being someone else’s and becomes partly yours. A software engineer’s job here is not to endorse the physics or to debunk it. It is to make the derived number and the analysis behind it trustworthy enough that the result, in either direction, is one a reasonable skeptic has to engage. There is a catch worth stating plainly, since the piece has spent its length teaching readers to catch exactly this kind of thing. A clean pipeline makes a null decisive only when the measurement was sensitive enough to have caught the effect had it been there. When the claimed signal sits at or below the instrument’s error floor, even a flawless analysis returns “no effect detected,” which is absence of evidence at insufficient power, not evidence of absence. So the honest deliverable is a result reported with its sensitivity attached: an anomaly that survives a validated, blinded pipeline and demands an explanation, or a null at a stated detection limit high enough to have seen the effect, which genuinely closes a corner of the map. A well-characterized null of that kind is worth far more than another number nobody can check. The instrument is the code, and it is also the thermocouples; today the code is the least-tested part of it. Fixing that half is work for the people who build and validate software, and it is theirs for the taking.

Editorial note: This primer presents a scholarly synthesis of solid-state fusion's relationship to software verification, validation, and data integrity, written for an expert audience. The underlying nuclear claims of SSF/LENR remain scientifically contested. Evidence tiers (A = replicated/consensus, B = single peer-reviewed source, C = preliminary/contested) are noted inline. Readers are directed to primary experimental literature for empirical evaluation.

References & Footnotes

  1. Excess power in these experiments is a derived quantity: it is computed from measured temperatures, currents, and voltages through a calorimetric model, not read directly off an instrument. For the standing of excess heat as the field’s central reported anomaly, see Edmund Storms, The Science of Low Energy Nuclear Reaction (Singapore: World Scientific, 2007). Tier C for the SSF-specific empirical record (single-community synthesis, replication limited); the description of calorimetry as a computed quantity is standard measurement practice. ↩
  2. M. J. Guffey, Y. Tang, and P. J. King, “Attempted Replication of Excess Heat in the Letts Dual-laser Experiment,” Journal of Condensed Matter Nuclear Science 20 (2016): 1–28. Across 231 trials at ~10 W input the measured excess averaged 6.1 ± 21.6 mW. The authors attribute their artifacts to apparatus design rather than analysis code: calibration artifacts of 130–460 mW and cap-instability temperature artifacts of 135–324 mW, with a single excursion worth ~400 mW. This is the best current published evidence on that specific protocol, and it is null. ↩
  3. M. C. H. McKubre et al., “Using Resistivity to Measure H/Pd and D/Pd Loading: Method and Significance,” in Condensed Matter Nuclear Science (ICCF-12 Proceedings) (Singapore: World Scientific, 2006). Establishes the resistance-ratio loading diagnostic and the clustering of excess-heat reports at high loading (D/Pd ≈ 0.85–0.90, approximate); high loading is treated as necessary but not sufficient. ↩
  4. Monya Baker, “1,500 Scientists Lift the Lid on Reproducibility,” Nature 533 (2016): 452–454. Survey of 1,576 researchers. ↩
  5. Curtis P. Berlinguette et al., “Revisiting the Cold Case of Cold Fusion,” Nature 570 (2019): 45–51. The team did not reproduce excess heat but identified extreme-loading materials science as an under-explored parameter space. ↩
  6. U.S. Department of Energy, Report of the Review of Low Energy Nuclear Reactions (Washington, DC, December 2004). The absence of a commensurate, energy-matched flux of nuclear products is an independent objection to a nuclear origin; the 2004 reviewers split on the excess-heat and helium evidence. The general-absence argument is well established (tier A); specific positive product reports are single-community and contested (tier C). ↩
  7. IEEE Std 1012-2016, IEEE Standard for System, Software, and Hardware Verification and Validation (New York: IEEE, 2017). Source of the verification/validation distinction and of independent verification and validation (IV&V) as an activity carried out by a party technically, managerially, and financially separate from the developers. ↩
  8. RTCA DO-178C, Software Considerations in Airborne Systems and Equipment Certification (Washington, DC: RTCA, 2011). Requires bidirectional traceability from requirements to code to tests; design assurance levels A–E scale required rigor to the consequence of failure. ↩
  9. Medicines and Healthcare products Regulatory Agency (MHRA), ‘GXP’ Data Integrity Guidance and Definitions, Revision 1 (March 2018). Defines the ALCOA and ALCOA+ data-integrity principles. ↩
  10. Roger D. Peng, “Reproducible Research in Computational Science,” Science 334 (2011): 1226–1227. Argues for publishing analysis code and data together so computational results can be independently re-executed. ↩
  11. Marcus R. Munafò et al., “A Manifesto for Reproducible Science,” Nature Human Behaviour 1 (2017): 0021. Consolidates preregistration, blinding, open data and code, and reporting standards into a single reform program. ↩
  12. Joseph P. Simmons, Leif D. Nelson, and Uri Simonsohn, “False-Positive Psychology: Undisclosed Flexibility in Data Collection and Analysis Allows Presenting Anything as Significant,” Psychological Science 22 (2011): 1359–1366. ↩
  13. Joshua R. Klein and Aaron Roodman, “Blind Analysis in Nuclear and Particle Physics,” Annual Review of Nuclear and Particle Science 55 (2005): 141–163. ↩
  14. Brian A. Nosek et al., “The Preregistration Revolution,” Proceedings of the National Academy of Sciences 115 (2018): 2600–2606. ↩
  15. David Goldberg, “What Every Computer Scientist Should Know About Floating-Point Arithmetic,” ACM Computing Surveys 23, no. 1 (1991): 5–48. Floating-point addition is not associative; summation order and parallel reduction can change a result in its least-significant bits. ↩
  16. Independent verification and validation is defined in IEEE Std 1012-2016 (see note 7) as V&V performed by an organization technically, managerially, and financially separate from the development organization. NASA maintains a dedicated Independent Verification and Validation Program for mission and flight software. ↩
  17. Advanced Research Projects Agency–Energy (ARPA-E), “U.S. Department of Energy Announces $10 Million in Funding to Projects Studying Low-Energy Nuclear Reactions,” February 2023. Eight teams, including groups at MIT, Stanford, and Lawrence Berkeley National Laboratory. ↩
Back to Top
©2026  | Solid State Fusion  
A Project By Anthropocene Institute
chevron-down