Add Gallery tab: factor poster, cuisine compass, vector arithmetic art, phylogeny, cosine map, SLERP trajectory

app.py

@@ -528,6 +528,389 @@ def api_embed(ingredient, sibling="chem"):
     if ingredient not in m.vocab: return {"error": f"'{ingredient}' not in vocab"}
     return [float(x) for x in _unit(m.E[m.vocab[ingredient]]).tolist()]
 
+# =====================================================================
+# Gallery: six aesthetic visualisations.
+# All use a shared dark-teal Kaikaku palette so they hang together.
+# =====================================================================
+
+GALLERY_BG     = KAIKAKU_DARK
+GALLERY_GRID   = "#1F4548"
+GALLERY_DUST   = "#1A3D3F"
+GALLERY_TEXT   = "#E8F4F1"
+GALLERY_TXTDIM = KAIKAKU_ACCENT_LIGHT
+GALLERY_MODE_PALETTE = [
+    "#B5E6D2", "#F4B86E", "#E8C0E8", "#9BC9E8", "#D7E89B",
+    "#FFAA8A", "#A8D5CA", "#E8E0A0",
+]
+
+# All cuisine names we display
+_CUISINES = ["East_Asian","Japanese","Southeast_Asian","South_Asian",
+             "Mediterranean","Eastern_European","Latin_American","Western_Atlantic"]
+
+
+def _gallery_axes(figsize=(10, 9)):
+    fig, ax = plt.subplots(figsize=figsize, facecolor=GALLERY_BG)
+    ax.set_facecolor(GALLERY_BG)
+    for s in ax.spines.values(): s.set_visible(False)
+    ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
+    return fig, ax
+
+
+# ---------- (1) Factor decomposition poster ----------
+
+def factor_options(sibling: str):
+    m = MODELS[sibling]
+    fids = sorted({md.property for md in m.modes if md.kind == "factor"},
+                  key=lambda x: int(x.split("_")[-1]) if x.split("_")[-1].isdigit() else 99)
+    return fids
+
+def render_factor_poster(sibling: str, factor_id: str):
+    """Reference-screenshot style: dark teal background, faint contour texture,
+    GMM-mode point clusters in pastel colours, callouts with leader lines, bottom stat line."""
+    m = MODELS[sibling]
+    coords = UMAP_DATA[sibling]
+    factor_modes = [md for md in m.modes if md.kind == "factor" and md.property == factor_id]
+    if not factor_modes:
+        fig, ax = _gallery_axes()
+        ax.text(0.5, 0.5, "(no factor selected)", ha="center", va="center",
+                color=GALLERY_TXTDIM, transform=ax.transAxes)
+        return fig
+
+    fig, ax = _gallery_axes(figsize=(11, 10))
+    xmin, xmax = float(coords[:,0].min()-0.8), float(coords[:,0].max()+0.8)
+    ymin, ymax = float(coords[:,1].min()-0.8), float(coords[:,1].max()+0.8)
+
+    # Topographic background: KDE of all ingredients, contoured
+    try:
+        from scipy.stats import gaussian_kde
+        kde = gaussian_kde(coords.T, bw_method=0.18)
+        xx, yy = np.meshgrid(np.linspace(xmin, xmax, 160), np.linspace(ymin, ymax, 160))
+        zz = kde(np.vstack([xx.ravel(), yy.ravel()])).reshape(xx.shape)
+        ax.contour(xx, yy, zz, levels=14, colors=GALLERY_GRID, alpha=0.45, linewidths=0.6)
+    except Exception:
+        pass
+
+    # Faint background scatter of every ingredient
+    ax.scatter(coords[:, 0], coords[:, 1], s=2, c=GALLERY_DUST, alpha=0.5,
+               linewidths=0, zorder=2)
+
+    # Plot each mode's members + callout
+    name_to_idx = MODELS[sibling].vocab
+    used_corners = []
+    corners = [(xmax-0.5, ymax-0.5), (xmin+0.5, ymax-0.5),
+               (xmax-0.5, ymin+0.5), (xmin+0.5, ymin+0.5),
+               (xmax-0.5, (ymin+ymax)/2), (xmin+0.5, (ymin+ymax)/2)]
+    for i, mode in enumerate(factor_modes):
+        idxs = [name_to_idx[n] for n in mode.members if n in name_to_idx]
+        if not idxs: continue
+        color = GALLERY_MODE_PALETTE[i % len(GALLERY_MODE_PALETTE)]
+        pts = coords[idxs]
+        # Scatter with size jitter for a painterly look
+        sizes = np.random.RandomState(i).randint(50, 130, len(idxs))
+        ax.scatter(pts[:,0], pts[:,1], s=sizes, c=color, alpha=0.92,
+                   edgecolors="white", linewidths=0.6, zorder=4)
+        # Callout
+        cx, cy = float(pts[:,0].mean()), float(pts[:,1].mean())
+        # pick a corner not yet used
+        corner = corners[i % len(corners)]
+        used_corners.append(corner)
+        ax.annotate(
+            f"M{mode.mode_id.split('M')[-1]} · {mode.label.upper()}",
+            xy=(cx, cy), xytext=corner,
+            color=GALLERY_TEXT, fontsize=9, family="monospace",
+            ha=("right" if corner[0] > (xmin+xmax)/2 else "left"),
+            va="center",
+            arrowprops=dict(arrowstyle="-", color=GALLERY_TXTDIM, lw=0.7,
+                            connectionstyle="arc3,rad=0.1"),
+            zorder=5,
+        )
+
+    ax.set_xlim(xmin, xmax); ax.set_ylim(ymin, ymax); ax.set_aspect("equal")
+
+    # Title strip top-left
+    ax.text(0.02, 0.97,
+            f"EPICURE  ·  FACTOR DECOMPOSITION  ·  {factor_id.upper()}",
+            transform=ax.transAxes, color=GALLERY_TXTDIM,
+            fontsize=11, family="monospace", va="top")
+
+    # Bottom stat line
+    n_modes = len(factor_modes)
+    total_n = sum(md.n_members for md in factor_modes)
+    fig.text(0.5, 0.07,
+             "All of human cooking compressed into 2 megabytes.",
+             ha="center", color=GALLERY_TEXT, fontsize=15)
+    fig.text(0.5, 0.04,
+             f"SIBLING {sibling.upper()}  ·  {n_modes} MODES  ·  {total_n} INGREDIENTS  ·  300-D EMBEDDING",
+             ha="center", color=GALLERY_TXTDIM, fontsize=9, family="monospace")
+    plt.tight_layout(rect=[0, 0.09, 1, 1])
+    return fig
+
+
+# ---------- (2) Cuisine compass (polar radar) ----------
+
+def _cuisine_pole(m, region):
+    key = f"cuisine:{region}"
+    if key in m.supervised_poles:
+        return _unit(m.supervised_poles[key])
+    return None
+
+def render_cuisine_compass(sibling: str, ingredients: list[str]):
+    m = MODELS[sibling]
+    valid = [n for n in (ingredients or []) if n in m.vocab]
+    if not valid:
+        fig = go.Figure()
+        fig.add_annotation(text="Pick at least one ingredient",
+                           showarrow=False, font=dict(color=GALLERY_TXTDIM, size=14),
+                           xref="paper", yref="paper", x=0.5, y=0.5)
+        fig.update_layout(paper_bgcolor=GALLERY_BG, plot_bgcolor=GALLERY_BG, height=520)
+        return fig
+    poles = {c: _cuisine_pole(m, c) for c in _CUISINES}
+    poles = {c: p for c, p in poles.items() if p is not None}
+    cuisines = list(poles.keys())
+    fig = go.Figure()
+    palette = GALLERY_MODE_PALETTE
+    for i, ing in enumerate(valid):
+        v = _unit(m.E[m.vocab[ing]])
+        radii = [float(v @ poles[c]) for c in cuisines]
+        # close the polygon
+        radii_closed = radii + [radii[0]]
+        labels_closed = cuisines + [cuisines[0]]
+        color = palette[i % len(palette)]
+        fig.add_trace(go.Scatterpolar(
+            r=radii_closed, theta=labels_closed,
+            fill="toself", name=ing,
+            fillcolor=f"rgba({int(color[1:3],16)},{int(color[3:5],16)},{int(color[5:7],16)},0.25)",
+            line=dict(color=color, width=2),
+            marker=dict(size=6, color=color),
+            hovertemplate="%{theta}<br>cos = %{r:.3f}<extra>" + ing + "</extra>",
+        ))
+    fig.update_layout(
+        polar=dict(
+            bgcolor=GALLERY_BG,
+            radialaxis=dict(visible=True, gridcolor=GALLERY_GRID, range=[-0.2, 0.8],
+                            tickfont=dict(color=GALLERY_TXTDIM, size=9),
+                            angle=90, tickangle=90),
+            angularaxis=dict(gridcolor=GALLERY_GRID,
+                             tickfont=dict(color=GALLERY_TEXT, size=11)),
+        ),
+        paper_bgcolor=GALLERY_BG,
+        font=dict(color=GALLERY_TEXT),
+        legend=dict(font=dict(color=GALLERY_TEXT), bgcolor="rgba(0,0,0,0)"),
+        title=dict(text=f"CUISINE COMPASS · {sibling.upper()}",
+                   font=dict(color=GALLERY_TXTDIM, size=12, family="monospace"),
+                   x=0.02, xanchor="left"),
+        height=560, margin=dict(l=60, r=60, t=70, b=40),
+    )
+    return fig
+
+
+# ---------- (7) Arithmetic vector art ----------
+
+def render_arithmetic_vector(sibling: str, positives: list[str], negatives: list[str]):
+    """Visualise centroid(positives) - centroid(negatives) as vector arrows on the UMAP."""
+    m = MODELS[sibling]
+    coords = UMAP_DATA[sibling]
+    fig, ax = _gallery_axes(figsize=(11, 9))
+    xmin, xmax = float(coords[:,0].min()-0.8), float(coords[:,0].max()+0.8)
+    ymin, ymax = float(coords[:,1].min()-0.8), float(coords[:,1].max()+0.8)
+    try:
+        from scipy.stats import gaussian_kde
+        kde = gaussian_kde(coords.T, bw_method=0.20)
+        xx, yy = np.meshgrid(np.linspace(xmin, xmax, 140), np.linspace(ymin, ymax, 140))
+        zz = kde(np.vstack([xx.ravel(), yy.ravel()])).reshape(xx.shape)
+        ax.contour(xx, yy, zz, levels=10, colors=GALLERY_GRID, alpha=0.4, linewidths=0.5)
+    except Exception: pass
+    ax.scatter(coords[:,0], coords[:,1], s=2, c=GALLERY_DUST, alpha=0.45)
+
+    if not positives:
+        ax.text(0.5, 0.5, "Pick at least one positive ingredient", ha="center",
+                va="center", transform=ax.transAxes, color=GALLERY_TXTDIM)
+        return fig
+
+    pos = _basket_centroid(m, positives)
+    neg = _basket_centroid(m, negatives) if negatives else None
+    q = _unit(pos - neg) if neg is not None else pos
+
+    def project(vec, k=8):
+        sims = m.E @ vec
+        idxs = np.argsort(-sims)[:k]
+        return coords[idxs].mean(axis=0), idxs
+
+    pos_pt, pos_top = project(pos)
+    res_pt, res_top = project(q)
+
+    # Plot positives in mint
+    for n in positives:
+        if n in m.vocab:
+            p = coords[m.vocab[n]]
+            ax.scatter([p[0]], [p[1]], s=140, c=KAIKAKU_ACCENT_LIGHT,
+                       edgecolors="white", linewidths=0.8, zorder=4)
+            ax.text(p[0], p[1]+0.25, n, color=KAIKAKU_ACCENT_LIGHT, ha="center",
+                    fontsize=10, fontweight="bold", zorder=5)
+    # Plot negatives in warm
+    for n in (negatives or []):
+        if n in m.vocab:
+            p = coords[m.vocab[n]]
+            ax.scatter([p[0]], [p[1]], s=140, c="#F4B86E",
+                       edgecolors="white", linewidths=0.8, zorder=4)
+            ax.text(p[0], p[1]+0.25, "− " + n, color="#F4B86E", ha="center",
+                    fontsize=10, fontweight="bold", zorder=5)
+    # Plot result as star
+    ax.scatter([res_pt[0]], [res_pt[1]], s=420, c="#FFFFFF", marker="*",
+               edgecolors=KAIKAKU_ACCENT_LIGHT, linewidths=1.5, zorder=6)
+    # Draw arrow from positives centroid -> result
+    ax.annotate("", xy=res_pt, xytext=pos_pt,
+                arrowprops=dict(arrowstyle="->", color=KAIKAKU_ACCENT_LIGHT, lw=1.8),
+                zorder=5)
+    # Label top-K of result
+    for idx in res_top[:5]:
+        p = coords[idx]
+        ax.text(p[0]+0.10, p[1], NAMES_BY_IDX[idx], color=GALLERY_TEXT,
+                fontsize=8, alpha=0.85, zorder=4)
+        ax.scatter([p[0]], [p[1]], s=30, c="#FFFFFF", alpha=0.6,
+                   edgecolors=GALLERY_TXTDIM, linewidths=0.6, zorder=3)
+
+    ax.set_xlim(xmin, xmax); ax.set_ylim(ymin, ymax); ax.set_aspect("equal")
+    title = " + ".join(positives) + (" − " + " − ".join(negatives) if negatives else "")
+    ax.text(0.02, 0.97, f"VECTOR ARITHMETIC · {sibling.upper()}",
+            transform=ax.transAxes, color=GALLERY_TXTDIM,
+            fontsize=11, family="monospace", va="top")
+    ax.text(0.02, 0.93, title, transform=ax.transAxes, color=GALLERY_TEXT,
+            fontsize=13, va="top")
+    res_names = ", ".join(NAMES_BY_IDX[i] for i in res_top[:5])
+    fig.text(0.5, 0.04, "Result top-5: " + res_names,
+             ha="center", color=GALLERY_TXTDIM, fontsize=10, family="monospace")
+    plt.tight_layout(rect=[0, 0.06, 1, 1])
+    return fig
+
+
+# ---------- (8) Cuisine phylogeny (dendrogram) ----------
+
+def render_cuisine_phylogeny(sibling: str):
+    m = MODELS[sibling]
+    cuisines = [c for c in _CUISINES if f"cuisine:{c}" in m.supervised_poles]
+    if len(cuisines) < 2:
+        fig, ax = _gallery_axes(figsize=(10, 5))
+        ax.text(0.5, 0.5, "Cuisine poles unavailable for this sibling",
+                ha="center", va="center", transform=ax.transAxes, color=GALLERY_TXTDIM)
+        return fig
+    poles = np.stack([_unit(m.supervised_poles[f"cuisine:{c}"]) for c in cuisines])
+    # cosine distance matrix
+    D = 1 - poles @ poles.T
+    # condensed distance
+    n = len(cuisines)
+    cond = []
+    for i in range(n):
+        for j in range(i+1, n):
+            cond.append(max(0.0, float(D[i, j])))
+    from scipy.cluster.hierarchy import linkage, dendrogram
+    Z = linkage(np.array(cond), method="average")
+    fig, ax = _gallery_axes(figsize=(11, 6))
+    matplotlib.rcParams["lines.linewidth"] = 1.4
+    ddata = dendrogram(Z, labels=cuisines, ax=ax, color_threshold=0,
+                       above_threshold_color=KAIKAKU_ACCENT_LIGHT,
+                       leaf_font_size=11, leaf_rotation=0)
+    ax.tick_params(axis="x", colors=GALLERY_TEXT, labelsize=10, pad=8)
+    ax.tick_params(axis="y", colors=GALLERY_TXTDIM, labelsize=8, labelleft=True, left=True)
+    ax.spines["bottom"].set_visible(False)
+    ax.spines["left"].set_visible(True); ax.spines["left"].set_color(GALLERY_TXTDIM)
+    ax.set_ylabel("cosine distance", color=GALLERY_TXTDIM, fontsize=10)
+    ax.set_title("", color=GALLERY_TEXT)
+    fig.text(0.02, 0.95, f"CUISINE PHYLOGENY · {sibling.upper()}",
+             color=GALLERY_TXTDIM, fontsize=11, family="monospace")
+    fig.text(0.02, 0.92, "Hierarchical clustering of cuisine pole vectors (cosine, average linkage)",
+             color=GALLERY_TEXT, fontsize=10)
+    plt.tight_layout(rect=[0, 0, 1, 0.93])
+    return fig
+
+
+# ---------- (6) Cuisine cosine map (matrix-art version of chord) ----------
+
+def render_cuisine_cosine_map(sibling: str):
+    m = MODELS[sibling]
+    cuisines = [c for c in _CUISINES if f"cuisine:{c}" in m.supervised_poles]
+    poles = np.stack([_unit(m.supervised_poles[f"cuisine:{c}"]) for c in cuisines])
+    S = poles @ poles.T
+    fig, ax = _gallery_axes(figsize=(9, 8))
+    # custom colormap: deep teal -> mint
+    from matplotlib.colors import LinearSegmentedColormap
+    cmap = LinearSegmentedColormap.from_list("kaikaku", [GALLERY_BG, GALLERY_DUST, KAIKAKU_ACCENT, KAIKAKU_ACCENT_LIGHT])
+    im = ax.imshow(S, cmap=cmap, vmin=0.0, vmax=1.0, aspect="auto")
+    ax.set_xticks(range(len(cuisines))); ax.set_yticks(range(len(cuisines)))
+    ax.set_xticklabels([c.replace("_"," ") for c in cuisines], rotation=35, ha="right",
+                       color=GALLERY_TEXT, fontsize=10)
+    ax.set_yticklabels([c.replace("_"," ") for c in cuisines], color=GALLERY_TEXT, fontsize=10)
+    ax.tick_params(left=True, bottom=False)
+    for i in range(len(cuisines)):
+        for j in range(len(cuisines)):
+            v = float(S[i,j])
+            ax.text(j, i, f"{v:.2f}", ha="center", va="center",
+                    color=("white" if v < 0.5 else GALLERY_BG), fontsize=10)
+    cb = plt.colorbar(im, ax=ax, shrink=0.8)
+    cb.outline.set_visible(False)
+    cb.ax.yaxis.set_tick_params(color=GALLERY_TXTDIM)
+    plt.setp(plt.getp(cb.ax.axes, "yticklabels"), color=GALLERY_TXTDIM)
+    cb.set_label("cosine", color=GALLERY_TXTDIM)
+    fig.text(0.02, 0.96, f"CUISINE COSINE MAP · {sibling.upper()}",
+             color=GALLERY_TXTDIM, fontsize=11, family="monospace")
+    fig.text(0.02, 0.93, "Pairwise cosine similarity between cuisine pole vectors",
+             color=GALLERY_TEXT, fontsize=10)
+    plt.tight_layout(rect=[0, 0, 1, 0.92])
+    return fig
+
+
+# ---------- (3) SLERP trajectory frames ----------
+
+def render_slerp_trajectory(sibling: str, seed: str, direction: str, max_theta: int = 60):
+    """Show the rotation as 5 stacked UMAP panels at increasing angles."""
+    m = MODELS[sibling]
+    coords = UMAP_DATA[sibling]
+    if seed not in m.vocab or direction not in m.supervised_poles:
+        fig, ax = _gallery_axes(figsize=(11, 4))
+        ax.text(0.5, 0.5, "Pick a valid seed and direction",
+                ha="center", va="center", transform=ax.transAxes, color=GALLERY_TXTDIM)
+        return fig
+    v = _unit(m.E[m.vocab[seed]])
+    d = _unit(m.supervised_poles[direction])
+    thetas = [0, int(max_theta*0.33), int(max_theta*0.66), int(max_theta)]
+    xmin, xmax = float(coords[:,0].min()-0.5), float(coords[:,0].max()+0.5)
+    ymin, ymax = float(coords[:,1].min()-0.5), float(coords[:,1].max()+0.5)
+    fig, axes = plt.subplots(1, len(thetas), figsize=(15, 4.2), facecolor=GALLERY_BG,
+                             gridspec_kw=dict(wspace=0.05))
+    for ax, theta in zip(axes, thetas):
+        ax.set_facecolor(GALLERY_BG)
+        for s in ax.spines.values(): s.set_visible(False)
+        ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False)
+        # background
+        ax.scatter(coords[:,0], coords[:,1], s=1.8, c=GALLERY_DUST, alpha=0.5)
+        q = _slerp(v, d, theta)
+        # top-K of current query
+        sims = m.E @ q
+        top = np.argsort(-sims)[:6]
+        # exclude seed
+        seed_idx = m.vocab[seed]
+        top = [i for i in top if i != seed_idx][:5]
+        # seed in mint
+        sp = coords[seed_idx]
+        ax.scatter([sp[0]], [sp[1]], s=200, c=KAIKAKU_ACCENT_LIGHT,
+                   edgecolors="white", linewidths=0.8, marker="*", zorder=4)
+        ax.text(sp[0], sp[1]+0.3, seed, color=KAIKAKU_ACCENT_LIGHT, ha="center",
+                fontsize=10, fontweight="bold", zorder=5)
+        # rotated query top-K
+        for idx in top:
+            p = coords[idx]
+            ax.scatter([p[0]], [p[1]], s=80, c="#F4B86E", edgecolors="white",
+                       linewidths=0.5, alpha=0.9, zorder=4)
+            ax.text(p[0]+0.05, p[1], NAMES_BY_IDX[idx], color=GALLERY_TEXT,
+                    fontsize=8, alpha=0.9, zorder=4)
+        ax.set_xlim(xmin, xmax); ax.set_ylim(ymin, ymax); ax.set_aspect("equal")
+        ax.set_title(f"θ = {theta}°", color=GALLERY_TXTDIM, fontsize=11,
+                     family="monospace", pad=6)
+    fig.suptitle(f"SLERP TRAJECTORY · {seed} → {direction} · {sibling.upper()}",
+                 color=GALLERY_TXTDIM, fontsize=12, family="monospace", y=0.98)
+    return fig
+
+
 # ===== Theme =====
 
 THEME = gr.themes.Soft(
@@ -864,6 +1247,74 @@ Three sibling ingredient embeddings from [arXiv:2605.22391](https://arxiv.org/ab
                 label="Try one of these",
             )
 
+        # ---------- Tab 5: GALLERY ----------
+        with gr.Tab("Gallery"):
+            gr.Markdown("Six aesthetic views of the model. All rendered in the Kaikaku palette.")
+            with gr.Tabs():
+                # --- Factor poster ---
+                with gr.Tab("Factor poster"):
+                    with gr.Row():
+                        fp_sib = gr.Radio(choices=["cooc","core","chem"], value="chem",
+                                          label="Sibling", scale=1)
+                        fp_factor = gr.Dropdown(choices=factor_options("chem"),
+                                                value=factor_options("chem")[0] if factor_options("chem") else None,
+                                                label="Factor", scale=2)
+                        fp_btn = gr.Button("Render", variant="primary", scale=1)
+                    fp_plot = gr.Plot(label="", value=render_factor_poster("chem", factor_options("chem")[0] if factor_options("chem") else ""))
+                    fp_btn.click(render_factor_poster, inputs=[fp_sib, fp_factor], outputs=fp_plot, show_progress="full")
+                    fp_sib.change(lambda s: gr.Dropdown(choices=factor_options(s), value=factor_options(s)[0] if factor_options(s) else None),
+                                  inputs=fp_sib, outputs=fp_factor)
+
+                # --- Cuisine compass ---
+                with gr.Tab("Cuisine compass"):
+                    with gr.Row():
+                        cc_sib = gr.Radio(choices=["cooc","core","chem"], value="chem", label="Sibling")
+                        cc_ings = gr.Dropdown(choices=ALL_INGREDIENTS, value=["miso","basil","cumin"],
+                                              label="Ingredients (1-5 polygons)", multiselect=True, max_choices=5)
+                        cc_btn = gr.Button("Render", variant="primary")
+                    cc_plot = gr.Plot(label="", value=render_cuisine_compass("chem", ["miso","basil","cumin"]))
+                    cc_btn.click(render_cuisine_compass, inputs=[cc_sib, cc_ings], outputs=cc_plot, show_progress="minimal")
+
+                # --- Arithmetic vector art ---
+                with gr.Tab("Vector arithmetic"):
+                    with gr.Row():
+                        va_sib = gr.Radio(choices=["cooc","core","chem"], value="core", label="Sibling")
+                        va_pos = gr.Dropdown(choices=ALL_INGREDIENTS, value=["miso"], label="Positives", multiselect=True, max_choices=5)
+                        va_neg = gr.Dropdown(choices=ALL_INGREDIENTS, value=["salt"], label="Negatives", multiselect=True, max_choices=5)
+                        va_btn = gr.Button("Render", variant="primary")
+                    va_plot = gr.Plot(label="", value=render_arithmetic_vector("core", ["miso"], ["salt"]))
+                    va_btn.click(render_arithmetic_vector, inputs=[va_sib, va_pos, va_neg], outputs=va_plot, show_progress="full")
+
+                # --- Cuisine phylogeny ---
+                with gr.Tab("Cuisine phylogeny"):
+                    with gr.Row():
+                        ph_sib = gr.Radio(choices=["cooc","core","chem"], value="chem", label="Sibling")
+                        ph_btn = gr.Button("Render", variant="primary")
+                    ph_plot = gr.Plot(label="", value=render_cuisine_phylogeny("chem"))
+                    ph_btn.click(render_cuisine_phylogeny, inputs=[ph_sib], outputs=ph_plot, show_progress="minimal")
+
+                # --- Cuisine cosine map ---
+                with gr.Tab("Cuisine cosine map"):
+                    with gr.Row():
+                        cm_sib = gr.Radio(choices=["cooc","core","chem"], value="chem", label="Sibling")
+                        cm_btn = gr.Button("Render", variant="primary")
+                    cm_plot = gr.Plot(label="", value=render_cuisine_cosine_map("chem"))
+                    cm_btn.click(render_cuisine_cosine_map, inputs=[cm_sib], outputs=cm_plot, show_progress="minimal")
+
+                # --- SLERP trajectory ---
+                with gr.Tab("SLERP trajectory"):
+                    with gr.Row():
+                        st_sib = gr.Radio(choices=["cooc","core","chem"], value="chem", label="Sibling")
+                        st_seed = gr.Dropdown(choices=ALL_INGREDIENTS, value="rice", label="Seed")
+                        st_dir = gr.Dropdown(choices=_supervised_choices("chem"),
+                                             value="cuisine:South_Asian", label="Direction")
+                        st_max = gr.Slider(15, 90, value=60, step=15, label="Max θ (deg)")
+                        st_btn = gr.Button("Render", variant="primary")
+                    st_plot = gr.Plot(label="", value=render_slerp_trajectory("chem", "rice", "cuisine:South_Asian", 60))
+                    st_btn.click(render_slerp_trajectory, inputs=[st_sib, st_seed, st_dir, st_max], outputs=st_plot, show_progress="full")
+                    st_sib.change(lambda s: gr.Dropdown(choices=_supervised_choices(s), value=None),
+                                  inputs=st_sib, outputs=st_dir)
+
     # ---- Hidden API endpoints ----
     with gr.Group(visible=False):
         api_in_s1 = gr.Textbox(visible=False)