What it does. Track physical units and propagate measurement uncertainty in scientific calculations using pint and uncertainties. Use for unit conversion and dimensional checking, GUM uncertainty budgets, Type A and Type B evaluation, coverage factors and expanded uncertainty, Monte Carlo propagation, significant-figure and plus-minus reporting, error propagation through curve fits, CODATA constants, auditing Python code for stripped units or broken uncertainty propagation, and order-of-magnitude plausibility checks using dimensionless groups (Reynolds, Peclet, Damkohler, Knudsen, Biot, Womersley), characteristic scales such as diffusion time or Debye length, and observed magnitude ranges. Trigger on "is this number physically reasonable", "sanity check these units", "what regime is this flow in", or a result that looks off by orders of magnitude. Part of K-Dense-AI/scientific-agent-skills (AI Scientist skills) (K-Dense-AI/scientific-agent-skills).

Upstream	K-Dense-AI/scientific-agent-skills
Skill file	skills/uncertainty-and-units/SKILL.md
License	MIT
Author	K-Dense Inc.
Fetched	2026-09-10

Install

• npx skills add K-Dense-AI/scientific-agent-skills --skill uncertainty-and-units, or copy the skill folder into ~/.claude/skills/uncertainty-and-units/.
• Raw file: curl -sL https://raw.githubusercontent.com/K-Dense-AI/scientific-agent-skills/HEAD/skills/uncertainty-and-units/SKILL.md

SKILL.md (verbatim)

name: uncertainty-and-units
description: Track physical units and propagate measurement uncertainty in scientific calculations using pint and uncertainties. Use for unit conversion and dimensional checking, GUM uncertainty budgets, Type A and Type B evaluation, coverage factors and expanded uncertainty, Monte Carlo propagation, significant-figure and plus-minus reporting, error propagation through curve fits, CODATA constants, auditing Python code for stripped units or broken uncertainty propagation, and order-of-magnitude plausibility checks using dimensionless groups (Reynolds, Peclet, Damkohler, Knudsen, Biot, Womersley), characteristic scales such as diffusion time or Debye length, and observed magnitude ranges. Trigger on "is this number physically reasonable", "sanity check these units", "what regime is this flow in", or a result that looks off by orders of magnitude.
license: MIT
compatibility: Requires Python 3.12+. The numeric CLIs need pint, uncertainties, NumPy, and SciPy; the static auditor is standard-library only. All bundled tooling runs locally with no network access.
allowed-tools: Read Write Edit Bash
metadata:
  version: "1.1"
  skill-author: K-Dense Inc.

Uncertainty and units

Scope

Use this skill whenever a calculation carries physical units or a reported number needs an uncertainty. Concretely:

• converting between units, including conversions that need a physical context (wavelength to photon energy, mass to amount of substance, energy to temperature);
• propagating uncertainty through a measurement model, with or without correlated inputs;
• building a GUM uncertainty budget from calibration certificates, specifications, and repeatability data;
• choosing a coverage factor and deciding whether k = 2 is defensible;
• rounding and writing a result so a reader knows what the ± means;
• extracting parameter uncertainties from a curve fit without discarding correlations;
• reviewing existing analysis code for silent unit and uncertainty defects;
• checking that a dimensionally consistent answer is also physically possible — the order of magnitude, the dimensionless group, and the regime it implies.

This skill covers the metrology and the two libraries that implement it. It does not cover statistical inference, model selection, or study design — see statistical-analysis, statistical-power, and experimental-design.

Current release and installation

Verified 2026-07-26:

• pint 0.25.3, released 2026-03-19; requires Python 3.11+.
• uncertainties 3.2.3, released 2025-04-21; requires Python 3.8+.
• NumPy 2.5.1 and SciPy 1.18.0; both require Python 3.12+.
• scipy.constants in SciPy 1.18.0 serves CODATA 2022. SciPy 1.11 and earlier served CODATA 2018, and several recommended values differ between them.

uv venv --python 3.13
source .venv/bin/activate
uv pip install "pint==0.25.3" "uncertainties==3.2.3" "numpy==2.5.1" "scipy==1.18.0"

pint-pandas and pint-xarray add unit-aware columns and arrays and are separate installs.

Non-negotiable workflow

1. Attach units at input and strip them only at output. Convert at function boundaries with ureg.wraps or m_as("unit"), never mid-calculation.
2. Write the measurement model explicitly before computing anything, including corrections whose estimated value is zero. A correction left out of the model leaves its uncertainty out of the budget.
3. Give every input four things: an estimate, a standard uncertainty, the distribution the uncertainty came from, and its degrees of freedom.
4. Convert Type B statements with the right divisor. A certificate's expanded uncertainty divides by its stated k; rectangular limits divide by sqrt(3).
5. Identify correlations before combining. Inputs calibrated against the same standard, measured on the same instrument, or drawn from the same fit are correlated.
6. Compute sensitivity coefficients, and read the budget from c_i * u(x_i) rather than from the raw uncertainties.
7. Check the linearization. Run Monte Carlo alongside the GUM framework and apply the JCGM 101 clause 8 comparison. Report the Monte Carlo result when it fails.
8. Choose k from the effective degrees of freedom, not by habit.
9. Round the uncertainty first, then the value to the same decimal place.
10. State what the ± is — standard or expanded, with k, the coverage probability, and the method.
11. Sanity-check the magnitude before reporting. A dimensionally consistent result can still be impossible. Compare it against a known scale or a dimensionless group, and confirm every assumption you relied on still holds in that regime.

The failures this skill exists to prevent

Each of the following runs without error and produces a plausible number.

A unit stripped at an unknown scale

length = (12.7 * ureg.mm).magnitude          # 12.7 -- of what?
length = (12.7 * ureg.mm).m_as("m")          # 0.0127 metres, stated

.magnitude returns whatever the quantity happened to be carrying. Name the unit at the point of extraction, every time.

Offset temperature arithmetic

Q(20, "degC") + Q(5, "degC")     # OffsetUnitCalculusError -- correctly refused
Q(20, "degC") + Q(5, "delta_degC")   # 25 degree_Celsius
Q(25, "degC") - Q(20, "degC")        # 5 delta_degree_Celsius

Celsius and Fahrenheit are interval scales. An uncertainty on a temperature is always a difference and belongs in a delta_ unit: converting 20 ± 0.5 degC to Fahrenheit gives 68 degF ± 0.9 delta_degF, two different conversions on one line.

Logarithmic units that add by multiplying

Q(10, "dBm") + Q(10, "dBm")   # 0.0001 kilogram**2 * meter**4 / second**6

That is 10 mW × 10 mW, not 20 mW and not 13 dBm. Nothing raises. Convert to a linear unit before any arithmetic.

