Glossary

Our technical reports and SQL queries use symbols, variable names, and named concepts repeatedly, without re-explaining them each time. This page collects all of them in one place — what sigma_gt, notta, a "Failure Fingerprint," a "masking blind spot," and every other such term actually mean.

Symbols & variables

comp_*: The eight reconstruction-side diagnostic features (sharpness, edges, artifact_ringing, artifact_block, contrast, texture, entropy, noise) computed directly from an 8×8 image block. Full definitions and implementation are in DOI 1.8; an overview is on Technology.
σ_gt (sigma_gt): The standard deviation of pixel values within one ground-truth 8×8 block — this project's block-level measure of local contrast/texture in the original, unprocessed image. Feeds directly into SSIM's contrast (C) and structure (S) terms.
σ_notta (sigma_notta): The same standard-deviation measure, computed instead from the model's noTTA reconstruction of that block (not the ground truth). Compared against σ_gt to test how closely a reconstruction's local contrast matches the original.
σ_stat (sigma_stat): An empirically-derived threshold along the σ_gt axis, found via a Two-Segment Optimal Split procedure, marking where a model's texture-axis behavior changes regime. See DOI 1.4, 1.10, and 1.12 (a published correction) for its derivation.
μ_gt (mu_gt): The mean pixel value within one ground-truth 8×8 block — this project's block-level measure of local brightness/luminance. Feeds directly into SSIM's luminance (L) term.
μ_notta (mu_notta): The same mean-pixel-value measure as μ_gt, computed instead from the model's noTTA reconstruction of that block (not the ground truth). Compared against μ_gt to test how closely a reconstruction's brightness matches the original — see DOI 1.18.
μ_stat (mu_stat): The same kind of empirically-derived threshold as σ_stat, but along the μ_gt (luminance) axis instead of the σ_gt (texture) axis.
notta / TTA: The two inference conditions every block is evaluated under. notta ("no test-time augmentation") is a single, direct reconstruction pass. TTA (test-time augmentation) reconstructs the same image from several augmented copies of the input and averages the results — a common technique intended to improve output quality. In the super-resolution literature specifically, this technique is usually called self-ensemble, following EDSR's original "geometric self-ensemble" strategy; "TTA" is the more general term used across computer vision as a whole. See Technology.
Δssim (delta_ssim): The TTA condition's SSIM score minus the noTTA condition's SSIM score, at the same block coordinate. Positive means TTA improved the score at that block; negative means it made it worse.
L, C, S: SSIM's three multiplicative components — Luminance, Contrast, Structure — whose product (L×C×S) is the overall SSIM score for a block. See What Is SSIM? for the full picture.
ρ (Pearson correlation): A measure (−1 to 1) of how closely two blocks' pixel patterns match in shape — independent of their actual brightness (μ_gt) or spread (σ_gt). ρ=1 means the deviations from each block's own mean rise and fall in exactly the same proportion, even if one block is much brighter or more spread out than the other. Feeds SSIM's structure term S (S=(σ_xy+C₃)/(σ_xσ_y+C₃), where ρ=σ_xy/(σ_xσ_y)). Worth distinguishing from σ_xy (covariance, which appears in that same formula) — despite the shared σ notation, σ_xy is not the same quantity as σ_gt/σ_notta (standard deviation). Unlike μ_gt or σ_gt, σ_xy can't be computed from either block alone: for pixels x_i (ground truth) and y_i (reconstruction), it's the average of (x_i−μ_gt)×(y_i−μ_notta) over every pixel pair in the block — it needs both images' pixels matched up position by position, not just each block's own mean and spread. Worked example and diagram in DOI 1.18.
is_comp_zero / comp_zero: A boolean flag from the project's original, now-retired JOIN-based database schema, meaning "all 8 comp_* features are exactly 0 for this block." Retired because the JOIN step it depended on was found to have repeated data-integrity bugs — see Superseded Files. Current databases compute comp_* features directly, with no such flag.
n_features_matched: How many of a block's 8 comp_* features exactly equal the ground truth's own comp_* values at that same coordinate — an integer from 0 to 8.

Terms & concepts

Merutan condition

This series' name for the filter is_comp_zero = TRUE AND delta_ssim != 0 (see is_comp_zero above) — blocks whose reconstruction is fully degenerate/flat, yet whose SSIM score still changed between noTTA and TTA. This population is the source data for μ_stat.

Phase-transition curve

A curve built by binning blocks along μ_gt or σ_gt and plotting a spread statistic (typically STDDEV(ABS(delta_ssim)) or average S) per bin. It typically looks flat, then bends sharply at some point — that bend is what the Two-Segment Optimal Split locates, giving μ_stat/σ_stat.

Critical point (μ_c, σ_c)

The theoretical, closed-form values μ_c=√(C1/2) and σ_c=√C3, derived algebraically from SSIM's own stabilization constants (C1, C2, C3) rather than measured from data. Comparing a model's empirically-measured μ_stat/σ_stat against these gives the Failure Fingerprint.

Failure Fingerprint (Δμ, Δσ)

The deviation coordinate (μ_stat−μ_c, σ_stat−σ_c) — how far a given model's actual, measured transition points sit from the theoretical critical points. Used throughout this series as a compact, per-model summary statistic.

