ui: harden score card against deploy lag, polish styling, expose physics problems

Bug fix (TypeError on Streamlit Cloud)
- The new pre_polish_loss kwarg added to render_score_card last release
  raised TypeError on Cloud during the window between git push and
  Cloud's bytecode-cache refresh (the deployed _common.py was on the
  previous signature). To make the wire format resilient:
    * pre_polish_loss is now carried inside the score dict (just like
      every other field), so out-of-sync deployments never crash.
    * render_score_card grew a **_extra catch-all so future kwargs
      cannot break callers either.
    * format strings are guarded by isinstance(..., int | float) so a
      stray Tensor / None can no longer trip f"{x:.4g}".

UI polish
- Score card got softer radii, a radial-gradient highlight, a subtle
  drop shadow, tabular numerals for the loss line, and a dedicated
  green "polish improved by Δ" badge style (one rule for light, one
  for dark theme).
- New helper render_config_chips() draws a chip-style row of
  (problem, size, device, seed, plus optional hyper-params). The
  Solve page uses one chip row at the top (problem identity) and a
  second one right above the Run button (active hyper-params,
  including polish/warm-start state) so the user can verify the
  full configuration at a glance.
- Run button is now type=primary + width="stretch" so it stops
  competing with the Apply-preset button for visual weight.
- Sidebar references row gained a "Cite (Zenodo DOI)" link.

Physics catalog (PSpinGlass + RandomFieldIsing)
- Both problems are reachable from the Home Physics/spin family
  selector with appropriate auxiliary sliders (p-order for PSpin;
  dim, J, σ_h for RFIM).
- _solution_viz reuses render_sk for PSpin (no useful lattice) and
  render_ea for RFIM (same hyper-cubic geometry). Tests cover the
  catalog visibility (AppTest sweeps the family selector) and an
  end-to-end Solve flow on min_dominating_set / maxcut.

Made-with: Cursor

Author: Yuma-Ichikawa

app/_common.py