A correlation destroyed by a round trip

x = ufloat(1.0, 0.1)
x - x                                     # 0.0+/-0
x - ufloat(x.nominal_value, x.std_dev)    # 0.00+/-0.14

Rebuilding a variable from its nominal value and standard deviation creates an independent variable. So does any serialization that passes through a pair of floats. Use correlated_values(values, covariance_matrix) to rebuild a correlated set.

A covariance matrix silently rescaled

popt, pcov = curve_fit(f, x, y, sigma=sigma)                        # default
popt, pcov = curve_fit(f, x, y, sigma=sigma, absolute_sigma=True)

The default rescales pcov by the reduced chi-square, so the parameter uncertainties absorb the goodness of fit and match what you would get by passing no sigma at all. On one synthetic straight-line fit the two give [0.0364, 0.2154] and [0.0477, 0.2820] — a 31% difference. Pass absolute_sigma=True whenever sigma holds real standard uncertainties.

A linearization that was never checked

For y = x² with x = 1.0 ± 0.5, the GUM framework gives y = 1.0, u_c = 1.0, and a 95% interval of [-0.96, 2.96] — mostly negative, for a squared quantity. Monte Carlo gives a mean of 1.25, u_c = 1.06, and a shortest 95% interval of [0, 3.32]. Nothing in a linear-propagation library will tell you this happened.

Bundled local CLIs

All helpers run offline, reject URLs and symlinks, bound their inputs, write output atomically with private permissions, and refuse to overwrite without --force.

python skills/uncertainty-and-units/scripts/propagate_uncertainty.py --help
python skills/uncertainty-and-units/scripts/uncertainty_budget.py --help
python skills/uncertainty-and-units/scripts/format_result.py --help
python skills/uncertainty-and-units/scripts/convert_units.py --help
python skills/uncertainty-and-units/scripts/audit_units.py --help
python skills/uncertainty-and-units/scripts/check_plausibility.py --help

propagate_uncertainty.py

Runs both propagation methods on the same model and applies the JCGM 101 clause 8 validation test.

python skills/uncertainty-and-units/scripts/propagate_uncertainty.py \
  --expression "m / (pi * (d / 2) ** 2 * h)" \
  --variable "m=250.0,0.05" \
  --variable "d=20.0,0.02,rectangular" \
  --variable "h=40.0,0.05,rectangular" \
  --measurand density --unit "g/cm3" --format markdown

Each --variable is name=value,standard_uncertainty[,distribution[,dof]], where the distribution is normal, rectangular, triangular, arcsine, or exact and controls Monte Carlo sampling only. Correlations go in as --correlation "a,b=0.9". A JSON --spec file holds the same model for anything long-lived.

The expression is parsed into an abstract syntax tree and reduced by an explicit walk over + - * / ** and a fixed list of functions. It is never compiled or executed.

The report gives the estimate, u_c, sensitivity coefficients, the budget in percent, effective degrees of freedom, k, U, both Monte Carlo coverage intervals, and the verdict on whether the linearized result may be reported.

uncertainty_budget.py

Combines components stated the way certificates and data sheets state them.

python skills/uncertainty-and-units/scripts/uncertainty_budget.py --template > budget.json
python skills/uncertainty-and-units/scripts/uncertainty_budget.py --spec budget.json --format markdown

Each component names a distribution that fixes its divisor — expanded divides by its coverage_factor, rectangular by sqrt(3), triangular by sqrt(6), arcsine by sqrt(2), normal by 1 — with an optional sensitivity, dof, and relative: true. The tool computes u_c, the Welch-Satterthwaite effective degrees of freedom, k from the t-distribution, and U, and warns when a Type A component has no degrees of freedom, when nu_eff is small enough that k = 2 is wrong, when one component dominates, and when a Type B component declared normal is probably an undivided expanded uncertainty.

format_result.py

python skills/uncertainty-and-units/scripts/format_result.py \
  --value 12.34567 --uncertainty 0.02345 --unit mm \
  --coverage-factor 2.26 --coverage-probability 0.95

Returns 12.346 ± 0.023 mm, 12.346(23) mm, the scientific and LaTeX forms, and the sentence that has to accompany the number. Warns when one significant digit is requested for an uncertainty beginning in 1 or 2, and when the uncertainty exceeds the estimate.

convert_units.py

python skills/uncertainty-and-units/scripts/convert_units.py \
  --value 532 --unit nm --to eV --context spectroscopy --uncertainty 0.5

python skills/uncertainty-and-units/scripts/convert_units.py \
  --value 1.0 --unit g --to mol --context chemistry --context-parameter "mw=180.156 g/mol"

Carries the uncertainty through the conversion's local derivative, which matters because context conversions are reciprocal rather than proportional. Names the context in the error message when a conversion needs one, and flags offset and logarithmic units. --list-contexts shows what the registry defines.

audit_units.py

Static review of existing analysis code. Parses, never imports or runs.

python skills/uncertainty-and-units/scripts/audit_units.py \
  --input analysis.py --format markdown --fail-on medium

Rule	Severity	Detects
UNIT001	medium	a second UnitRegistry in one module — cross-registry ValueError
UNIT002	medium	offset temperature units with no delta_ unit anywhere
UNIT003	high	.magnitude without a preceding .to(...) or .m_as(...)
UNIT004	medium	logarithmic units, whose + multiplies
UNC001	high	curve_fit without absolute_sigma
UNC002	medium	np.std / np.var without ddof
UNC003	medium	math or numpy functions in a module that uses uncertainties
UNC004	high	a ufloat rebuilt from .nominal_value and .std_dev
CONST001	low	a literal within 0.1% of a CODATA constant

Exit status is 1 when a finding meets --fail-on (default high), which makes it usable as a pre-commit or CI check.

The rules are heuristics, so a false positive is suppressed with a directive comment — trailing to cover its own line, or alone on a line to cover the next one:

value = quantity.magnitude  # audit-units: ignore UNIT003 -- already converted upstream

# audit-units: ignore UNC003 -- the argument here is a plain float array
scaled = np.log10(counts)

# audit-units: ignore-file CONST001 covers a whole module, and naming no rule suppresses all of them. Suppressions are counted in the report rather than hidden, so a file that silences everything still says so.

check_plausibility.py

Dimensional consistency is not physical possibility. A cell 2 m across and a Reynolds number of 4e7 in a capillary both pass every unit check. This tool tests a set of quantities against dimensionless groups, characteristic scales, and curated magnitude bands, and verifies each formula's dimensionality before reporting a number.

