chialoops 1.0.0__py3-none-any.whl

chia/analysis/__init__.py

@@ -0,0 +1 @@
+"""Post-design analysis utilities (carbon/sustainability modeling, etc.)."""

chia/analysis/sustainability/__init__.py

@@ -0,0 +1,23 @@
+from chia.analysis.sustainability.focal import (
+    ALPHA_EMBODIED_DOMINATED,
+    ALPHA_OPERATIONAL_DOMINATED,
+    SWEEPABLE_PARAMETERS,
+    FocalBothRefs,
+    FocalComparison,
+    FocalSweep,
+    focal_compare,
+    focal_sweep,
+    sweep_both_arches_as_ref,
+)
+
+__all__ = [
+    "ALPHA_EMBODIED_DOMINATED",
+    "ALPHA_OPERATIONAL_DOMINATED",
+    "SWEEPABLE_PARAMETERS",
+    "FocalBothRefs",
+    "FocalComparison",
+    "FocalSweep",
+    "focal_compare",
+    "focal_sweep",
+    "sweep_both_arches_as_ref",
+]

chia/analysis/sustainability/focal.py

@@ -0,0 +1,472 @@
+"""FOCAL: a first-order carbon model for comparing processor architectures.
+
+Implements the Normalized Carbon Footprint (NCF) metric from Lieven Eeckhout,
+"FOCAL: A First-Order Carbon Model to Assess Processor Sustainability"
+(ASPLOS '24, https://doi.org/10.1145/3620665.3640415).
+
+FOCAL weighs a design's *embodied* footprint (proxied by chip area) against its
+*operational* footprint (proxied by power under a fixed-time use case, or by
+energy under a fixed-work use case) using a single embodied-to-operational
+weight ``alpha`` in [0, 1]. Comparing a ``test`` design against a ``ref``
+baseline, the fixed-time NCF is::
+
+    NCF(test, ref) = alpha * (A_test / A_ref) + (1 - alpha) * (P_test / P_ref)
+
+where ``A`` is chip area and ``P`` is power consumption. ``NCF < 1`` means the
+test design has a lower total carbon footprint than the reference (i.e. it is
+more sustainable); ``NCF > 1`` means it is worse; ``NCF == 1`` means the two are
+carbon-equal. The same expression holds for the fixed-work scenario with energy
+substituted for power.
+
+``alpha`` is the embodied-to-operational weight in [0, 1]. Paper scenarios:
+``alpha = 0.8`` (embodied-dominated, e.g. mobile and datacenter hardware) and
+``alpha = 0.2`` (operational-dominated, e.g. always-connected devices).
+"""
+
+from __future__ import annotations
+
+import sys
+import textwrap
+import warnings
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+
+# Embodied-to-operational weight scenarios from the FOCAL paper (Section 5).
+ALPHA_EMBODIED_DOMINATED = 0.8     # e.g. mobile / datacenter hardware
+ALPHA_OPERATIONAL_DOMINATED = 0.2  # e.g. always-connected devices
+
+# The five FOCAL parameters that focal_sweep can vary.
+SWEEPABLE_PARAMETERS = ("test_pwr", "ref_pwr", "test_area", "ref_area", "alpha_ref")
+
+_PARAM_LABELS = {
+    "test_pwr": "test power",
+    "ref_pwr": "ref power",
+    "test_area": "test area",
+    "ref_area": "ref area",
+    "alpha_ref": r"embodied-to-operational weight $\alpha$",
+}
+
+
+@dataclass
+class FocalComparison:
+    """FOCAL comparison of a ``test`` architecture against a ``ref`` baseline.
+
+    Computed under the fixed-time scenario, i.e. power is the operational
+    proxy. (Pass energy in place of power to evaluate the fixed-work scenario;
+    the NCF expression is identical.)
+    """
+
+    ncf: float                 # normalized carbon footprint NCF(test, ref)
+    embodied_ratio: float      # A_test / A_ref  (normalized embodied footprint)
+    operational_ratio: float   # P_test / P_ref  (normalized operational footprint)
+    alpha_ref: float           # embodied-to-operational weight used
+    # Operating point echoed back for traceability.
+    test_pwr: float
+    ref_pwr: float
+    test_area: float
+    ref_area: float
+
+    @property
+    def more_sustainable(self) -> bool:
+        """True if the test design has a strictly lower carbon footprint."""
+        return self.ncf < 1.0
+
+    @property
+    def verdict(self) -> str:
+        """Human-readable verdict for the test design relative to ref."""
+        if self.ncf < 1.0:
+            return "more sustainable"
+        if self.ncf > 1.0:
+            return "less sustainable"
+        return "equally sustainable"
+
+    @property
+    def pct_change(self) -> float:
+        """Percent change in carbon footprint of test vs ref.
+
+        Negative means a reduction (more sustainable); e.g. -30.0 means the
+        test design emits 30% less carbon than the reference.
+        """
+        return (self.ncf - 1.0) * 100.0
+
+    @property
+    def breakeven_alpha(self) -> float | None:
+        """Embodied weight ``alpha`` at which test and ref are carbon-equal.
+
+        Solves ``NCF(alpha) = 1`` for alpha at the current area and power
+        ratios::
+
+            alpha* = (1 - P_test/P_ref) / (A_test/A_ref - P_test/P_ref)
+
+        Returns None when the embodied and operational ratios are equal (NCF
+        does not depend on alpha, so there is no crossing). A value outside
+        [0, 1] means the verdict never flips within the valid weight range,
+        i.e. the test design is uniformly more or less sustainable.
+        """
+        if self.embodied_ratio == self.operational_ratio:
+            return None
+        return (1.0 - self.operational_ratio) / (self.embodied_ratio - self.operational_ratio)
+
+
+def focal_compare(
+    test_pwr: float,
+    ref_pwr: float,
+    test_area: float,
+    ref_area: float,
+    alpha_ref: float,
+) -> FocalComparison:
+    """Compare a ``test`` architecture against a ``ref`` baseline with FOCAL.
+
+    Computes the Normalized Carbon Footprint (NCF) of the test design relative
+    to the reference under the fixed-time scenario::
+
+        NCF = alpha_ref * (test_area / ref_area)
+              + (1 - alpha_ref) * (test_pwr / ref_pwr)
+
+    ``NCF < 1`` means the test design has a lower total carbon footprint than
+    the reference (more sustainable); ``NCF > 1`` means it is worse.
+
+    Args:
+        test_pwr: Power of the test design (operational proxy, numerator).
+            Substitute energy to evaluate the fixed-work scenario instead.
+        ref_pwr: Power of the reference design (operational proxy, denominator).
+        test_area: Chip area of the test design (embodied proxy, numerator).
+        ref_area: Chip area of the reference design (embodied proxy, denominator).
+        alpha_ref: Embodied-to-operational weight in [0, 1] (the FOCAL
+            ``alpha_E2O``). 0.8 = embodied-dominated, 0.2 = operational-dominated.
+
+    Returns:
+        A FocalComparison with the NCF, its embodied/operational components,
+        and convenience verdicts.
+
+    Raises:
+        ValueError: if a denominator is non-positive, an input is negative, or
+            ``alpha_ref`` is outside [0, 1].
+    """
+    if ref_pwr <= 0.0 or ref_area <= 0.0:
+        raise ValueError("ref_pwr and ref_area must be positive (they are denominators)")
+    if test_pwr < 0.0 or test_area < 0.0:
+        raise ValueError("test_pwr and test_area must be non-negative")
+    if not 0.0 <= alpha_ref <= 1.0:
+        raise ValueError(f"alpha_ref must be in [0, 1], got {alpha_ref}")
+
+    embodied_ratio = test_area / ref_area
+    operational_ratio = test_pwr / ref_pwr
+    ncf = alpha_ref * embodied_ratio + (1.0 - alpha_ref) * operational_ratio
+    return FocalComparison(
+        ncf=ncf,
+        embodied_ratio=embodied_ratio,
+        operational_ratio=operational_ratio,
+        alpha_ref=alpha_ref,
+        test_pwr=test_pwr,
+        ref_pwr=ref_pwr,
+        test_area=test_area,
+        ref_area=ref_area,
+    )
+
+
+@dataclass
+class FocalSweep:
+    """NCF of a test/ref pair as one FOCAL parameter is swept over a range."""
+
+    parameter: str                       # which of the five params was swept
+    values: list[float]                  # swept parameter values
+    ncf: list[float]                     # NCF at each swept value
+    comparisons: list[FocalComparison]   # full comparison at each swept value
+    breakevens: list[float]              # swept values where NCF crosses 1.0
+    # Nominal operating point (the swept field holds its nominal value here).
+    test_pwr: float
+    ref_pwr: float
+    test_area: float
+    ref_area: float
+    alpha_ref: float
+
+    @property
+    def crosses_unity(self) -> bool:
+        """True if the verdict flips (NCF crosses 1) within the swept range."""
+        return bool(self.breakevens)
+
+
+@dataclass
+class FocalBothRefs:
+    """Two alpha sweeps comparing arch A and arch B, each taken as the reference.
+
+    Holds the ``arch_a_ref`` sweep (A is the reference, so the test design is B)
+    and the ``arch_b_ref`` sweep (B is the reference, so the test design is A).
+    See ``sweep_both_arches_as_ref`` for why both directions matter.
+    """
+
+    arch_a_ref: FocalSweep   # arch A as reference, test design is arch B
+    arch_b_ref: FocalSweep   # arch B as reference, test design is arch A
+
+
+def focal_sweep(
+    test_pwr: float,
+    ref_pwr: float,
+    test_area: float,
+    ref_area: float,
+    alpha_ref: float,
+    *,
+    sweep: str = "alpha_ref",
+    values: Sequence[float] | None = None,
+    num: int = 51,
+    span: float = 2.0,
+    plot_path: str | Path | None = None,
+) -> FocalSweep:
+    """Sweep one FOCAL parameter and report NCF across the range.
+
+    Holds four of the five FOCAL parameters fixed at the values passed in and
+    varies the fifth (``sweep``), recomputing the test-vs-ref NCF at each point.
+    This mirrors the paper's sensitivity analyses: sweeping ``alpha_ref`` shows
+    how the verdict shifts between operational- and embodied-dominated regimes,
+    while sweeping an area or power term traces NCF against that dimension.
+
+    Args:
+        test_pwr: Nominal test power.
+        ref_pwr: Nominal reference power.
+        test_area: Nominal test area.
+        ref_area: Nominal reference area.
+        alpha_ref: Nominal embodied-to-operational weight in [0, 1].
+        sweep: Name of the parameter to vary; one of ``SWEEPABLE_PARAMETERS``.
+        values: Explicit values to sweep. If None, a default range is built:
+            ``alpha_ref`` sweeps [0, 1]; any other parameter sweeps from
+            ``nominal / span`` to ``nominal * span``.
+        num: Number of points in the default range (ignored if ``values`` given).
+        span: Multiplicative half-range for non-alpha default sweeps.
+        plot_path: If given, save a PNG of NCF vs the swept parameter there
+            (requires matplotlib, imported lazily).
+
+    Returns:
+        A FocalSweep with the swept values, the NCF at each, the per-point
+        FocalComparison objects, and any NCF==1 break-even crossings.
+
+    Raises:
+        ValueError: if ``sweep`` is not a FOCAL parameter, or a default range
+            cannot be built because the nominal swept value is non-positive.
+    """
+    if sweep not in SWEEPABLE_PARAMETERS:
+        raise ValueError(f"sweep must be one of {SWEEPABLE_PARAMETERS}, got {sweep!r}")
+    if sweep in ("ref_pwr", "ref_area"):
+        _warn_ref_sweep(sweep)
+
+    base = {
+        "test_pwr": test_pwr,
+        "ref_pwr": ref_pwr,
+        "test_area": test_area,
+        "ref_area": ref_area,
+        "alpha_ref": alpha_ref,
+    }
+
+    if values is not None:
+        swept_values = [float(v) for v in values]
+    elif sweep == "alpha_ref":
+        swept_values = _linspace(0.0, 1.0, num)
+    else:
+        nominal = base[sweep]
+        if nominal <= 0.0:
+            raise ValueError(
+                f"cannot auto-range {sweep} from a non-positive nominal "
+                f"({nominal}); pass explicit values=..."
+            )
+        swept_values = _linspace(nominal / span, nominal * span, num)
+
+    comparisons: list[FocalComparison] = []
+    for v in swept_values:
+        params = dict(base)
+        params[sweep] = v
+        comparisons.append(focal_compare(**params))
+
+    ncf = [c.ncf for c in comparisons]
+    breakevens = _level_crossings(swept_values, ncf, 1.0)
+
+    result = FocalSweep(
+        parameter=sweep,
+        values=swept_values,
+        ncf=ncf,
+        comparisons=comparisons,
+        breakevens=breakevens,
+        test_pwr=test_pwr,
+        ref_pwr=ref_pwr,
+        test_area=test_area,
+        ref_area=ref_area,
+        alpha_ref=alpha_ref,
+    )
+    if plot_path is not None:
+        _plot_sweep(result, plot_path)
+    return result
+
+
+def sweep_both_arches_as_ref(
+    arch_a_pwr: float,
+    arch_a_area: float,
+    arch_b_pwr: float,
+    arch_b_area: float,
+    *,
+    values: Sequence[float] | None = None,
+    num: int = 51,
+    plot_path: str | Path | None = None,
+) -> FocalBothRefs:
+    """Sweep alpha comparing two architectures with *each* used as the reference.
+
+    The NCF metric is not symmetric: ``NCF(X, Y) != 1 / NCF(Y, X)`` in general,
+    because NCF is a weighted *sum* of the area and power ratios rather than a
+    single ratio (in fact ``NCF(X, Y) * NCF(Y, X) >= 1``). The reference design
+    is the denominator, so for the *same* alpha you can get a different NCF — and
+    even a different verdict — depending on which architecture you pick as the
+    reference. There is no privileged "baseline" here, so it is worth looking at
+    both directions before concluding that one design is more sustainable.
+
+    This runs two alpha sweeps over the same grid: one with arch A as the
+    reference (test design is B) and one with arch B as the reference (test
+    design is A). Compare the two curves at a given alpha to see the asymmetry.
+
+    Args:
+        arch_a_pwr: Power of architecture A.
+        arch_a_area: Chip area of architecture A.
+        arch_b_pwr: Power of architecture B.
+        arch_b_area: Chip area of architecture B.
+        values: Explicit alpha values to sweep. If None, sweeps [0, 1].
+        num: Number of alpha points in the default range (ignored if ``values``).
+        plot_path: If given, save a PNG overlaying both NCF curves vs alpha
+            (requires matplotlib, imported lazily).
+
+    Returns:
+        A FocalBothRefs holding the ``arch_a_ref`` and ``arch_b_ref`` sweeps.
+    """
+    # Placeholder alpha_ref; it is overridden at every point of the alpha sweep.
+    arch_a_ref = focal_sweep(
+        test_pwr=arch_b_pwr, ref_pwr=arch_a_pwr,
+        test_area=arch_b_area, ref_area=arch_a_area,
+        alpha_ref=0.5, sweep="alpha_ref", values=values, num=num,
+    )
+    arch_b_ref = focal_sweep(
+        test_pwr=arch_a_pwr, ref_pwr=arch_b_pwr,
+        test_area=arch_a_area, ref_area=arch_b_area,
+        alpha_ref=0.5, sweep="alpha_ref", values=values, num=num,
+    )
+
+    result = FocalBothRefs(arch_a_ref=arch_a_ref, arch_b_ref=arch_b_ref)
+    if plot_path is not None:
+        _plot_both_refs(result, plot_path)
+    return result
+
+
+def _warn_ref_sweep(sweep: str) -> None:
+    """Loudly warn that sweeping a reference value at constant alpha_ref is dicey.
+
+    Fires when ``focal_sweep`` is asked to vary ``ref_pwr`` or ``ref_area``:
+    holding ``alpha_ref`` fixed across such a sweep is internally inconsistent,
+    because the embodied-to-operational weight that actually applies to the
+    reference design depends on its own power and area.
+    """
+    message = (
+        "sweeping reference values with a constant alpha_ref yields difficult "
+        "to understand results, since the true value of alpha_ref is a function "
+        "of the ref_pwr and ref_area"
+    )
+    width = 76
+    bar = "!" * width
+    lines = ["", bar, "!!" + "  FOCAL WARNING  ".center(width - 4) + "!!", bar]
+    for line in textwrap.wrap(f"You are sweeping {sweep!r}: {message}.", width - 6):
+        lines.append("!! " + line.ljust(width - 6) + " !!")
+    lines += [bar, ""]
+    print("\n".join(lines), file=sys.stderr)
+    warnings.warn(message, stacklevel=3)
+
+
+def _linspace(lo: float, hi: float, num: int) -> list[float]:
+    """Evenly spaced values from lo to hi inclusive (pure-Python linspace)."""
+    if num < 1:
+        return []
+    if num == 1:
+        return [lo]
+    step = (hi - lo) / (num - 1)
+    return [lo + step * i for i in range(num)]
+
+
+def _level_crossings(xs: list[float], ys: list[float], level: float = 1.0) -> list[float]:
+    """Find x where the piecewise-linear (xs, ys) curve crosses ``level``.
+
+    Returns the x of every exact hit and every sign-change crossing (located by
+    linear interpolation between the bracketing samples).
+    """
+    crossings: list[float] = []
+    for i in range(len(xs) - 1):
+        a = ys[i] - level
+        b = ys[i + 1] - level
+        if a == 0.0:
+            crossings.append(xs[i])
+        elif (a < 0.0 < b) or (b < 0.0 < a):
+            t = a / (a - b)
+            crossings.append(xs[i] + t * (xs[i + 1] - xs[i]))
+    if ys and ys[-1] - level == 0.0:
+        crossings.append(xs[-1])
+    return crossings
+
+
+def _plot_sweep(result: FocalSweep, plot_path: str | Path) -> None:
+    """Save a PNG of NCF vs the swept parameter (matplotlib imported lazily)."""
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots(figsize=(7, 5))
+    ax.plot(result.values, result.ncf, color="#2b6cb0", marker="o",
+            markersize=3, linewidth=1.5, label="NCF(test, ref)")
+    ax.axhline(1.0, color="grey", linestyle="--", linewidth=1.0,
+               label="carbon-equal (NCF = 1)")
+
+    ymin, ymax = ax.get_ylim()
+    ax.axhspan(ymin, 1.0, color="#c6f6d5", alpha=0.3, zorder=0,
+               label="test more sustainable")
+    ax.set_ylim(ymin, ymax)
+
+    for i, be in enumerate(result.breakevens):
+        ax.axvline(be, color="#e53e3e", linestyle=":", linewidth=1.0,
+                   label="break-even" if i == 0 else None)
+
+    ax.set_xlabel(_PARAM_LABELS.get(result.parameter, result.parameter))
+    ax.set_ylabel("normalized carbon footprint (NCF)")
+    ax.set_title(f"FOCAL sweep over {result.parameter}")
+    ax.grid(alpha=0.3)
+    ax.legend(loc="best", fontsize=8)
+    fig.tight_layout()
+
+    out = Path(plot_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out, dpi=150)
+    plt.close(fig)
+    print(f"  FOCAL sweep plot -> {out}")
+
+
+def _plot_both_refs(result: FocalBothRefs, plot_path: str | Path) -> None:
+    """Overlay the two reference-choice NCF curves vs alpha (lazy matplotlib)."""
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots(figsize=(7, 5))
+    ax.plot(result.arch_a_ref.values, result.arch_a_ref.ncf, color="#2b6cb0",
+            marker="o", markersize=3, linewidth=1.5,
+            label="A as ref  (NCF of B vs A)")
+    ax.plot(result.arch_b_ref.values, result.arch_b_ref.ncf, color="#dd6b20",
+            marker="s", markersize=3, linewidth=1.5,
+            label="B as ref  (NCF of A vs B)")
+    ax.axhline(1.0, color="grey", linestyle="--", linewidth=1.0,
+               label="carbon-equal (NCF = 1)")
+
+    ax.set_xlabel(_PARAM_LABELS["alpha_ref"])
+    ax.set_ylabel("normalized carbon footprint (NCF)")
+    ax.set_title("FOCAL: same alpha, each architecture as reference")
+    ax.grid(alpha=0.3)
+    ax.legend(loc="best", fontsize=8)
+    fig.tight_layout()
+
+    out = Path(plot_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    fig.savefig(out, dpi=150)
+    plt.close(fig)
+    print(f"  FOCAL both-refs plot -> {out}")

chia/analysis/sustainability/pfas.py

@@ -0,0 +1,127 @@
+"""PFAS-in-semiconductor-manufacturing mask data for chip PFAS/carbon modeling.
+
+All data in this module is derived from the following work, and full credit
+for the underlying analysis belongs to its authors:
+
+    Mariam Elgamal, Abdulrahman Mahmoud, Gu-Yeon Wei, David Brooks, and
+    Gage Hills. "Modeling PFAS in Semiconductor Manufacturing to Quantify
+    Trade-offs in Energy Efficiency and Environmental Impact of Computing
+    Systems." arXiv preprint arXiv:2505.06727 (2025).
+
+    Abstract: https://arxiv.org/abs/2505.06727
+    PDF:      https://arxiv.org/pdf/2505.06727
+
+Any use of this node should cite this work.
+
+The paper uses the number of lithography masks as a first-order proxy for the
+amount of PFAS ("forever chemicals") used in chip manufacturing, because the
+PFAS-containing layers (photoresist, anti-reflective coatings, topcoats) scale
+with mask count -- eq. (1): #PFAS_litho ~ number of lithography masks.
+
+Data provenance within the paper:
+  * BEOL_METAL_STACK_TYPES -- lithography masks per BEOL metal-stack recipe.
+    Mask counts follow Table II ("Number of lithography process steps and masks
+    per metal line process"); the recipe names are the BEOL stack types in the
+    Figure 5 legend, read top-to-bottom.
+  * BEOL_PROCESSES_PER_NODE -- per-node BEOL metal-stack composition, decoded
+    from the stacked bars of Figure 5.
+  * PROCESSES_PER_NODE -- the full per-node stack: FEOL and MOL layers (counts
+    from Figure 5) prepended to the BEOL layers above.
+
+Any transcription errors here are ours, not the authors'.
+
+The PFAS proxy (lithography masks * area/yield) is only meaningful when considered relative
+to other instances.
+"""
+
+# BEOL metal-stack type -> total lithography masks (metal-layer process + via-
+# layer process), read top-to-bottom from the Figure 5 legend (arXiv:2505.06727).
+# Keys match the recipe strings used in BEOL_PROCESSES_PER_NODE, so a node's BEOL
+# mask count is sum(BEOL_METAL_STACK_TYPES[r] for r in BEOL_PROCESSES_PER_NODE[node]).
+BEOL_METAL_STACK_TYPES: dict[str, int] = {
+    "M: ArF, V: ArF": 2,
+    "M: ArFi, V: ArFi": 2,
+    "M: ArFi LE, V: ArFi LE": 3,
+    "M: ArFi SADP + ArFi LE block, V: ArFi LE-2": 4,
+    "M: ArFi SADP + ArFi SAB, V: ArFi LE-4": 7,
+    "M: ArFi SAQP + ArFi SAB, V: ArFi LE-4": 7,
+    "M: EUV LE, V: EUV LE": 2,
+    "M: ArFi SAQP + EUV LE block, V: EUV LE": 3,
+    "M: ArFi SAQP + EUV LE block, V: EUV LE-2": 4,
+    "M: ArFi SAQP + EUV LE-2, V: EUV LE-2": 5,
+    "M: EUV LE-2 + EUV SAB, V: EUV LE-2": 6,
+    "M: i-line, V: ArF": 2,
+}
+
+# Per-node BEOL metal stack from Figure 5 of arXiv:2505.06727
+# Order is bottom (finest) -> top (coarsest). 
+BEOL_PROCESSES_PER_NODE: dict[str, list[str]] = {
+    "130nm": ["M: ArF, V: ArF"]*5 + ["M: i-line, V: ArF"],
+    "90nm":  ["M: ArF, V: ArF"]*5 + ["M: i-line, V: ArF"],
+    "65nm":  ["M: ArF, V: ArF"]*8 + ["M: i-line, V: ArF"],
+    "40nm":  ["M: ArFi, V: ArFi"]*5 + ["M: ArF, V: ArF"]*4 + ["M: i-line, V: ArF"],
+    "28nm":  ["M: ArFi, V: ArFi"]*7 + ["M: ArF, V: ArF"]*2 + ["M: i-line, V: ArF"],
+    "20nm":  ["M: ArFi LE, V: ArFi LE"]*3 + ["M: ArFi, V: ArFi"]*4 + ["M: ArF, V: ArF"]*2 + ["M: i-line, V: ArF"],
+    "16nm":  ["M: ArFi LE, V: ArFi LE"]*3 + ["M: ArFi, V: ArFi"]*4 + ["M: ArF, V: ArF"]*2 + ["M: i-line, V: ArF"],
+    "10nm":  ["M: ArFi SADP + ArFi LE block, V: ArFi LE-2"]*3 + ["M: ArFi LE, V: ArFi LE"]*4 + ["M: ArFi, V: ArFi"]*3 + ["M: i-line, V: ArF"],
+    "7nm":   ["M: ArFi SADP + ArFi SAB, V: ArFi LE-4"]*1 + ["M: ArFi SAQP + ArFi SAB, V: ArFi LE-4"]*2 + ["M: ArFi SADP + ArFi LE block, V: ArFi LE-2"]*4 + ["M: ArFi, V: ArFi"]*7 + ["M: i-line, V: ArF"],
+    "7nm+":  ["M: EUV LE, V: EUV LE"]*3 + ["M: ArFi SADP + ArFi LE block, V: ArFi LE-2"]*4 + ["M: ArFi, V: ArFi"]*7 + ["M: i-line, V: ArF"],
+    "5nm":   ["M: ArFi SAQP + EUV LE-2, V: EUV LE-2"]*1 + ["M: ArFi SAQP + EUV LE block, V: EUV LE-2"]*2 + ["M: ArFi SAQP + EUV LE block, V: EUV LE"]*2 + ["M: ArFi SADP + ArFi LE block, V: ArFi LE-2"]*2 + ["M: ArFi, V: ArFi"]*9 + ["M: i-line, V: ArF"],
+    "3nm":   ["M: EUV LE-2 + EUV SAB, V: EUV LE-2"]*2 + ["M: ArFi SAQP + EUV LE-2, V: EUV LE-2"]*2 + ["M: ArFi SAQP + EUV LE block, V: EUV LE"]*2 + ["M: ArFi SADP + ArFi LE block, V: ArFi LE-2"]*2 + ["M: ArFi, V: ArFi"]*11 + ["M: i-line, V: ArF"],
+}
+
+# FEOL and MOL lithography-layer counts per node (each is one PFAS mask layer),
+# from arXiv:2505.06727 (the FEOL/MOL portions of the Figure 5 stacked bars).
+_FEOL_LAYERS_PER_NODE: dict[str, int] = {
+    n: (8 if n == "130nm" else 10) for n in BEOL_PROCESSES_PER_NODE
+}
+_MOL_LAYERS_PER_NODE: dict[str, int] = {
+    n: (1 if n in ("130nm", "90nm", "65nm", "40nm", "28nm", "20nm") else 2)
+    for n in BEOL_PROCESSES_PER_NODE
+}
+
+# Full per-node lithography stack, bottom -> top: FEOL, then MOL, then the BEOL
+# metal layers. Each "FEOL"/"MOL" entry is one mask layer; the BEOL entries are
+# metal-stack recipes priced by BEOL_METAL_STACK_TYPES. A node's total PFAS mask
+# layers is (# "FEOL") + (# "MOL") + sum(BEOL_METAL_STACK_TYPES[r] for the BEOL
+# entries r).
+PROCESSES_PER_NODE: dict[str, list[str]] = {
+    n: ["FEOL"] * _FEOL_LAYERS_PER_NODE[n]
+    + ["MOL"] * _MOL_LAYERS_PER_NODE[n]
+    + beol
+    for n, beol in BEOL_PROCESSES_PER_NODE.items()
+}
+
+
+def num_lith_masks(node: str) -> int:
+    """Number of PFAS-containing lithography masks for ``node``.
+
+    Sums the full per-node stack in PROCESSES_PER_NODE: each FEOL and MOL layer
+    counts as one mask, and each BEOL metal-stack recipe is priced by
+    BEOL_METAL_STACK_TYPES (paper eq. 1: #PFAS_litho ~ number of masks).
+    """
+    if node not in PROCESSES_PER_NODE:
+        raise KeyError(f"unknown node {node!r}; known nodes: {list(PROCESSES_PER_NODE)}")
+    return sum(
+        1 if layer in ("FEOL", "MOL") else BEOL_METAL_STACK_TYPES[layer]
+        for layer in PROCESSES_PER_NODE[node]
+    )
+
+
+def get_PFAS_proxy(node: str, area: float, yield_: float) -> float:
+    """PFAS manufacturing proxy for ``node`` (paper eq. 2)::
+
+        PFAS_chip_manufacturing = #PFAS_litho * Area / Yield
+
+    where #PFAS_litho is ``num_lith_masks(node)``. ``area`` is die area (in
+    whatever unit you use consistently) and ``yield_`` is the manufacturing
+    yield in (0, 1]. (``yield`` is a Python keyword, hence the trailing
+    underscore.) 
+    
+    Like the mask proxy itself, the result is only meaningful
+    relative to other instances computed the same way. This is
+    not an absolute quantity of PFAS.
+    """
+    if not 0.0 < yield_ <= 1.0:
+        raise ValueError(f"yield_ must be in (0, 1], got {yield_}")
+    return num_lith_masks(node) * area / yield_