Livermore scientists systematically check and review software throughout the software life-cycle in a verification and validation (V&V) process to ensure the credibility of codes and models, quantify confidence in calculation results, and measure the progress in the predictive capabilities.

**Verification**—Verification is the process of confirming that a computer code correctly implements the algorithms that were intended. The process of confirming that the equations are numerically solved accurately.**Validation**—Validation is the process of confirming that the predictions of a code adequately represent measured physical phenomena. The process of confirming that the equations are (physically) accurate.

Code verification is the most general component of V&V. It answers three specific questions:

- Are the equations represented by a code mathematically (not physically) correct?
- Are the algorithms that provide the numerical solution of the mathematical equations themselves mathematically correct?
- Is the software implementation of these algorithms correct (that is, free of faults)?

Resolution of these questions is general and in principle does not depend on specific applications of the code. However, code verification does not directly address the problem of deciding how numerically accurate a given calculation is, that is calculation verification (or calculation numerical error assessment), but it provides the necessary foundation for believing accuracy assessments. The specific accuracy achievable in given calculations is very much a function of the particular application.

Solution verification is quantification of the numerical error in a presented calculation. This answers a direct question: What is the error in a given calculation? Unfortunately, this is all but impossible to perform completely and rigorously for complex calculations. However, it can be partially and practically addressed by explicit discretization robustness and convergence studies, formal error estimation procedures, inference from test problem suites, and – possibly with some danger – inference from previous experience (i.e., judgment). Past experience can count for much if properly understood and presented.

Code verification can be completely achieved, and calculations can still be inaccurate, due to poor discretizations (lack of converged calculations). More generally, verification of correct functioning of algorithms cannot be partitioned as cleanly as we would like. It may be impossible to determine that algorithms are failing only on available test problems; the failures may appear only on a large-scale problem for which there is no referent solution. In such a case, the only warning that the solution is incorrect will be heuristic or empirically based assessment of the quality of specific calculations, which is what calculation verification is about.