python skills/uncertainty-and-units/scripts/check_plausibility.py \
  --quantity "density=1060 kg/m**3" --quantity "velocity=0.5 mm/s" \
  --quantity "length=8 um" --quantity "viscosity=3.5 mPa*s" \
  --group reynolds --format markdown
# Re = 0.001211 -- laminar (circular pipe, length = diameter)

python skills/uncertainty-and-units/scripts/check_plausibility.py \
  --quantity "diameter=2 m" --band "eukaryotic_cell_diameter=diameter"
# implausible: 4.3 decades outside the 5-100 um range

--group evaluates one of 14 dimensionless groups and names the regime it places the system in; --scale computes a characteristic scale such as a diffusion time, Debye length, or Stokes settling velocity; --band compares a supplied quantity against an observed range. --list prints the whole catalogue with the inputs each formula needs.

Physical constants (k_B, N_A, R_gas, g_earth, and the rest) are available to every formula without being supplied, and are read from scipy.constants at run time rather than written as literals, so they track the CODATA release SciPy ships.

The dimensionality check is the point. Passing a kinematic viscosity where the formula needs a dynamic one — both called "viscosity", both tabulated for water, differing by a factor of ρ — is refused before any number is computed:

error: viscosity must have dimensionality [mass] / ([length] * [time]),
       but m²/s is [length] ** 2 / [time]

Exit status is 1 when the verdict meets --fail-on (default implausible; a value within one decade of a band is questionable). The thresholds are conventions with soft edges and assume the geometry their correlation was fitted for — see references/plausibility-scales.md for the characteristic length to use in each case.

Choosing a propagation method

Situation	Method
Linear or near-linear model, normal-ish inputs, large dof	GUM framework alone
Any nonlinearity across ±2u of an input	run both, apply the clause 8 test
Relative uncertainty above ~20% on any input	Monte Carlo
Dominant rectangular or otherwise non-normal component	Monte Carlo
Output bounded below (variance, concentration, squared quantity)	Monte Carlo
Asymmetric output distribution	Monte Carlo, shortest coverage interval
Correlated inputs	either, but supply the covariance matrix, not the standard uncertainties alone

A model dominated by rectangular contributions fails the clause 8 test even when it is perfectly linear: the framework's k = 1.96 over-covers a nearly trapezoidal output. The estimate and u_c are still right; only the interval is too wide.

Constants

Never type a constant from memory. The 2019 SI redefinition fixed c, h, e, k, and N_A exactly, so their relative standard uncertainty is zero; everything else is a measured value that moves between CODATA releases.

import scipy.constants as constants

constants.value("electron mass")        # 9.1093837139e-31
constants.unit("electron mass")         # kg
constants.precision("electron mass")    # 3.07e-10, relative standard uncertainty
constants.precision("Planck constant")  # 0.0, exact by definition

precision returns a relative standard uncertainty; multiply by the value for the absolute one.

Reference files

• references/gum-methodology.md — Type A and Type B evaluation, distribution divisors, the law of propagation, Welch-Satterthwaite, when the framework fails, the Monte Carlo procedure, and the clause 8 validation test.
• references/pint-recipes.md — registries, offset and logarithmic units, contexts, boundary enforcement with wraps and check, NumPy interoperability, custom units, formatting.
• references/uncertainties-recipes.md — variable identity and correlation, correlated_values, umath and unumpy, format specs, fit covariance matrices, and the package's limits.
• references/domain-conversions.md — the energy ladder, spectroscopy, concentration, pressure, radiation and magnetism, mass spectrometry, logarithmic quantities, and the pairs that share dimensions without sharing meaning.
• references/reporting-rules.md — rounding, notations, the sentence that must accompany a result, SD versus SEM versus CI in figures, non-detects, and conformity decision rules.
• references/plausibility-scales.md — choosing the characteristic length, the dimensionless groups and the modelling assumption each one gates, characteristic scales, the observed magnitude bands and their sources, and the caveats on every threshold.

Dated sources

Checked 2026-07-26:

• JCGM 100:2008, Evaluation of measurement data — Guide to the expression of uncertainty in measurement
• JCGM 101:2008, Supplement 1 — Propagation of distributions using a Monte Carlo method
• NIST Technical Note 1297
• CODATA internationally recommended values
• Pint on PyPI — 0.25.3, released 2026-03-19.
• Pint documentation, including non-multiplicative units and contexts.
• uncertainties on PyPI — 3.2.3, released 2025-04-21.
• uncertainties documentation
• scipy.constants reference

Citing Scientific Agent Skills

This skill is part of Scientific Agent Skills by K-Dense. If it materially contributed to a manuscript, report, presentation, or code release, add the paper to the references or software section and tell the user you did so:

Kassis, T., Agarwal, V., He, Y., Patel, D., & Brueckner, A. M. (2026). Scientific Agent Skills: A Library of Procedural Knowledge for Research Agents. arXiv:2609.00065. https://doi.org/10.48550/arXiv.2609.00065

Always cite the current version. The DOI and https://arxiv.org/abs/2609.00065 resolve to the latest arXiv version, so never append a version suffix such as v1. When network access is available, fetch https://arxiv.org/abs/2609.00065 (or http://export.arxiv.org/api/query?id_list=2609.00065) before writing the reference and take the author list, year, and version from that record. If the record lists a journal reference or publisher DOI, cite the published version instead.

Other files in this skill

• references/domain-conversions.md
• references/gum-methodology.md
• references/pint-recipes.md
• references/plausibility-scales.md
• references/reporting-rules.md
• references/uncertainties-recipes.md
• scripts/_common.py
• scripts/audit_units.py
• scripts/check_plausibility.py
• scripts/convert_units.py
• scripts/format_result.py
• scripts/propagate_uncertainty.py
• scripts/uncertainty_budget.py

references/domain-conversions.md (verbatim)

Domain conversions and dimensional blind spots

Values below were produced with pint 0.25.3 and SciPy 1.18.0 (CODATA 2022). Anything marked exact is fixed by definition and carries zero uncertainty.

Dimensional analysis does not catch these

Two quantities with the same dimensions convert freely, whether or not the conversion means anything.

Pair	Shared dimension	What pint does	Why it matters
gray and sievert	L²T⁻²	converts 1:1, silently	Sv includes a radiation weighting factor; the numbers coincide only for photons and electrons
newton-metre and joule	ML²T⁻²	converts 1:1, silently	torque is a vector product, energy a scalar; adding them is meaningless
hertz and becquerel	T⁻¹	converts 1:1, silently	one is periodic, the other stochastic
radian and dimensionless	none	radians vanish	sin(x) needs radians; a degrees value that lost its unit is silently wrong
mol/L and mol/kg	different	raises	molarity and molality are genuinely different quantities
mg/L and ppm	different	raises	equal only for dilute aqueous solutions near 1 g/mL

