Improve the taxonomy of the methods

.cache/known_methods_snapshot.json

@@ -3,7 +3,10 @@
     "teki": {
       "abbreviation": "TEKI",
       "Method": "Tikhonov Regularized Ensemble Kalman Inversion",
-      "family": "Kalman",
+      "parallelism": "parallel-interacting",
+      "update_type": "kalman",
+      "method_goal": "optimization",
+      "emulator_use": "none",
       "aliases": [
         "teki"
       ]
@@ -11,7 +14,10 @@
     "etki": {
       "abbreviation": "ETKI",
       "Method": "Ensemble Transform Kalman Inversion",
-      "family": "Kalman",
+      "parallelism": "parallel-interacting",
+      "update_type": "kalman",
+      "method_goal": "optimization",
+      "emulator_use": "none",
       "aliases": [
         "etki"
       ]
@@ -19,7 +25,10 @@
     "iekf": {
       "abbreviation": "IEKF",
       "Method": "Iterative Ensemble Kalman Filter",
-      "family": "Kalman",
+      "parallelism": "parallel-interacting",
+      "update_type": "kalman",
+      "method_goal": "uq",
+      "emulator_use": "none",
       "aliases": [
         "iekf",
         "gnsl",
@@ -29,7 +38,10 @@
     "uki": {
       "abbreviation": "UKI",
       "Method": "Unscented Kalman Inversion",
-      "family": "Kalman",
+      "parallelism": "parallel-interacting",
+      "update_type": "kalman",
+      "method_goal": "optimization",
+      "emulator_use": "none",
       "aliases": [
         "uki"
       ]
@@ -37,7 +49,10 @@
     "abc": {
       "abbreviation": "ABC",
       "Method": "Approximate Bayesian Calibration",
-      "family": "Bayesian",
+      "parallelism": "parallel-independent",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "none",
       "aliases": [
         "abc"
       ]
@@ -45,7 +60,10 @@
     "hm": {
       "abbreviation": "HM",
       "Method": "History Matching",
-      "family": "Bayesian",
+      "parallelism": "parallel-independent",
+      "update_type": "general",
+      "method_goal": "uq",
+      "emulator_use": "within-optimize",
       "aliases": [
         "hm"
       ]
@@ -53,7 +71,10 @@
     "ces-eki-dmc": {
       "abbreviation": "CES-EKI-DMC",
       "Method": "Calibrate Emulate Sample (EKI-DataMisfitController)",
-      "family": "calibrate_then_emulate",
+      "parallelism": "parallel-interacting",
+      "update_type": "kalman",
+      "method_goal": "uq",
+      "emulator_use": "after-optimize",
       "aliases": [
         "ces-eki-dmc"
       ]
@@ -61,7 +82,10 @@
     "adam": {
       "abbreviation": "ADAM",
       "Method": "Adaptive Moment Estimation",
-      "family": "gradient",
+      "parallelism": "serial",
+      "update_type": "gradient",
+      "method_goal": "optimization",
+      "emulator_use": "none",
       "aliases": [
         "adam"
       ]
@@ -69,7 +93,10 @@
     "lm": {
       "abbreviation": "LM",
       "Method": "Levenberg-Marquardt",
-      "family": "gradient",
+      "parallelism": "serial",
+      "update_type": "gradient",
+      "method_goal": "optimization",
+      "emulator_use": "none",
       "aliases": [
         "lm",
         "levenberg_marquardt",

.claude/skills/leaderboard-manager/SKILL.md

@@ -75,7 +75,7 @@ NetCDF file
   └─ algorithm_type dim (raw string, e.g. "gnki", "teki")
        └─ normalize_method_name()  → lowercase alias
             └─ canonicalize_method_name()  → canonical key (e.g. "iekf", "teki")
-                 └─ KNOWN_METHODS[canonical]  → { abbreviation, Method, family, aliases }
+                 └─ KNOWN_METHODS[canonical]  → { abbreviation, Method, parallelism, update_type, method_goal, emulator_use, aliases }
                       └─ method_meta[abbreviation]  → { citation, url, summary }
 ```
 
@@ -114,7 +114,7 @@ These traps apply to every task. Read them before touching any file.
 
 **1. Method metadata is split across three files.**
 Adding or editing a method requires changes in all three:
-- `src/common/method_registry.py` — canonical key, abbreviation, family, aliases
+- `src/common/method_registry.py` — canonical key, abbreviation, taxonomy tags (parallelism, update_type, method_goal, emulator_use), aliases
 - `src/pages/MethodDetails.py` — citation, URL, summary (in `method_meta` dict, keyed by abbreviation)
 - `src/data_store.py` — `DATASET_FILES` (optimization) or `UQ_BUDGET_FILES` (UQ) data path registration
 

.claude/skills/leaderboard-manager/references/add-method.md

@@ -42,10 +42,13 @@ at line 7). Follow the existing pattern exactly:
 
 ```python
 "new-key": {
-    "abbreviation": "NEWABBR",          # Short uppercase display name
-    "Method": "Full Method Name",       # Human-readable name for tables
-    "family": "Kalman",                 # One of: Kalman | Bayesian | calibrate_then_emulate
-    "aliases": ["new-key", "alias2"],   # All raw strings that may appear in NetCDF algorithm_type
+    "abbreviation": "NEWABBR",           # Short uppercase display name
+    "Method": "Full Method Name",        # Human-readable name for tables
+    "parallelism": "parallel-interacting",  # serial | parallel-independent | parallel-interacting
+    "update_type": "kalman",             # gradient | kalman | general
+    "method_goal": "optimization",       # optimization | uq
+    "emulator_use": "none",              # none | within-optimize | after-optimize
+    "aliases": ["new-key", "alias2"],    # All raw strings that may appear in NetCDF algorithm_type
 },
 ```
 

.claude/skills/leaderboard-manager/references/assess.md

@@ -37,7 +37,8 @@ Read these in a single parallel batch before starting the checklist:
 - [ ] **`.cache/known_methods_snapshot.json` → `unmapped_observed_methods` not empty** —
   means a NetCDF carries an `algorithm_type` string that has no entry in `KNOWN_METHODS`
   (or its aliases list). Those rows silently fall through with a raw uppercase fallback
-  abbreviation and `family = "Kalman"` default.
+  abbreviation and `"unmapped"` for all four taxonomy tags (parallelism, update_type,
+  method_goal, emulator_use).
 - [ ] **`DATASET_FILES` references a file path that doesn't exist on disk** — `_load_store`
   emits a `warnings.warn` and skips it silently; run
   `python -c "from src.data_store import load_metric_store; load_metric_store()"` and

.claude/skills/leaderboard-manager/references/manage-display.md

@@ -64,7 +64,8 @@ Search for `table_column_order = [` in `src/common/leaderboard.py` — there is
 list (not one-per-view):
 ```python
 table_column_order = [
-    "Placement", "abbreviation", "Method", "family", "Score",
+    "Placement", "abbreviation", "Method",
+    "update_type", "parallelism", "method_goal", "emulator_use", "Score",
     "Mean Forward Model Runs", "Minimum Forward Model Runs",
     "Mean Failure Rate (%)", "Optimal Ensemble Size", "Ensemble Sizes Used",
 ]
@@ -239,8 +240,8 @@ table:
 
 To **add or modify a UQ chart**, edit the `if budget_store is not None` block. The
 `budget_store` DataFrame has columns: `benchmark`, `algorithm_type`, `abbreviation`,
-`family`, `uq_target`, `ensemble_size`, `mean_budget`, `mean_iters`, `failure_count`,
-`failure_rate`, `n_seeds`.
+`parallelism`, `update_type`, `method_goal`, `emulator_use`, `uq_target`, `ensemble_size`,
+`mean_budget`, `mean_iters`, `failure_count`, `failure_rate`, `n_seeds`.
 
 **Bar chart integer x-axis:** Use `ensemble_size:O` (ordinal) with an explicit sort list
 and `axis=alt.Axis(labelAngle=0)` to suppress diagonal labels:

.claude/skills/leaderboard-manager/references/populate-metadata.md

@@ -38,7 +38,7 @@ Method information lives in **two separate places** that serve different purpose
 
 | File | Key used | What it stores |
 |---|---|---|
-| `src/common/method_registry.py` | canonical key (e.g. `"uki"`) | Abbreviation, full method name, family, aliases — used for **data processing and identity** |
+| `src/common/method_registry.py` | canonical key (e.g. `"uki"`) | Abbreviation, full method name, taxonomy tags (parallelism, update_type, method_goal, emulator_use), aliases — used for **data processing and identity** |
 | `src/pages/MethodDetails.py` `method_meta` dict | abbreviation (e.g. `"UKI"`) | Citation, URL, summary — used for **display copy only** |
 
 Both must be kept in sync. When you edit one, check the other. The most common mistake is
@@ -95,7 +95,7 @@ variant is used here).
 
 ## Editing method identity / naming
 
-If you need to correct the full method name, family classification, or abbreviation (the
+If you need to correct the full method name, taxonomy tags, or abbreviation (the
 short label that appears in table columns), edit `KNOWN_METHODS` in
 `src/common/method_registry.py`:
 
@@ -103,7 +103,10 @@ short label that appears in table columns), edit `KNOWN_METHODS` in
 "uki": {
     "abbreviation": "UKI",           # Short label in table columns
     "Method": "Unscented Kalman Inversion",  # Full name in Method column
-    "family": "Kalman",              # Kalman | Bayesian | calibrate_then_emulate
+    "parallelism": "parallel-interacting",   # serial | parallel-independent | parallel-interacting
+    "update_type": "kalman",                 # gradient | kalman | general
+    "method_goal": "optimization",            # optimization | uq
+    "emulator_use": "none",                   # none | within-optimize | after-optimize
     "aliases": ["uki"],              # Raw algorithm_type strings from NetCDF
 },
 ```
@@ -111,8 +114,9 @@ short label that appears in table columns), edit `KNOWN_METHODS` in
 **If you change `abbreviation`**: also update the corresponding key in `method_meta` in
 `MethodDetails.py` (the keys must match). The app looks up `method_meta[abbreviation]`.
 
-**If you change `family`**: the "Family" column in the leaderboard table updates
-automatically — no other change needed.
+**If you change any taxonomy tag**: the corresponding column in the leaderboard table
+updates automatically — no other change needed. Changing `update_type` also shifts that
+method's group in the sort order (see `_UPDATE_TYPE_ORDER` in `manage-display.md`).
 
 **If you add an alias**: new alias strings start matching immediately after reload. Use
 this when a collaborator's NetCDF uses a variant spelling not currently in the alias list.

CLAUDE.md

@@ -96,7 +96,7 @@ calibration_benchmark/
 | `algorithm_type` | Canonical method key (e.g. `teki`) |
 | `algorithm_alias` | Normalized raw name from NetCDF |
 | `abbreviation` | Display name (e.g. `TEKI`) |
-| `family` | `Kalman` · `Bayesian` · `calibrate_then_emulate` · `gradient` |
+| `parallelism` / `update_type` / `method_goal` / `emulator_use` | Taxonomy tags — see **Method taxonomy** below |
 | `rmse_target` | Target RMSE level |
 | `ensemble_size` | Ensemble / particle count |
 | `metric` | Mean forward-model runs over `random_seed` (lower = better; −1 = failed) |
@@ -116,7 +116,7 @@ rate = % of seeds that never satisfied the coverage condition (NaN metric, not
 |---|---|
 | `benchmark` | `L63`, `L96`, `L96_NN_FORCING`, `L96_SPATIAL_FORCING` |
 | `algorithm_type` | Canonical method key |
-| `abbreviation` / `Method` / `family` | From method registry |
+| `abbreviation` / `Method` / `parallelism` / `update_type` / `method_goal` / `emulator_use` | From method registry |
 | `uq_target` | Target-scaling level c |
 | `ensemble_size` | Ensemble size N |
 | `mean_budget` | Mean N·k_iter over converged seeds (NaN if all failed) |
@@ -149,25 +149,55 @@ Physical dimensions of each benchmark exported from `src/data_store.py` as
 Passed as `benchmark_dims=BENCHMARK_DIMS` to `render_leaderboard()` for column-header
 annotations in the suitability table. Update if a new benchmark is added.
 
+## Method taxonomy
+
+Four independent tags on every `KNOWN_METHODS` entry, each scoped to its own axis:
+
+- **`parallelism`** — how the search explores parameter space:
+  `serial` (single point estimate advanced step by step, e.g. `ADAM`/`LM`) ·
+  `parallel-independent` (population updated with no coupling between members,
+  e.g. `ABC`'s accepted samples / `HM`'s per-wave resampling) ·
+  `parallel-interacting` (ensemble members coupled through a shared update each
+  iteration — any Kalman-based method).
+- **`update_type`** — the mechanism driving each update step:
+  `gradient` (follows the loss gradient or a Gauss-Newton approximation) ·
+  `kalman` (a possibly linearized/unscented Kalman-style ensemble update) ·
+  `general` (anything else, e.g. `ABC`'s rejection sampling, `HM`'s implausibility cuts).
+- **`method_goal`** — what the method is built to report:
+  `optimization` (single best-fit parameter estimate) or `uq` (full posterior /
+  parameter uncertainty). UQ methods *can* still be scored on the Optimization
+  leaderboard — they're just usually less competitive there.
+- **`emulator_use`** — when/whether a surrogate model of the forward model is used:
+  `none` (samples/evaluates the true forward model throughout) ·
+  `within-optimize` (refits a surrogate at each search iteration, e.g. `HM` waves) ·
+  `after-optimize` (fits a surrogate once, after calibration finishes, e.g. `CES-EKI-DMC`).
+
+`update_type` deliberately avoids a "Bayesian" label — Kalman methods are approximate
+Bayesian updates too, so the split is about mechanism (gradient vs. Kalman vs. general),
+not philosophy. `_UPDATE_TYPE_ORDER` in `src/common/leaderboard.py` controls
+table/suitability sort order and must stay in sync with `update_type` values.
+A quick taxonomy tree is rendered on the home page (`src/streamlit_app.py`).
+
 ## Method registry  (`src/common/method_registry.py`)
 
-| Canonical | Abbreviation | Family | Aliases |
-|---|---|---|---|
-| `teki` | TEKI | Kalman | — |
-| `etki` | ETKI | Kalman | — |
-| `iekf` | IEKF | Kalman | gnsl, gnki |
-| `uki` | UKI | Kalman | — |
-| `abc` | ABC | Bayesian | — |
-| `hm` | HM | Bayesian | — |
-| `ces-eki-dmc` | CES-EKI-DMC | calibrate_then_emulate | — |
-| `adam` | ADAM | gradient | — |
-| `lm` | LM | gradient | gradient_descent |
+| Canonical | Abbreviation | parallelism | update_type | method_goal | emulator_use | Aliases |
+|---|---|---|---|---|---|---|
+| `teki` | TEKI | parallel-interacting | kalman | optimization | none | — |
+| `etki` | ETKI | parallel-interacting | kalman | optimization | none | — |
+| `iekf` | IEKF | parallel-interacting | kalman | uq | none | gnsl, gnki |
+| `uki` | UKI | parallel-interacting | kalman | optimization | none | — |
+| `abc` | ABC | parallel-independent | general | uq | none | — |
+| `hm` | HM | parallel-independent | general | uq | within-optimize | — |
+| `ces-eki-dmc` | CES-EKI-DMC | parallel-interacting | kalman | uq | after-optimize | — |
+| `adam` | ADAM | serial | gradient | optimization | none | — |
+| `lm` | LM | serial | gradient | optimization | none | gradient_descent |
 
 ## How to extend
 
 ### Add a method
 1. Add entry to `KNOWN_METHODS` in `src/common/method_registry.py`
-   (keys: `abbreviation`, `Method`, `family`, `aliases`).
+   (keys: `abbreviation`, `Method`, `parallelism`, `update_type`, `method_goal`,
+   `emulator_use`, `aliases` — see **Method taxonomy** above for valid tag values).
 2. Add detail-page metadata to the inline `method_meta` dict in `src/pages/MethodDetails.py`
    keyed by **abbreviation** (e.g. `"TEKI"`). ⚠️ Metadata is split across both files.
 3. Place result NetCDF(s) in `data/` and add paths to `DATASET_FILES` in `src/data_store.py`.

src/common/leaderboard.py

@@ -49,13 +49,13 @@ def _method_color(present_abbrevs: list[str]) -> alt.Color:
         legend=alt.Legend(values=sorted(present_abbrevs)),
     )
 
-# Family display order in the leaderboard table (lower = earlier).
-# Unknown families fall back to 99 and appear at the end.
-_FAMILY_ORDER: dict[str, int] = {
-    "Kalman": 0,
-    "Bayesian": 1,
-    "gradient": 2,
-    "calibrate_then_emulate": 3,
+# update_type display order in the leaderboard table (lower = earlier).
+# Unknown/unmapped update types fall back to 99 and appear at the end.
+# See method_registry.py for the full four-axis taxonomy.
+_UPDATE_TYPE_ORDER: dict[str, int] = {
+    "kalman": 0,
+    "gradient": 1,
+    "general": 2,
 }
 
 
@@ -72,15 +72,15 @@ def _render_suitability_table(
         store["benchmark"].unique().tolist(),
         key=lambda bm: benchmark_dims[bm][0] if (benchmark_dims and bm in benchmark_dims) else bm,
     )
-    _abbr_family = (
-        store[["abbreviation", "family"]].dropna()
+    _abbr_update_type = (
+        store[["abbreviation", "update_type"]].dropna()
         .drop_duplicates("abbreviation")
-        .set_index("abbreviation")["family"]
+        .set_index("abbreviation")["update_type"]
         .to_dict()
     )
     methods = sorted(
         store["abbreviation"].dropna().unique().tolist(),
-        key=lambda a: (_FAMILY_ORDER.get(_abbr_family.get(a, ""), 99), a),
+        key=lambda a: (_UPDATE_TYPE_ORDER.get(_abbr_update_type.get(a, ""), 99), a),
     )
 
     target_str     = str(float(suitability_target))
@@ -178,8 +178,9 @@ def render_leaderboard(
     metric_store:
         DataFrame produced by ``load_metric_store()`` or ``load_uq_store()``.
         Must contain at least the columns ``benchmark``, ``algorithm_type``,
-        ``abbreviation``, ``Method``, ``family``, ``ensemble_size``, ``metric``,
-        ``failure_rate``, and *target_col*.
+        ``abbreviation``, ``Method``, the four taxonomy tag columns
+        (``parallelism``, ``update_type``, ``method_goal``, ``emulator_use``),
+        ``ensemble_size``, ``metric``, ``failure_rate``, and *target_col*.
     target_col:
         Name of the target-coordinate column, e.g. ``"rmse_target"`` or
         ``"uq_target"``.
@@ -292,7 +293,7 @@ def render_leaderboard(
 
         # Failure rate from every row (NaN metric rows carry failure_rate=100)
         failure_agg = ranking_source.groupby(
-            ["algorithm_type", "abbreviation", "Method", "family"], as_index=False
+            ["algorithm_type", "abbreviation", "Method"], as_index=False
         ).agg(**{"Mean Failure Rate (%)": ("failure_rate", "mean")})
 
         # Metric stats only from runs that reached the target (non-NaN metric)
@@ -301,7 +302,7 @@ def render_leaderboard(
             return pd.DataFrame()
 
         scored_df = valid_rows.groupby(
-            ["algorithm_type", "abbreviation", "Method", "family"], as_index=False
+            ["algorithm_type", "abbreviation", "Method"], as_index=False
         ).agg(
             **{"Mean Forward Model Runs": ("metric", "mean")},
             **{"Minimum Forward Model Runs": ("metric", "min")},
@@ -310,13 +311,12 @@ def render_leaderboard(
 
         best_per_target = (
             valid_rows.sort_values(["algorithm_type", target_str_col, "metric", "ensemble_size"])
-            .groupby(["algorithm_type", "abbreviation", "Method", "family", target_str_col], as_index=False)
+            .groupby(["algorithm_type", "abbreviation", "Method", target_str_col], as_index=False)
             .first()[
                 [
                     "algorithm_type",
                     "abbreviation",
                     "Method",
-                    "family",
                     target_str_col,
                     "ensemble_size",
                 ]
@@ -324,17 +324,17 @@ def render_leaderboard(
         )
 
         optimal_ensemble = best_per_target.groupby(
-            ["algorithm_type", "abbreviation", "Method", "family"], as_index=False
+            ["algorithm_type", "abbreviation", "Method"], as_index=False
         ).agg(**{"Optimal Ensemble Size": ("ensemble_size", "mean")})
 
         scored_df = scored_df.merge(
             optimal_ensemble,
-            on=["algorithm_type", "abbreviation", "Method", "family"],
+            on=["algorithm_type", "abbreviation", "Method"],
             how="left",
         )
         scored_df = scored_df.merge(
             failure_agg,
-            on=["algorithm_type", "abbreviation", "Method", "family"],
+            on=["algorithm_type", "abbreviation", "Method"],
             how="left",
         )
 
@@ -421,17 +421,25 @@ def render_leaderboard(
 
     leaderboard_df = build_scored_table(filtered, add_rank=True)
 
-    # Re-sort by family group, then by performance within each group.
+    # Attach the four taxonomy tags (constant per abbreviation, so this is a
+    # plain lookup merge rather than a groupby key threaded through every
+    # aggregation above).
+    if not leaderboard_df.empty:
+        tag_cols = ["abbreviation", "parallelism", "update_type", "method_goal", "emulator_use"]
+        tag_lookup = filtered[tag_cols].drop_duplicates("abbreviation")
+        leaderboard_df = leaderboard_df.merge(tag_lookup, on="abbreviation", how="left")
+
+    # Re-sort by update_type group, then by performance within each group.
     # Placement numbers still reflect overall performance rank.
     if not leaderboard_df.empty:
         leaderboard_df = leaderboard_df.assign(
-            _family_sort=leaderboard_df["family"].map(_FAMILY_ORDER).fillna(99),
+            _update_type_sort=leaderboard_df["update_type"].map(_UPDATE_TYPE_ORDER).fillna(99),
             _is_dnf=leaderboard_df["Score"].isna(),
         ).sort_values(
-            ["_family_sort", "_is_dnf", "Score"],
+            ["_update_type_sort", "_is_dnf", "Score"],
             ascending=[True, True, False],
             na_position="last",
-        ).drop(columns=["_family_sort", "_is_dnf"]).reset_index(drop=True)
+        ).drop(columns=["_update_type_sort", "_is_dnf"]).reset_index(drop=True)
 
     if scoring_mode == "Mean Forward Model Runs":
         score_basis = "mean forward-model runs at the selected target level (lower is better)"
@@ -706,7 +714,10 @@ def render_leaderboard(
         "Placement",
         "abbreviation",
         "Method",
-        "family",
+        "update_type",
+        "parallelism",
+        "method_goal",
+        "emulator_use",
         "Score",
         "Mean Forward Model Runs",
         "Minimum Forward Model Runs",
@@ -730,7 +741,10 @@ def render_leaderboard(
             use_container_width=True,
             column_config={
                 "Placement": st.column_config.TextColumn("Placement"),
-                "family": st.column_config.TextColumn("Family"),
+                "update_type": st.column_config.TextColumn("Update Type"),
+                "parallelism": st.column_config.TextColumn("Parallelism"),
+                "method_goal": st.column_config.TextColumn("Method Goal"),
+                "emulator_use": st.column_config.TextColumn("Emulator Use"),
                 "Method": st.column_config.TextColumn("Method"),
                 "abbreviation": st.column_config.TextColumn("Abbrev."),
                 "Mean Forward Model Runs": st.column_config.NumberColumn("Mean Forward Model Runs", format="%.4f"),

src/common/method_registry.py

@@ -4,59 +4,116 @@ import json
 from pathlib import Path
 
 
+# Taxonomy
+# --------
+# Every method carries four independent tags, each scoped to its own axis:
+#
+# ``parallelism`` — how the search explores parameter space:
+#   "serial"               — a single point estimate advanced step by step (ADAM, LM).
+#   "parallel-independent" — a population of candidates updated with no coupling
+#                             between members (ABC's accepted samples, HM's per-wave
+#                             resampling from the non-implausible region).
+#   "parallel-interacting" — an ensemble whose members are coupled through a shared
+#                             update each iteration (any Kalman-based method).
+#
+# ``update_type`` — the mechanism driving each update step:
+#   "gradient" — follows the loss gradient or a Gauss-Newton approximation of it.
+#   "kalman"   — a (possibly linearized/unscented) Kalman-style ensemble update.
+#   "general"  — anything else (e.g. ABC's rejection sampling, HM's implausibility cuts).
+#
+# ``method_goal`` — what the method is built to report:
+#   "optimization" — a single best-fit parameter estimate.
+#   "uq"           — the full posterior / parameter uncertainty. UQ methods can still
+#                    be scored on the Optimization leaderboard (usually less
+#                    competitive there, since they're not optimizing for speed-to-target).
+#
+# ``emulator_use`` — when/whether a surrogate model of the forward model is used:
+#   "none"            — samples/evaluates the true forward model throughout.
+#   "within-optimize" — refits a surrogate at each iteration of the search (HM waves).
+#   "after-optimize"  — fits a surrogate once, after calibration finishes (CES).
+#
+# Note: Kalman methods are Bayesian in spirit too (approximate Gaussian posterior
+# updates) — ``update_type`` is about mechanism, not a "Bayesian vs not" philosophy.
 KNOWN_METHODS = {
     "teki": {
         "abbreviation": "TEKI",
         "Method": "Tikhonov Regularized Ensemble Kalman Inversion",
-        "family": "Kalman",
+        "parallelism": "parallel-interacting",
+        "update_type": "kalman",
+        "method_goal": "optimization",
+        "emulator_use": "none",
         "aliases": ["teki"],
     },
     "etki": {
         "abbreviation": "ETKI",
         "Method": "Ensemble Transform Kalman Inversion",
-        "family": "Kalman",
+        "parallelism": "parallel-interacting",
+        "update_type": "kalman",
+        "method_goal": "optimization",
+        "emulator_use": "none",
         "aliases": ["etki"],
     },
     "iekf": {
         "abbreviation": "IEKF",
         "Method": "Iterative Ensemble Kalman Filter",
-        "family": "Kalman",
+        "parallelism": "parallel-interacting",
+        "update_type": "kalman",
+        "method_goal": "uq",
+        "emulator_use": "none",
         "aliases": ["iekf", "gnsl", "gnki"],
     },
     "uki": {
         "abbreviation": "UKI",
         "Method": "Unscented Kalman Inversion",
-        "family": "Kalman",
+        "parallelism": "parallel-interacting",
+        "update_type": "kalman",
+        "method_goal": "optimization",
+        "emulator_use": "none",
         "aliases": ["uki"],
     },
     "abc": {
         "abbreviation": "ABC",
         "Method": "Approximate Bayesian Calibration",
-        "family": "Bayesian",
+        "parallelism": "parallel-independent",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "none",
         "aliases": ["abc"],
     },
     "hm": {
         "abbreviation": "HM",
         "Method": "History Matching",
-        "family": "Bayesian",
+        "parallelism": "parallel-independent",
+        "update_type": "general",
+        "method_goal": "uq",
+        "emulator_use": "within-optimize",
         "aliases": ["hm"],
     },
     "ces-eki-dmc": {
         "abbreviation": "CES-EKI-DMC",
         "Method": "Calibrate Emulate Sample (EKI-DataMisfitController)",
-        "family": "calibrate_then_emulate",
+        "parallelism": "parallel-interacting",
+        "update_type": "kalman",
+        "method_goal": "uq",
+        "emulator_use": "after-optimize",
         "aliases": ["ces-eki-dmc"]
     },
     "adam": {
         "abbreviation": "ADAM",
         "Method": "Adaptive Moment Estimation",
-        "family": "gradient",
+        "parallelism": "serial",
+        "update_type": "gradient",
+        "method_goal": "optimization",
+        "emulator_use": "none",
         "aliases": ["adam"],
     },
     "lm": {
         "abbreviation": "LM",
         "Method": "Levenberg-Marquardt",
-        "family": "gradient",
+        "parallelism": "serial",
+        "update_type": "gradient",
+        "method_goal": "optimization",
+        "emulator_use": "none",
         "aliases": ["lm", "levenberg_marquardt", "levenberg-marquardt", "gradient_descent"],
     },
 }

src/data_store.py

@@ -59,6 +59,10 @@ DATASET_FILES = {
 EXPECTED_DIMS_OPT = ("algorithm_type", "rmse_target", "ensemble_size", "random_seed")
 EXPECTED_DIMS_UQ  = ("random_seed", "ensemble_size", "k_iter", "coverage_quantile")
 
+# Method-taxonomy tag columns — one value per method, sourced from KNOWN_METHODS.
+# See src/common/method_registry.py for the axis definitions.
+TAXONOMY_TAG_COLUMNS = ["parallelism", "update_type", "method_goal", "emulator_use"]
+
 
 # ---------------------------------------------------------------------------
 # Uncertainty Quantification datasets
@@ -229,10 +233,11 @@ def _load_store(dataset_files: dict[str, list[str]], target_col: str, *, drop_na
     merged["ensemble_size"] = merged["ensemble_size"].astype(int)
     merged["abbreviation"] = merged["algorithm_type"].map(lambda method: get_method_meta(method).get("abbreviation"))
     merged["Method"] = merged["algorithm_type"].map(lambda method: get_method_meta(method).get("Method"))
-    merged["family"] = merged["algorithm_type"].map(lambda method: get_method_meta(method).get("family"))
+    for tag_col in TAXONOMY_TAG_COLUMNS:
+        merged[tag_col] = merged["algorithm_type"].map(lambda method: get_method_meta(method).get(tag_col))
+        merged[tag_col] = merged[tag_col].fillna("unmapped")
     merged["abbreviation"] = merged["abbreviation"].fillna(merged["algorithm_type"].str.upper())
     merged["Method"] = merged["Method"].fillna(merged["abbreviation"])
-    merged["family"] = merged["family"].fillna("Kalman")
 
     try:
         dump_method_registry_snapshot(project_root=project_root, observed_methods=set(merged["algorithm_type"].unique()))
@@ -267,7 +272,7 @@ def load_uq_store() -> pd.DataFrame:
         return pd.DataFrame(
             columns=[
                 "benchmark", "algorithm_type", "algorithm_alias", "abbreviation",
-                "Method", "family", "uq_target", "ensemble_size", "metric", "failure_rate",
+                "Method", *TAXONOMY_TAG_COLUMNS, "uq_target", "ensemble_size", "metric", "failure_rate",
             ]
         )
     df = budget_df.copy()
@@ -281,7 +286,7 @@ def load_uq_store() -> pd.DataFrame:
     return df[
         [
             "benchmark", "algorithm_type", "algorithm_alias", "abbreviation",
-            "Method", "family", "uq_target", "ensemble_size", "metric", "failure_rate",
+            "Method", *TAXONOMY_TAG_COLUMNS, "uq_target", "ensemble_size", "metric", "failure_rate",
         ]
     ]
 
@@ -295,8 +300,9 @@ def load_uq_budget_store() -> pd.DataFrame:
       UQ_COVERAGE_QUANTILES.  Budget = N · k_iter; NaN when target never reached.
 
     Returns a DataFrame with columns:
-        benchmark, algorithm_type, abbreviation, family, uq_target,
-        ensemble_size, mean_budget, mean_iters, failure_count, failure_rate, n_seeds
+        benchmark, algorithm_type, abbreviation, parallelism, update_type,
+        method_goal, emulator_use, uq_target, ensemble_size, mean_budget,
+        mean_iters, failure_count, failure_rate, n_seeds
     """
     xr = importlib.import_module("xarray")
 
@@ -383,7 +389,7 @@ def load_uq_budget_store() -> pd.DataFrame:
     if not records:
         return pd.DataFrame(
             columns=[
-                "benchmark", "algorithm_type", "abbreviation", "family",
+                "benchmark", "algorithm_type", "abbreviation", *TAXONOMY_TAG_COLUMNS,
                 "uq_target", "ensemble_size", "mean_budget", "mean_iters",
                 "failure_count", "failure_rate", "n_seeds",
             ]
@@ -395,6 +401,7 @@ def load_uq_budget_store() -> pd.DataFrame:
         return get_method_meta(canonicalize_method_name(normalize_method_name(m))).get(key, fallback)
 
     df["abbreviation"] = df["algorithm_type"].map(lambda m: _meta(m, "abbreviation", m.upper()))
-    df["family"] = df["algorithm_type"].map(lambda m: _meta(m, "family", "Kalman"))
+    for tag_col in TAXONOMY_TAG_COLUMNS:
+        df[tag_col] = df["algorithm_type"].map(lambda m, col=tag_col: _meta(m, col, "unmapped"))
     df["Method"] = df["algorithm_type"].map(lambda m: _meta(m, "Method", m.upper()))
     return df

src/pages/MethodDetails.py

@@ -33,7 +33,7 @@ if metric_store.empty:
     st.warning("No metric data found. Expected NetCDF files in `data/` with a `metric` variable.")
     st.stop()
 
-methods_df = metric_store[["family", "Method", "abbreviation"]].drop_duplicates().sort_values("abbreviation")
+methods_df = metric_store[["Method", "abbreviation"]].drop_duplicates().sort_values("abbreviation")
 
 abbrs = methods_df["abbreviation"].tolist()
 

src/pages/RawData.py

@@ -40,7 +40,10 @@ st.dataframe(
             "benchmark",
             "abbreviation",
             "Method",
-            "family",
+            "parallelism",
+            "update_type",
+            "method_goal",
+            "emulator_use",
             "algorithm_type",
             "algorithm_alias",
             "rmse_target",
@@ -54,7 +57,10 @@ st.dataframe(
         "benchmark": st.column_config.TextColumn("Benchmark"),
         "abbreviation": st.column_config.TextColumn("Abbrev."),
         "Method": st.column_config.TextColumn("Method"),
-        "family": st.column_config.TextColumn("Family"),
+        "parallelism": st.column_config.TextColumn("Parallelism"),
+        "update_type": st.column_config.TextColumn("Update Type"),
+        "method_goal": st.column_config.TextColumn("Method Goal"),
+        "emulator_use": st.column_config.TextColumn("Emulator Use"),
         "algorithm_type": st.column_config.TextColumn("Canonical Type"),
         "algorithm_alias": st.column_config.TextColumn("Source Alias"),
         "rmse_target": st.column_config.TextColumn("RMSE Target"),

src/streamlit_app.py

@@ -81,18 +81,48 @@ st.image(
     width=1200,
 )
 
-st.subheader("Method families")
+st.subheader("Method taxonomy")
 st.markdown(
-    "Methods are grouped into three families. See the **📘 Methods** page for "
-    "citations and per-method performance charts."
+    "Every method carries four independent tags — how it searches, what update "
+    "mechanism drives each step, what it's built to report, and whether/when it uses "
+    "a surrogate model. See the **📘 Methods** page for citations and per-method "
+    "performance charts."
+)
+st.markdown(
+    """
+- **Parallelism** — how the search explores parameter space
+    - **Serial** — `ADAM`, `LM` — a single point estimate advanced step by step.
+    - **Parallel-independent** — `ABC`, `HM` — a population of candidates updated
+      with no coupling between members (accepted samples / per-wave resampling).
+    - **Parallel-interacting** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `CES-EKI-DMC` — an
+      ensemble whose members are coupled through a shared update each iteration.
+- **Update type** — the mechanism driving each update step
+    - **Gradient** — `ADAM`, `LM` — follow the loss gradient (or a Gauss-Newton
+      approximation of it) directly.
+    - **Kalman** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `CES-EKI-DMC` — a (possibly
+      linearized or unscented) Kalman-style ensemble update.
+    - **General** — `ABC`, `HM` — neither gradient- nor Kalman-based (rejection
+      sampling, implausibility cuts).
+- **Method goal** — what the method is built to report
+    - **Optimization** — `TEKI`, `ETKI`, `UKI`, `ADAM`, `LM` — a single best-fit
+      parameter estimate.
+    - **UQ** — `IEKF`, `ABC`, `HM`, `CES-EKI-DMC` — the full posterior / parameter
+      uncertainty. Can still be scored on the Optimization leaderboard, but tends to
+      be less competitive there since it's not optimizing for speed-to-target.
+- **Emulator use** — when/whether a surrogate model of the forward model is used
+    - **None** — `TEKI`, `ETKI`, `IEKF`, `UKI`, `ADAM`, `LM`, `ABC` — samples/evaluates
+      the true forward model throughout.
+    - **Within-optimize** — `HM` — refits a surrogate at each iteration (wave) of the
+      search itself.
+    - **After-optimize** — `CES-EKI-DMC` — fits a surrogate (e.g. a GP) once, after
+      calibration finishes, and samples the posterior through it.
+"""
+)
+st.caption(
+    "Note: Kalman methods are Bayesian in spirit too (they're approximate Gaussian "
+    "posterior updates) — update type is about mechanism (gradient vs. Kalman vs. "
+    "general), not whether a method is 'Bayesian'."
 )
-families = {
-    "Kalman": "Ensemble Kalman variants (TEKI, ETKI, IEKF, UKI) — update an ensemble of parameter guesses via a linearized observation operator.",
-    "Bayesian": "Sampling-based approaches (ABC, HM) — explore parameter space without requiring gradient information.",
-    "Calibrate-then-emulate": "Two-stage pipelines (CES-EKI-DMC) — use an initial calibration phase to build a cheap emulator, then sample the posterior via MCMC.",
-}
-for family, desc in families.items():
-    st.markdown(f"- **{family}** — {desc}")
 
 st.subheader("Key metric")
 st.markdown(