@@ -450,12 +450,16 @@ def apply_theme() -> None:
             box-shadow: 0 1px 2px rgba(15,23,42,0.04);
         }}
         .qqa-score {{
-            background: linear-gradient(135deg, rgba(15,118,110,0.06), rgba(30,58,138,0.06));
+            background:
+              radial-gradient(120% 150% at 0% 0%, rgba(56,189,248,0.10) 0%, transparent 60%),
+              linear-gradient(135deg, rgba(15,118,110,0.06), rgba(30,58,138,0.06));
             border: 1px solid var(--qqa-accent);
-            border-left: 4px solid var(--qqa-accent);
-            padding: 1rem 1.4rem;
-            border-radius: 8px;
+            border-left: 5px solid var(--qqa-accent);
+            padding: 1.1rem 1.4rem;
+            border-radius: 14px;
             margin: 0.6rem 0 1rem 0;
+            box-shadow: 0 6px 24px -12px rgba(56,189,248,0.32),
+                        0 1px 2px rgba(15,23,42,0.06);
         }}
         .qqa-score .label {{
             font-size: 0.72rem;
@@ -465,10 +469,11 @@ def apply_theme() -> None:
         }}
         .qqa-score .value {{
             font-family: 'Source Serif 4', Georgia, serif;
-            font-size: 2.2rem;
+            font-size: 2.4rem;
             font-weight: 700;
             color: var(--qqa-text);
             line-height: 1.1;
+            letter-spacing: -0.01em;
         }}
         .qqa-score .value.infeasible {{ color: #b45309; }}
         .qqa-score .unit {{
@@ -481,7 +486,14 @@ def apply_theme() -> None:
             color: var(--qqa-muted);
             font-size: 0.85rem;
             margin-top: 0.3rem;
+            font-variant-numeric: tabular-nums;
         }}
+        .qqa-score .raw.polish {{
+            color: #047857;
+            font-weight: 500;
+            margin-top: 0.45rem;
+        }}
+        .qqa-score .raw .muted {{ color: var(--qqa-muted); font-weight: 400; }}
         .qqa-badge {{
             display: inline-block;
             padding: 0.12rem 0.55rem;
@@ -661,20 +673,25 @@ def apply_theme() -> None:
             backdrop-filter: blur(10px);
         }}
         .qqa-score {{
-            background: linear-gradient(135deg, rgba(56,189,248,0.14), rgba(168,85,247,0.14));
+            background:
+              radial-gradient(120% 150% at 0% 0%, rgba(56,189,248,0.18) 0%, transparent 60%),
+              linear-gradient(135deg, rgba(56,189,248,0.14), rgba(168,85,247,0.14));
             border: 1px solid rgba(56,189,248,0.4);
-            border-left: 4px solid var(--qqa-accent);
-            padding: 1rem 1.4rem;
-            border-radius: 12px;
+            border-left: 5px solid var(--qqa-accent);
+            padding: 1.1rem 1.4rem;
+            border-radius: 14px;
             margin: 0.6rem 0 1rem 0;
+            box-shadow: 0 14px 36px -16px rgba(56,189,248,0.50),
+                        0 1px 2px rgba(0,0,0,0.30);
         }}
         .qqa-score .label {{
             font-size: 0.72rem; letter-spacing: 0.12em;
             text-transform: uppercase; color: var(--qqa-muted);
         }}
         .qqa-score .value {{
             font-family: 'Source Serif 4', serif;
-            font-size: 2.2rem; font-weight: 700; color: #f8fafc;
+            font-size: 2.4rem; font-weight: 700; color: #f8fafc;
+            letter-spacing: -0.01em;
         }}
         .qqa-score .value.infeasible {{ color: #fcd34d; }}
         .qqa-score .unit {{
@@ -683,7 +700,14 @@ def apply_theme() -> None:
         }}
         .qqa-score .raw {{
             color: var(--qqa-muted); font-size: 0.85rem; margin-top: 0.3rem;
+            font-variant-numeric: tabular-nums;
         }}
+        .qqa-score .raw.polish {{
+            color: #6ee7b7;
+            font-weight: 500;
+            margin-top: 0.45rem;
+        }}
+        .qqa-score .raw .muted {{ color: var(--qqa-muted); font-weight: 400; }}
         .qqa-badge {{
             display: inline-block; padding: 0.12rem 0.55rem; border-radius: 999px;
             font-size: 0.72rem; font-weight: 600; letter-spacing: 0.04em;
@@ -705,6 +729,7 @@ def apply_theme() -> None:
 _PAPER_URL = "https://openreview.net/forum?id=9EfBeXaXf0"
 _GITHUB_URL = "https://github.com/Yuma-Ichikawa/QQA4CO"
 _DEMO_URL = "https://parallelquasiquantum4co.streamlit.app/"
+_DOI_URL = "https://doi.org/10.5281/zenodo.19648231"
 
 
 def sidebar_brand() -> None:
@@ -851,6 +876,8 @@ def paper_link_footer() -> None:
                    text-decoration:none;">📄  Paper (OpenReview)</a>
                 <a href="{_GITHUB_URL}" target="_blank" style="color:{link};
                    text-decoration:none;">⎇  GitHub repository</a>
+                <a href="{_DOI_URL}" target="_blank" style="color:{link};
+                   text-decoration:none;">🆔  Cite (Zenodo DOI)</a>
                 <a href="{_DEMO_URL}" target="_blank" style="color:{link};
                    text-decoration:none;">🚀  Hosted live demo</a>
               </div>
@@ -893,51 +920,111 @@ def hero_badges() -> None:
     )
 
 
+def render_config_chips(
+    cfg: dict,
+    *,
+    extras: dict | None = None,
+) -> None:
+    """Render the active problem configuration as a row of chip-style badges.
+
+    A more polished replacement for the bare ``problem: x | size: y | ...``
+    caption used at the top of the Solve / Visualize / Compare pages.
+
+    Args:
+        cfg: Problem configuration dict, must contain ``kind`` / ``size`` /
+            ``device`` / ``seed``.
+        extras: Optional ``{label: value}`` dict appended after the standard
+            chips (e.g. ``{"polish": "on", "warm-start": "off"}``).
+    """
+    p = palette()
+    accent = p["accent"]
+    border = p["border"]
+    muted = p["muted"]
+    chip_style = (
+        "display:inline-flex;align-items:center;gap:0.35rem;"
+        f"padding:0.22rem 0.7rem;border:1px solid {border};"
+        "background:rgba(148,163,184,0.10);border-radius:999px;"
+        "font-size:0.78rem;font-variant-numeric:tabular-nums;"
+        "white-space:nowrap;"
+    )
+    label_style = f"color:{muted};text-transform:uppercase;letter-spacing:0.06em;font-size:0.66rem;"
+    val_style = f"color:{accent};font-weight:600;"
+
+    def _chip(label: str, value: object) -> str:
+        return (
+            f'<span style="{chip_style}">'
+            f'<span style="{label_style}">{label}</span>'
+            f'<span style="{val_style}">{value}</span>'
+            f"</span>"
+        )
+
+    chips = [
+        _chip("problem", cfg.get("kind", "?")),
+        _chip("size", cfg.get("size", "?")),
+        _chip("device", cfg.get("device", "?")),
+        _chip("seed", cfg.get("seed", "?")),
+    ]
+    if extras:
+        for k, v in extras.items():
+            chips.append(_chip(k, v))
+    st.markdown(
+        '<div style="display:flex;gap:0.45rem;flex-wrap:wrap;margin:0.2rem 0 0.9rem 0;">'
+        + "".join(chips)
+        + "</div>",
+        unsafe_allow_html=True,
+    )
+
+
 def render_score_card(
     score: dict,
     raw_loss: float | None = None,
-    *,
-    pre_polish_loss: float | None = None,
+    **_extra: object,
 ) -> None:
     """Render the big problem-specific score tile used by the Solve page.
 
     Parameters
     ----------
     score:
-        Output of ``problem.score_summary``.
+        Output of ``problem.score_summary``. The dict may carry an extra
+        ``pre_polish_loss`` key — when present *and* strictly worse than
+        ``raw_loss`` we surface a small "before polish" badge so users
+        can see how much :func:`qqa.polish.greedy_one_flip` contributed.
     raw_loss:
         Optional raw ``loss_fn`` value (after polish, since ``anneal``
         replaces ``best_obj`` with the polished value).
-    pre_polish_loss:
-        Optional ``loss_fn`` value of the *un-polished* annealer winner.
-        Displayed as a small "before polish" badge whenever it is
-        strictly worse than ``raw_loss`` so the user can see how much
-        :func:`qqa.polish.greedy_one_flip` contributed.
+    **_extra:
+        Forward-compatible: silently absorbs any future kwargs from
+        callers so an out-of-sync deployment never crashes the page
+        with ``TypeError: got an unexpected keyword argument``.
     """
-    if not score:
+    if not isinstance(score, dict) or not score:
         return
-    feas = score.get("feasible", True)
+    feas = bool(score.get("feasible", True))
     badge = (
         '<span class="qqa-badge ok">feasible</span>'
         if feas
         else '<span class="qqa-badge warn">infeasible</span>'
     )
     value = score.get("value", "-")
-    value_s = f"{value:.4g}" if isinstance(value, float) else str(value)
+    value_s = f"{value:.4g}" if isinstance(value, int | float) else str(value)
     unit = score.get("unit", "")
     unit_html = f'<span class="unit">{unit}</span>' if unit else ""
-    raw_html = f'<div class="raw">raw loss = {raw_loss:.4g}</div>' if raw_loss is not None else ""
+    raw_html = ""
+    if isinstance(raw_loss, int | float):
+        raw_html = f'<div class="raw">raw loss = {float(raw_loss):.4g}</div>'
     polish_html = ""
+    pre_polish = score.get("pre_polish_loss")
     if (
-        pre_polish_loss is not None
-        and raw_loss is not None
+        isinstance(pre_polish, int | float)
+        and isinstance(raw_loss, int | float)
         # Only surface the line when polish actually moved the needle.
-        and pre_polish_loss > raw_loss + 1e-9
+        and float(pre_polish) > float(raw_loss) + 1e-9
     ):
-        delta = pre_polish_loss - raw_loss
+        delta = float(pre_polish) - float(raw_loss)
         polish_html = (
-            f'<div class="raw">pre-polish loss = {pre_polish_loss:.4g} '
-            f"(polish improved by {delta:.4g})</div>"
+            f'<div class="raw polish">▴ polish improved by '
+            f"<b>{delta:.4g}</b> "
+            f'<span class="muted">(pre-polish = {float(pre_polish):.4g})</span></div>'
         )
     value_cls = "value" if feas else "value infeasible"
     st.markdown(
@@ -1006,6 +1093,24 @@ def build_problem(cfg: dict) -> Any:
         )
     if kind == "sk":
         return _safe_call(qqa.SherringtonKirkpatrick, N=size, seed=seed, device=device)
+    if kind == "pspin":
+        return _safe_call(
+            qqa.PSpinGlass,
+            N=size,
+            p=int(extra.get("p_order", 3)),
+            seed=seed,
+            device=device,
+        )
+    if kind == "rfim":
+        return _safe_call(
+            qqa.RandomFieldIsing,
+            L=size,
+            dim=int(extra.get("dim", 2)),
+            J=float(extra.get("coupling_J", 1.0)),
+            h_std=float(extra.get("h_std", 1.0)),
+            seed=seed,
+            device=device,
+        )
     if kind == "perceptron":
         return _safe_call(
             qqa.BinaryPerceptron,

app/_solution_viz.py

@@ -1422,7 +1422,14 @@ def render_hopfield(problem, result, cfg) -> None:
     "maxsat3": render_maxsat3,
     "ising1d": render_ising1d,
     "sk": render_sk,
+    # Dense p-spin glass has no useful spatial layout — reuse the SK ring
+    # + local-energy view (J is None for p > 2 so only the ring renders,
+    # which is exactly what we want).
+    "pspin": render_sk,
     "ea": render_ea,
+    # RFIM lives on the same hyper-cubic lattice as EA, so the EA
+    # 2D-slice renderer applies as-is.
+    "rfim": render_ea,
     "perceptron": render_perceptron,
     "hopfield": render_hopfield,
 }

app/pages/1_Solve.py

@@ -19,6 +19,7 @@
     palette,
     paper_link_footer,
     plotly_layout,
+    render_config_chips,
     render_score_card,
     sidebar_brand,
     theme_toggle_in_sidebar,
@@ -49,10 +50,7 @@
     )
     st.stop()
 cfg = st.session_state["problem_config"]
-st.caption(
-    f"problem: **{cfg['kind']}** | size: **{cfg['size']}** | "
-    f"device: **{cfg['device']}** | seed: **{cfg['seed']}**"
-)
+render_config_chips(cfg)
 
 # Hyper-parameter presets — each tuple is
 # (sol_size, epochs, learning_rate, temp, min_bg, max_bg, curve_rate,
@@ -447,7 +445,21 @@ def on_epoch_end(self, state: CallbackState) -> None:
         )
 
 
-run = st.button("▶  Run QQA", type="primary")
+# Compact "active hyper-params" chip row, so the user can see what is
+# about to run without scrolling the sidebar.
+render_config_chips(
+    cfg,
+    extras={
+        "sol_size": sol_size,
+        "epochs": epochs,
+        "lr": f"{learning_rate:.2g}",
+        "T": f"{temp:.2g}",
+        "polish": "on" if polish else "off",
+        "warm-start": "on" if warm_start else "off",
+    },
+)
+
+run = st.button("▶  Run QQA", type="primary", width="stretch")
 if run:
     try:
         problem = build_problem(cfg)
@@ -521,13 +533,19 @@ def on_epoch_end(self, state: CallbackState) -> None:
         else float(np.asarray(result.best_obj).mean())
     )
     # The callback tracks the *un-polished* running best (it fires inside
-    # the annealing loop, before greedy_one_flip runs). Surface that here
-    # so users can see how much polish contributed when it actually fired.
-    pre_polish = (
-        cb.best_disc[-1] if (polish and result.polished_sol is not None and cb.best_disc) else None
-    )
+    # the annealing loop, before greedy_one_flip runs). Inject it into
+    # the score dict so render_score_card can show a "polish improved
+    # by Δ" badge when polish actually moved the needle. We pass it via
+    # the dict (instead of a kwarg) so an older deployed _common.py
+    # cannot raise ``TypeError: got an unexpected keyword argument``.
+    import contextlib  # noqa: PLC0415
+
+    score_payload = dict(result.score) if isinstance(result.score, dict) else {}
+    if polish and result.polished_sol is not None and cb.best_disc:
+        with contextlib.suppress(TypeError, ValueError):
+            score_payload["pre_polish_loss"] = float(cb.best_disc[-1])
     with score_holder.container():
-        render_score_card(result.score, raw_loss=raw, pre_polish_loss=pre_polish)
+        render_score_card(score_payload, raw_loss=raw)
     st.session_state.setdefault("results", []).append(
         {
             "cfg": dict(cfg),

app/streamlit_app.py

@@ -154,6 +154,8 @@
                 ("ising1d", "1D Ising model"),
                 ("ea", "Edwards–Anderson spin glass"),
                 ("sk", "Sherrington–Kirkpatrick spin glass"),
+                ("pspin", "p-spin glass (dense, p ≥ 2)"),
+                ("rfim", "Random Field Ising Model (RFIM)"),
                 ("perceptron", "Binary perceptron"),
                 ("hopfield", "Hopfield memory"),
             ],
@@ -168,8 +170,12 @@
             format_func=lambda s: _LABELS[s],
         )
 
-        size_default = {"tsp": 8, "qap": 8, "nqueens": 8, "ea": 6}.get(problem_kind, 32)
-        size_max = {"tsp": 20, "qap": 14, "nqueens": 14, "ea": 16}.get(problem_kind, 400)
+        size_default = {"tsp": 8, "qap": 8, "nqueens": 8, "ea": 6, "rfim": 8, "pspin": 16}.get(
+            problem_kind, 32
+        )
+        size_max = {"tsp": 20, "qap": 14, "nqueens": 14, "ea": 16, "rfim": 20, "pspin": 32}.get(
+            problem_kind, 400
+        )
         size_label = {
             "tsp": "Cities N",
             "qap": "Facilities N",
@@ -178,6 +184,8 @@
             "knapsack": "Items N",
             "number_partition": "Values N",
             "ea": "Lattice side L",
+            "rfim": "Lattice side L",
+            "pspin": "Spins N",
         }.get(problem_kind, "Problem size (N)")
         size = st.number_input(size_label, min_value=4, max_value=size_max, value=size_default)
         seed = st.number_input("Seed", min_value=0, max_value=10_000, value=0)
@@ -203,6 +211,12 @@
             )
         if problem_kind == "ea":
             extra["dim"] = st.selectbox("Lattice dim", (2, 3), index=1)
+        if problem_kind == "rfim":
+            extra["dim"] = st.selectbox("Lattice dim", (1, 2, 3), index=1)
+            extra["coupling_J"] = st.slider("Ferromagnetic coupling J", 0.1, 5.0, 1.0, 0.1)
+            extra["h_std"] = st.slider("Random-field σ_h", 0.0, 5.0, 1.0, 0.1)
+        if problem_kind == "pspin":
+            extra["p_order"] = st.slider("Interaction order p", 2, 5, 3)
         if problem_kind == "perceptron":
             extra["alpha"] = st.slider("Loading α = M/N", 0.1, 1.5, 0.5, 0.1)
         if problem_kind == "hopfield":