The last two raise because they are dimensionally distinct. The first four are the dangerous ones: no tool will warn you.

Energy ladder

Molecular science quotes the same energy in at least six units, three of which are per-mole and therefore need the Avogadro constant.

From	To	Factor
1 eV	kJ/mol	96.48533212331002
1 hartree	eV	27.21138624598103
1 hartree	kcal/mol	627.5094740628942
1 cm⁻¹	eV	1.2398419843320026e-4
1 cm⁻¹	K (as E/k_B)	1.4387768775039336
k_B T at 298.15 K	eV	0.02569257912108585
k_B T at 298.15 K	kJ/mol	2.478957029602389
1 cal (thermochemical)	J	4.184 (exact)
1 cal_IT	J	4.1868 (exact)

Two traps. First, per-mole and per-particle units are not dimensionally interchangeable: eV is an energy, kJ/mol is an energy per amount of substance, and the conversion needs N_A. Pint will refuse Q(1, "eV").to("kJ/mol") and accept Q(1, "eV * N_A").to("kJ/mol"). Second, there are two calories and a factor of 1.00067 between them; thermochemical is the default in chemistry, IT in engineering.

Q(1, "eV * N_A").to("kJ/mol")            # 96.48533212331002 kilojoule / mole
Q(1, "1/cm").to("eV", "sp")              # 0.00012398419843320026 electron_volt
Q(298.15, "K").to("eV", "boltzmann")     # 0.02569257912108585 electron_volt

Spectroscopy

Wavelength, frequency, wavenumber, and photon energy are related by physics, not by dimensional analysis, and the relations are reciprocal — an uncertainty does not convert by the same factor as the value.

Q(532, "nm").to("THz", "sp")     # 563.5196578947367 terahertz
Q(532, "nm").to("1/cm", "sp")    # 18796.992481203004 / centimeter
Q(532, "nm").to("eV", "sp")      # 2.3305300457368467 electron_volt

Because E = hc/λ, a constant wavelength uncertainty becomes an energy uncertainty that scales as 1/λ². Propagate through the relation, do not scale the uncertainty by the value's conversion factor. scripts/convert_units.py --uncertainty does this with the conversion's local derivative.

The sp context assumes vacuum unless given a refractive index: n=1.33 for water shifts a 532 nm frequency from 563.5 THz to 423.7 THz.

Concentration

Quantity	Unit	Depends on
Molarity	mol/L	temperature, through solution volume
Molality	mol/kg solvent	nothing — preferred for thermodynamics
Mole fraction	dimensionless	nothing
Mass fraction, ppm(m/m)	dimensionless	nothing
Volume fraction, ppm(v/v)	dimensionless	temperature
Mass concentration	mg/L, g/L	temperature

"ppm" alone is ambiguous: mass/mass, volume/volume, and mol/mol differ by the ratio of densities or molar masses. In environmental water chemistry ppm conventionally means mg/L, which equals mg/kg only because dilute water is close to 1 kg/L. In gas analysis it conventionally means volume/volume. State which.

Pint treats ppm and percent as plain dimensionless scale factors (1e-6 and 0.01), which is right for arithmetic and gives no protection against mixing the three senses. Defining ureg.define("ppm_v = 1e-6 = ppmv") as a distinct unit does give protection.

Mass and amount of substance need the chemistry context and a molar mass:

Q(1, "g").to("mol", "chemistry", mw=Q(180.156, "g/mol"))   # 0.005550744909966918 mole

Pressure

From	To Pa	Note
1 atm	101325	exact
1 bar	100000	exact
1 torr	133.32236842105263	atm/760, exact by definition
1 psi	6894.7572931683635
1 mmHg	133.322387415	not identical to torr, differs in the 8th digit

Gauge and absolute pressure are different quantities and no unit library models the difference. "psig" and "psia" have the same dimensions; a gauge reading needs the ambient pressure added before it can be used in a gas law. Vacuum work, autoclave protocols, and chromatography backpressures are where this bites.

Radiation, magnetism, rotation

Q(1, "Ci").to("Bq")               # 37000000000.0 becquerel   (exact by definition)
Q(1, "gauss").to("T", "Gaussian") # 9.999999999338245e-05 tesla
Q(1, "rpm").to("rad/s")           # 0.10471975511965977 radian / second

Gauss fails without the Gaussian context: CGS electromagnetic units have different dimensions from SI ones, not merely different scales. Magnetic field strength H (A/m, oersted) and magnetic flux density B (T, gauss) are distinct quantities that literature routinely calls "the field".

Mass spectrometry

The unified atomic mass unit and the dalton are the same thing: 1 Da = 1.66053906892e-27 kg (CODATA 2022, relative standard uncertainty 3.1e-10).

m/z is conventionally reported as a dimensionless number: the ratio of mass in daltons to charge number. The thomson (Th) exists but is not SI and is rarely used. Treating m/z as a mass is wrong for any ion with z > 1, which is most of a protein spectrum.

Logarithmic quantities

pH, pKa, dB, and magnitudes are logarithms of ratios. They do not add, average, or propagate like ordinary quantities:

• the mean of pH 5 and pH 7 is not pH 6 — averaging requires converting to concentration, averaging, and converting back;
• a standard deviation in pH units is a relative standard deviation in concentration;
• adding two dB quantities multiplies the underlying linear quantities (see pint-recipes.md);
• decibel scales differ by reference: dBm references 1 mW, dBW references 1 W, dBV references 1 V, and dB alone references nothing until you say so.

Temperature

Kelvin and rankine are ratio scales and behave normally. Celsius and Fahrenheit are interval scales: 20 degC is not "twice" 10 degC, and their differences live in delta_degC / delta_degF. See pint-recipes.md for what pint permits.

Absolute zero is exactly 273.15 K below 0 degC — scipy.constants.zero_Celsius.

Constants: which values, and which uncertainties

The 2019 SI redefinition fixed several constants exactly, so their relative standard uncertainty is zero and no future CODATA release will change them:

Constant	Exact value
speed of light in vacuum, c	299792458 m/s
Planck constant, h	6.62607015e-34 J/Hz
elementary charge, e	1.602176634e-19 C
Boltzmann constant, k	1.380649e-23 J/K
Avogadro constant, N_A	6.02214076e23 /mol

Everything else is a measured recommended value that moves between CODATA releases — electron mass, the gravitational constant, the fine-structure constant, the Rydberg constant, and every derived quantity built from them.

import scipy.constants as constants

constants.value("electron mass")       # 9.1093837139e-31
constants.unit("electron mass")        # kg
constants.precision("electron mass")   # 3.07e-10  relative standard uncertainty
constants.precision("Planck constant") # 0.0       exact by definition