Two-Segment Optimal Split

The SQL procedure that locates a phase-transition curve's bend point by trying every possible split and keeping whichever one minimizes combined within-segment variance. Explained in full, with the SQL, in How to read SQL.

Luminance Bias (Amplification Phase)

The luminance-axis counterpart to the masking blind spot below: in a region below the critical point μ_c, SSIM's luminance term L becomes hypersensitive to tiny reconstruction errors, since the signal itself (μ_gt²) is small relative to the stabilization constant C1 in the term's denominator. A visually imperceptible shift of a single 8-bit level can noticeably lower the overall score. See About for a worked example.

Masking blind spot

The identity proved in DOI 1.11: whenever a ground-truth block is perfectly flat (σ_gt=0), SSIM's structure term S is mathematically forced to exactly 1, regardless of what the reconstruction actually contains. A real limitation of SSIM as a metric, not a bug in this project's own computation — see What Is SSIM?. Practical consequence: an observed score increase in a σ_gt=0 region can't be read as genuine improvement, since S is mathematically forced to 1 there no matter what the reconstruction actually did — contrast with the nonzero-σ ties in DOI 1.16, where SSIM is not fooled this way. Also referred to on this site as Structural Masking — see About for a worked example.

Pixel Identity Theorem

The identity that SSIM=1.0 for a block forces that block's reconstruction to be pixel-identical to ground truth (and, conversely, tests whether pixel-identical comp_* features force SSIM=1.0 — see DOI 1.15).

Tier3 (state)

This project's four-way, per-block collapse classification, comparing noTTA and TTA outcomes: Stable (no collapse either way), Persistent (collapse under both), Escape (collapse under noTTA, but TTA corrects it), BlindSpot (no collapse under noTTA, but TTA reveals one). See DOI 1.6.

Axis1

A signed bias-direction score per block, derived from the first principal component of SSIM's internal feature space. Positive values indicate a bias toward degradation, negative toward improvement/suppression. See DOI 1.7 (introduced in the earlier DOI 1.3).

Axis5

A Mahalanobis-distance-based collapse-intensity measure per block, combining multiple comp_* features with learned weights into a single severity score. See DOI 1.7.

Degenerate (block / reconstruction)

A block whose reconstruction is fully flat/blank — all 8 comp_* features equal to exactly 0. The population is_comp_zero flags (in older schemas) or that a direct all-8-comp_*-fields-zero check identifies (in current ones).

Hallucinate / hallucination

When a model's reconstruction contains detail (measured here mainly via sharpness) that shouldn't exist given a perfectly flat ground truth — the model has effectively invented texture out of nothing. Characterized in DOI 1.11.

Distinct-value count (COUNT(DISTINCT))

"Distinct" means ignoring duplicates: the distinct values in [1, 2, 2, 3] are {1, 2, 3} — three of them, not four. SQL's

COUNT(DISTINCT
        column)

counts how many different exact values a column actually takes across every row. We use it to ask: out of this project's roughly 79 million blocks, how many truly different σ_gt (or μ_gt) values actually occur? A distinct-value count much smaller than the number of blocks means many blocks must be landing on the exact same value by coincidence — see 8-bit pixel quantization below for why that happens, and floating-point ghost duplication for a pitfall in measuring this count accurately.

8-bit pixel quantization

Pixel brightness values in an 8-bit image can only be one of 256 integers (0–255), not any real number. Because a block's σ_gt is computed from a small, fixed set of these integers, only a limited number of exact σ_gt values are mathematically possible — so across millions of blocks, many land on the exact same value by coincidence, with no connection between their actual content. Explained with a worked example and diagram in DOI 1.16.

Floating-point ghost duplication

Floating-point addition is not strictly associative -- the exact order operations happen to execute in can change the result by the smallest possible bit:

>>> (0.1 + 0.2) + 0.3
0.6000000000000001
>>> 0.1 + (0.2 + 0.3)
0.6

Mathematically these are the same number, 0.6, but the computer stores two different bit patterns depending on which addition happened first. When the same true numeric value in this project's database gets computed via two slightly different operation orders like this, a naive COUNT(DISTINCT) counts the result as two separate values rather than one, inflating the true count. One real example: two unrelated blocks that happen to share the same true σ_gt (≈0.0004863513439456968) because of 8-bit quantization (see above) were found stored with a gap of 5.421010862427522e-20 — exactly 2^-64, a clean IEEE 754 machine constant (see below), not a real difference. Corrected for via a tolerance-based adjacent-gap recount in DOI 1.21.

IEEE 754 (double-precision floating point)

The standard nearly every computer uses to store non-integer numbers: a number is kept as a sign, a roughly 52-bit mantissa (its significant digits), and an exponent (a power of two) — sign × mantissa × 2^exponent. Because of this, the smallest possible gap between two storable numbers near a given magnitude — called a ULP, "unit in the last place" — is always an exact power of two relative to that magnitude, never an arbitrary small number. That's what makes a gap like 2^-64 (see floating-point ghost duplication above) recognizable as a rounding artifact rather than a genuine numeric difference: a real gap between two independently measured quantities essentially never lands on a clean power of two by coincidence.