scipy.constants in SciPy 1.18.0 defaults to CODATA 2022; SciPy 1.11 and earlier served CODATA 2018. Hard-coding a constant pins you to whichever release you copied it from and discards its uncertainty entirely. scripts/audit_units.py flags literals that match a known constant (CONST001).

Note also that constants.precision returns a relative standard uncertainty. The absolute standard uncertainty is value * precision.

references/gum-methodology.md (verbatim)

GUM methodology

The Guide to the Expression of Uncertainty in Measurement (JCGM 100:2008, "the GUM") and its Supplement 1 (JCGM 101:2008, the Monte Carlo method) define how an uncertainty is evaluated, combined, and reported. This file covers the parts that decide whether a number is defensible.

Vocabulary that has to stay straight

Term	Symbol	Meaning
Measurand	Y	the quantity intended to be measured
Estimate	y	the value obtained for it
Standard uncertainty	u(x)	uncertainty of an input, expressed as a standard deviation
Combined standard uncertainty	u_c(y)	standard uncertainty of the result
Expanded uncertainty	U	k * u_c(y)
Coverage factor	k	multiplier chosen for a stated coverage probability
Coverage probability	p	probability that the interval contains the measurand

"Error" and "uncertainty" are not synonyms. An error is a single unknowable difference from the true value; an uncertainty is a dispersion. "Accuracy" and "precision" are qualitative words in the GUM's vocabulary and never carry a number.

Type A and Type B are methods, not qualities

The distinction is only about how the uncertainty was evaluated. Neither is more reliable than the other, and both produce a standard uncertainty on the same footing.

Type A — evaluated from a statistical analysis of repeated observations.

For n independent readings with experimental standard deviation s(q):

u(q_bar) = s(q) / sqrt(n)          degrees of freedom: nu = n - 1

The standard uncertainty of the mean is what enters the budget when the reported value is a mean. Using s(q) itself overstates it by sqrt(n); using numpy.std without ddof=1 understates s(q) itself. Both mistakes are common and neither is visible in the output.

Pooling repeatability across several runs raises the degrees of freedom and is worth doing when the same instrument and procedure produced them.

Type B — evaluated by any other means: a calibration certificate, a manufacturer's specification, a handbook value, a previous measurement, or documented judgement.

The stated quantity is converted to a standard uncertainty by dividing by a factor that depends on what the statement means:

What the source states	Assumed density	Divisor	u
Expanded uncertainty U with coverage factor k	normal	k	U / k
95% confidence interval, no k given	normal	1.96	half-width / 1.96
A standard uncertainty	normal	1	as stated
Limits ±a, any value equally likely	rectangular	sqrt(3)	a / sqrt(3)
Limits ±a, centre far more likely	triangular	sqrt(6)	a / sqrt(6)
Limits ±a, extremes more likely (sinusoidal drift, cyclic error)	arcsine	sqrt(2)	a / sqrt(2)

Rectangular is the default when a specification gives limits and says nothing about the distribution inside them. Digital resolution of one least significant digit d gives half-width a = d/2, so u = d / (2 sqrt(3)).

The most frequent Type B error is treating a certificate's expanded uncertainty as a standard uncertainty: it silently doubles the reported interval.

Law of propagation of uncertainty

For a model Y = f(X_1, ..., X_N) with uncorrelated inputs (JCGM 100:2008 equation 10):

u_c(y)^2 = sum_i ( df/dx_i )^2 * u(x_i)^2

with correlated inputs (equation 13):

u_c(y)^2 = sum_i ( df/dx_i )^2 u(x_i)^2
         + 2 * sum_i sum_{j>i} (df/dx_i)(df/dx_j) u(x_i) u(x_j) r(x_i, x_j)

The partial derivatives are the sensitivity coefficients c_i. They carry units, and c_i * u(x_i) is the contribution of that input expressed in the units of the result. Comparing contributions, not raw uncertainties, is what tells you where to spend effort.

Correlation is not exotic. It appears whenever two inputs were calibrated against the same standard, corrected with the same reference value, measured with the same instrument, or derived from a common fit. Ignoring a positive correlation understates u_c; ignoring a negative one overstates it. In a difference of two similar quantities measured the same way, the correlation is the whole point — it is what makes the difference more precise than either term.

Degrees of freedom and the coverage factor

k = 2 is a convention, not a law. It corresponds to p ≈ 95% only when the effective degrees of freedom are large. The Welch-Satterthwaite formula (JCGM 100:2008 G.2b) gives them:

nu_eff = u_c(y)^4 / sum_i ( (c_i u(x_i))^4 / nu_i )

Components evaluated as Type B from a specification are conventionally assigned infinite degrees of freedom and drop out of the denominator. A single Type A component from a handful of readings can pull nu_eff low enough that k rises well above 2:

nu_eff	k for p = 95%
2	4.30
5	2.57
10	2.23
20	2.09
50	2.01
infinite	1.96

If the dominant component came from five readings, reporting k = 2 understates the interval by about a quarter. The formula assumes uncorrelated inputs; with correlation it is an approximation with no established validity.

When the GUM framework is not applicable

The framework linearizes f about the estimates. That is fine when the model is close to linear across the input uncertainties, and wrong when it is not. Specifically, it breaks down when:

• the model is significantly nonlinear over ±2u of an input — squares, reciprocals, ratios of comparable quantities, exponentials;
• a single non-normal component dominates, so the output is not approximately normal and k from a t-distribution does not deliver the claimed coverage;
• the output distribution is asymmetric, which the symmetric interval y ± U cannot represent;
• an input's relative uncertainty is large (above roughly 20-30%), where the second-order terms the expansion drops are no longer negligible;
• the model has a bound the interval crosses — a variance, a concentration, or a squared quantity whose GUM interval extends below zero.

Monte Carlo propagation (JCGM 101:2008)

The supplement propagates the input distributions rather than their standard deviations. The procedure is:

1. assign a probability density to each input, not merely a standard uncertainty;
2. draw M samples from the joint density, respecting any correlation;
3. evaluate the model for each draw;
4. take the mean as the estimate and the standard deviation as u_c;
5. take a coverage interval from the sorted output.

Two intervals are defined and they differ for an asymmetric output. The probabilistically symmetric interval cuts (1-p)/2 from each tail. The shortest interval is the narrowest one containing the fraction p; it is the honest choice when the output is skewed, and identical to the other when it is not.

M = 10^6 is the usual starting point for a 95% interval; JCGM 101 also defines an adaptive procedure that keeps drawing until the results are stable to within the numerical tolerance below. Fewer than 10^4 trials cannot resolve a 95% interval's endpoints reliably.

The validation test that decides which answer to report

JCGM 101 clause 8 is the reason to run both methods rather than choosing one. Write u_c from the GUM framework to n_dig significant digits (1 or 2) as c × 10^L. The numerical tolerance is half of that last digit:

delta = 0.5 * 10^L

Compare the endpoints of the two coverage intervals:

d_low  = | (y - U)      - y_low_MC  |
d_high = | (y + U)      - y_high_MC |

If both are at or below delta, the linearization is validated and the GUM framework result may be reported. If either exceeds delta, the framework is not validated for this model, and the Monte Carlo result is what should be reported.

scripts/propagate_uncertainty.py runs both methods and applies this test. Two outcomes worth understanding:

Rectangular inputs, linear model. A model dominated by rectangular contributions fails validation even though it is perfectly linear: the true output distribution is closer to trapezoidal than normal, and k = 1.96 over-covers. The GUM value and u_c are right; the interval is too wide.

Nonlinear model. For y = x^2 with x = 1.0 ± 0.5, the framework gives y = 1.0, u_c = 1.0, and a 95% interval of [-0.96, 2.96] — an interval that is largely negative for a squared quantity. Monte Carlo gives a mean of 1.25, u_c = 1.06, and a shortest 95% interval of [0, 3.32]. The framework result is not merely imprecise; it is outside the range the model can produce.

Order of operations

1. Write the measurement model explicitly, including every correction, even those whose value is zero. A correction with an estimated value of zero still has an uncertainty, and leaving it out of the model leaves its uncertainty out of the budget.
2. Assign each input an estimate, a standard uncertainty, a distribution, and degrees of freedom.
3. Identify correlations before combining anything.
4. Compute sensitivity coefficients and the budget.
5. Combine, and check the linearization against Monte Carlo.
6. Choose k from nu_eff, not by habit.
7. Round the uncertainty first, then the value (see reporting-rules.md).

Recurring defects

• Reporting a standard deviation of readings as the uncertainty of their mean.
• Dividing a certificate's expanded uncertainty by nothing, or by 2 when the certificate states a different k.
• Omitting a correction from the model because its value is negligible, thereby omitting its uncertainty too.
• Combining relative and absolute uncertainties without converting.
• Treating resolution and repeatability as independent when the resolution is what limits the repeatability — double counting.
• Quoting k = 2 with an effective degrees of freedom below 10.
• Applying the framework to a strongly nonlinear model and never checking.
• Propagating uncertainty through a fitted model without using the fit's covariance matrix, which discards the correlation between the fitted parameters.

references/pint-recipes.md (verbatim)

Pint recipes

Verified against pint 0.25.3 with NumPy 2.5.1. Every output below was produced by running the snippet.

One registry per process

A Quantity belongs to the registry that created it. Two registries produce quantities that cannot interact, and the failure is a bare ValueError far from the cause:

import pint

first = pint.UnitRegistry()
second = pint.UnitRegistry()
first.Quantity(1, "m") + second.Quantity(1, "m")
# ValueError: Cannot operate with Quantity and Quantity of different registries.

This bites hardest across module boundaries, where each module innocently creates its own registry at import time, and after unpickling, because a pickled quantity is restored against the application registry rather than the one that created it.

Build one registry and share it, or use the application registry everywhere:

import pint

ureg = pint.UnitRegistry()
pint.set_application_registry(ureg)

# in every other module
ureg = pint.get_application_registry()

Offset units

Degrees Celsius and Fahrenheit measure a point on a scale, not an amount, so multiplication and addition are undefined for them. Pint refuses rather than guessing:

Q = ureg.Quantity
Q(20, "degC") * 2
# OffsetUnitCalculusError: Ambiguous operation with offset unit (degree_Celsius).
Q(20, "degC") + Q(5, "degC")
# OffsetUnitCalculusError: Ambiguous operation with offset unit (...).

The delta units carry temperature differences, and mixed arithmetic works:

Q(20, "degC") + Q(5, "delta_degC")   # 25 degree_Celsius
Q(25, "degC") - Q(20, "degC")        # 5 delta_degree_Celsius

Note the second line: subtracting two absolute temperatures yields a delta unit automatically, which is correct and often surprising downstream.

An uncertainty on a temperature is always a difference. u = 0.5 degC means 0.5 delta_degC; converting it to Fahrenheit multiplies by 9/5 and applies no offset, giving 0.9 delta_degF. Converting the value 20 degC to Fahrenheit applies the offset and gives 68 degF. Two different conversions on the same line of a report.

pint.UnitRegistry(autoconvert_offset_to_baseunit=True) makes arithmetic proceed by converting to kelvin first. It removes the exception, not the ambiguity; enable it deliberately, not to silence an error.

Logarithmic units

Pint models dB, dBm, and friends as non-multiplicative units, and + on them means what it means in log space — multiplication of the underlying linear quantities:

Q(10, "dBm").to("mW")        # 10.000000000000002 milliwatt
Q(10, "dBm") + Q(10, "dBm")  # 0.00010000000000000005 kilogram**2 * meter**4 / second**6

The second line is 10 mW × 10 mW = 10^-4 W², not 20 mW and not 13 dBm. Nothing raises. Convert to a linear unit, do the arithmetic, convert back.

Contexts

Some conversions are physical relations rather than dimensional identities. Pint performs them only inside a named context, which is a feature: it forces the physics to be stated.

Q(532, "nm").to("THz", "sp")     # 563.5196578947367 terahertz
Q(532, "nm").to("1/cm", "sp")    # 18796.992481203004 / centimeter
Q(532, "nm").to("eV", "sp")      # 2.3305300457368467 electron_volt
Q(532, "nm").to("THz")           # DimensionalityError

Q(1, "g").to("mol", "chemistry", mw=Q(180.156, "g/mol"))   # 0.005550744909966918 mole
Q(298.15, "K").to("eV", "boltzmann")                       # 0.02569257912108585 electron_volt
Q(1, "gauss").to("T", "Gaussian")                          # 9.999999999338245e-05 tesla

The registry ships spectroscopy (sp), chemistry (chem), boltzmann, energy, textile, Gaussian (Gau), and ESU (esu). ureg.enable_contexts("sp") turns one on for every subsequent conversion and ureg.disable_contexts() turns it off again; prefer passing the context per call so the assumption stays visible at the point of use.

The spectroscopy context accepts a refractive index n, defaulting to 1 (vacuum). It matters more than it looks:

Q(532, "nm").to("THz", "sp")            # 563.5196578947367 terahertz
Q(532, "nm").to("THz", "sp", n=1.33)    # 423.69899089829823 terahertz

Note that gauss fails without the Gaussian context: CGS electromagnetic units have different dimensions from SI ones, not merely different scales.

Stripping the unit

.magnitude returns whatever number the quantity happens to be carrying, in whatever unit it happens to be in. That is the single most common way a unit error enters a correct-looking program:

length = (12.7 * ureg.mm).magnitude          # 12.7 -- but of what?
length = (12.7 * ureg.mm).to("m").magnitude  # 0.0127 metres, stated
length = (12.7 * ureg.mm).m_as("m")          # same, shorter

Always name the unit at the point of extraction. m_as exists precisely so there is no excuse.

Boundary enforcement

Rather than sprinkling conversions through a function, convert once at its boundary:

@ureg.wraps("J", ("N", "m"))
def work(force, distance):
    return force * distance

work(ureg.Quantity(2, "N"), ureg.Quantity(300, "cm"))   # 6.0 joule

wraps strips the declared units on the way in and reattaches the result unit on the way out, so the body is plain floats and stays fast. It defaults to strict=True, which rejects bare numbers:

work(2.0, 3.0)
# ValueError: A wrapped function using strict=True requires quantity or a string
# for all arguments with not None units.

strict=False accepts bare numbers and assumes they are already in the declared units. That is convenient and it is also exactly the assumption that unit tracking exists to avoid; use it only at an edge you control.

check validates dimensionality without converting:

@ureg.check("[length]", "[time]")
def speed(distance, elapsed):
    return distance / elapsed

speed(ureg.Quantity(10, "kg"), ureg.Quantity(2, "s"))
# DimensionalityError: Cannot convert from '10 kilogram' ([mass]) to 'a quantity of' ([length])

NumPy interoperability

A quantity can wrap an array, and most ufuncs and many array functions are supported:

import numpy as np

a = ureg.Quantity(np.array([1.0, 2.0, 3.0]), "m")
np.mean(a)                                             # 2.0 meter
np.concatenate([a, ureg.Quantity(np.array([100.0]), "cm")])   # [1.0 2.0 3.0 1.0] meter
np.concatenate([a, np.array([1.0])])
# DimensionalityError: Cannot convert from 'dimensionless' to 'meter'

Note that the mixed concatenation converted centimetres to metres correctly, and the bare array was rejected rather than assumed. Both behaviours are what you want.

Wrapped arrays carry per-operation overhead. In an inner loop, convert at the boundary with wraps or m_as and compute on raw arrays.

Custom units and definitions

ureg.define("cell = [cell_count] = cells")
ureg.define("od600 = [optical_density]")
ureg.define("percent_v_v = 0.01 = %v/v")

Defining a new base dimension in square brackets makes it dimensionally distinct from everything else, which is the point: cells / mL will then refuse to be added to particles / mL. Load a whole file of them with ureg.load_definitions("units.txt").

Formatting

q = ureg.Quantity(1.2345, "kg*m/s**2")
f"{q}"          # 1.2345 kilogram * meter / second ** 2
f"{q:~}"        # 1.2345 kg * m / s ** 2
f"{q:.3f~P}"    # 1.234 kg·m/s²
f"{q:~L}"       # 1.2345\ \frac{\mathrm{kg} \cdot \mathrm{m}}{\mathrm{s}^{2}}

~ gives short unit symbols, P pretty Unicode, L LaTeX, C compact ASCII. Numeric format specs come first and behave as usual.

With uncertainties

The two libraries compose: a ufloat magnitude inside a pint quantity converts and formats correctly.

from uncertainties import ufloat

q = ufloat(2.5, 0.1) * ureg.meter
q.to("cm")         # 250+/-10 centimeter
f"{q:.2uS}"        # 2.50(10) meter

Related packages

pint-pandas provides a pandas extension dtype so a DataFrame column carries a unit; pint-xarray does the same for xarray. Both are separate installs and both inherit the one-registry rule.

references/plausibility-scales.md (verbatim)

Plausibility: dimensionless groups, characteristic scales, and magnitude bands

Dimensional analysis proves a calculation is consistent. It cannot prove the answer is possible. A cell 2 m across, a Reynolds number of 4×10⁷ in a capillary, and a diffusion time of 300 years across a lipid bilayer are all dimensionally impeccable, and a unit-checking library will pass every one of them.

The three checks below close that gap. scripts/check_plausibility.py runs all of them and verifies dimensional consistency of each formula before reporting a number.

---

1. Choose the characteristic length first

The single most common error in this whole area is not an arithmetic slip — it is using the wrong length. The dimensionless groups are only meaningful with the length the correlation was fitted against.

Geometry	Characteristic length
Flow in a circular pipe	inside diameter, not radius
Flow in a non-circular duct	hydraulic diameter 4A/P
External flow over a plate	distance from the leading edge
Flow past a sphere or cylinder	diameter
Conduction in an irregular body (Biot)	volume / surface area
Packed bed	particle diameter
Open channel	hydraulic radius A/P — note: radius, not diameter

Using radius where the correlation wants diameter puts every threshold out by a factor of two, which is exactly the size of error that survives review.

2. Dimensionless groups and what they gate

Each threshold is a modelling decision boundary: past it, an assumption in your analysis stops holding.

Group	Definition	Threshold	What stops being true past it
Reynolds Re	ρvL/μ	2300 / 4000 (pipe)	laminar solutions; above 4000 you need a turbulence model
Péclet Pe	vL/D	≈ 1	below 1 diffusion dominates, so stirring will not help
Damköhler Da_I	kL/v	0.1 / 10	above 10 the reagent is consumed at the inlet, so the reactor is transport-limited
Knudsen Kn	λ/L	0.01	the no-slip boundary condition, then the continuum assumption itself
Mach Ma	v/c	0.3	incompressibility, at about 5% density change
Womersley Wo	R√(ωρ/μ)	1 / 10	the parabolic (Poiseuille) profile; above 10 the core moves as a plug
Capillary Ca	μv/σ	≈ 10⁻³	an interface whose shape is set by surface tension alone
Weber We	ρv²L/σ	≈ 12	drop integrity — above it, aerodynamic breakup
Bond Bo	Δρ g L²/σ	1	surface tension holding a drop against gravity
Stokes Stk	ρ_p d² v / (18 μ L)	0.1	the tracer assumption behind PIV and aerosol sampling
Biot Bi	hL/k	0.1	lumped-capacitance (uniform internal temperature)
Fourier Fo	αt/L²	0.05 / 1	the semi-infinite solution; above 1 the body has equilibrated
Schmidt Sc	μ/(ρD)	—	≈ 1 for gases, ≈ 10³ for small molecules in water
Deborah De	t_relax/t_obs	1	whether the material is a liquid or a solid on your timescale

Womersley takes angular frequency. Pass 2πf, not f. A resting human heart at 1.2 Hz gives ω ≈ 7.5 rad/s, and in the aorta Wo ≈ 20 — firmly plug-like, which is why Poiseuille's law is the wrong model for arterial flow and the right one for a capillary.

The Reynolds thresholds are pipe-flow values. Transition over a flat plate is around Re ≈ 5×10⁵; for flow past a sphere the wake becomes unsteady near Re ≈ 100. The tool reports the pipe classification and says so.

3. Characteristic scales

Scale	Formula	Sanity anchor
Diffusion time	L²/D	10 µm at 10⁻⁹ m²/s → 0.1 s
Thermal diffusion time	L²/α	same form, thermal diffusivity
Thermal energy	k_B T	4.14×10⁻²¹ J at 300 K
Molar thermal energy	RT	2.49 kJ/mol at 300 K
Stokes settling velocity	Δρ g d²/(18μ)	1 µm bead in water → ≈ 0.5 µm/s
Mean free path (gas)	k_BT/(√2 π d² p)	air at 1 atm → ≈ 68 nm
Debye length	√(ε₀ε_r k_B T / (2 N_A e² I))	100 mM → 0.96 nm
Capillary length	√(σ/(ρg))	water → 2.7 mm

The L² in diffusion time is the whole story of cell biology. Ten micrometres takes 0.1 s; one millimetre takes 1000 s; one centimetre takes 10⁵ s ≈ 28 hours. This is why cells are small, why tissue thicker than ~200 µm needs a blood supply, and why a claim that a molecule "diffuses across the tissue in seconds" is worth checking.

Stokes settling is valid only while the particle Reynolds number stays below ≈ 0.1. Compute the settling velocity, then feed it back into the reynolds group with the particle diameter as the length. If Re_p > 0.1, the drag law is wrong and the velocity is an overestimate.

4. Magnitude bands

These are deliberately generous observed ranges. A value outside one is worth a second look, not automatically wrong — the tool reports questionable inside one decade and implausible beyond it.

Band	Range	Source
Bacterial cell diameter	0.2–10 µm	Milo & Phillips, Cell Biology by the Numbers, ch. 1
Eukaryotic cell diameter	5–100 µm	Milo & Phillips, ch. 1
Cell membrane thickness	3–5 nm	Alberts et al., MBoC 7th ed., ch. 10
DNA base-pair rise	0.32–0.36 nm	Bloomfield et al., Nucleic Acids
Ribosome diameter	20–30 nm	Milo & Phillips, ch. 1
Protein molar mass	5–1000 kDa	Milo & Phillips, ch. 1
Human capillary diameter	5–10 µm	Guyton & Hall, 14th ed., ch. 16
Mammalian body temperature	306–315 K	Guyton & Hall, ch. 74
Resting heart rate	0.7–3 Hz	Guyton & Hall, ch. 9
Blood plasma osmolarity	275–300 mol/m³	Guyton & Hall, ch. 25
Small-molecule diffusivity in water	3×10⁻¹⁰–3×10⁻⁹ m²/s	Cussler, Diffusion 3rd ed., app. A
Protein diffusivity in water	10⁻¹¹–1.5×10⁻¹⁰ m²/s	Cussler, app. A
Dynamic viscosity of water	0.5–1.5 mPa·s	IAPWS R12-08
Surface tension of water	0.06–0.08 N/m	IAPWS R1-76
Speed of sound in water	1400–1560 m/s	Del Grosso & Mader, JASA 52:1442 (1972)
Speed of sound in air	320–350 m/s	Cramer, JASA 93:2510 (1993)
Sea-level atmospheric pressure	95–105 kPa	ISO 2533
Earth surface gravity	9.76–9.84 m/s²	WGS 84 normal gravity
Visible wavelength	380–750 nm	CIE S 017:2020
Non-covalent bond energy	1–40 kJ/mol	Israelachvili 3rd ed., ch. 2
Covalent bond energy	150–1000 kJ/mol	Atkins & de Paula 12th ed.
ATP hydrolysis free energy	40–60 kJ/mol	Milo & Phillips, ch. 4

Compare binding energies against RT, not against zero. At 300 K, RT is 2.5 kJ/mol. A reported binding free energy of 1 kJ/mol is not a weak interaction; it is indistinguishable from thermal noise.

5. The three errors this catches

A quantity of the wrong kind. Kinematic viscosity (m²/s) where the formula needs dynamic (Pa·s) is the classic. Both are called "viscosity", both are tabulated for water, and they differ by a factor of ρ ≈ 1000. The dimensionality check refuses it before any number is computed:

error: viscosity must have dimensionality [mass] / ([length] * [time]),
       but m²/s is [length] ** 2 / [time]

A unit prefix slip. Micro for milli is three decades. The magnitude bands catch it whenever the quantity is one the table knows.

An assumption used outside its regime. Applying Poiseuille's law at Wo = 20, the lumped-capacitance model at Bi = 5, or Stokes drag at Re_p = 30 all produce a number. The group tells you the number is meaningless.

6. Caveats

• The thresholds are conventions with soft edges, not physical constants. Re = 2400 in a very smooth pipe can stay laminar; Re = 2000 with a disturbed inlet may not.
• Every group assumes the geometry its correlation was fitted for. Check §1 before trusting a classification.
• The bands describe typical observed values, not physical limits. Extremophiles, engineered materials, and pathological states legitimately sit outside them — which is why the tool warns rather than refuses.
• A plausible verdict means nothing contradicted the tables. It is not a correctness proof, and it says nothing about whether the measurement was any good — for that, see references/gum-methodology.md.

Sources

Checked 2026-07-26:

• White, Fluid Mechanics, 8th ed. — Reynolds, Mach, pipe-flow transition.
• Deen, Analysis of Transport Phenomena, 2nd ed. — Péclet, Schmidt, boundary layers.
• Incropera et al., Fundamentals of Heat and Mass Transfer — Biot, Fourier.
• Bruus, Theoretical Microfluidics — capillary number, low-Reynolds flow.
• Berg, Random Walks in Biology — diffusion times, the L² scaling.
• Phillips et al., Physical Biology of the Cell, 2nd ed. — k_BT as the biological energy scale.
• Milo & Phillips, Cell Biology by the Numbers — biological magnitude bands; bionumbers.hms.harvard.edu.
• Israelachvili, Intermolecular and Surface Forces, 3rd ed. — Debye length, bond energies.
• Cussler, Diffusion, 3rd ed. — diffusivity tables.
• CODATA internationally recommended values — reached through scipy.constants, never typed as literals.

Back to K-Dense-AI/scientific-agent-skills (AI Scientist skills) or Agent skills.