for demo

HANDOFF.md

@@ -0,0 +1,99 @@
+# Council AI — Theorem Explorer: Handoff Notes
+
+This is a Gradio app implementing Theorem 1 (deliberation convergence) and
+Theorem 2 (multi-expert safety bound) from the Council AI paper, styled to
+match Nexenda's brand (Instrument Sans / Noto Serif, dark palette, gold accent).
+
+**Status:** Math and theorem logic are locked, verified against the paper's
+worked examples. UI/branding/layout is the open area for refinement.
+
+**Constraints to keep in mind while editing:** no Bamzi product names, no
+"Mixture of Councils" / "MoC" naming, anywhere in the app or its outputs.
+Both are withheld until later papers. See the Council AI paper draft for
+the full naming context if needed.
+
+---
+
+## 1. Run it locally
+
+Requires Python 3.9+ (check with `python3 --version`; on a fresh Mac this is
+often older, in which case `brew install python@3.12` first).
+
+```bash
+cd council-ai-theorem-explorer
+python3 -m venv venv
+source venv/bin/activate      # Windows: venv\Scripts\activate
+pip install -r requirements.txt
+python app.py
+```
+
+Opens at `http://127.0.0.1:7860`. Every slider updates the plot live.
+
+**Note:** `venv` must be reactivated (`source venv/bin/activate`) every time
+you open a new terminal session, it doesn't persist automatically.
+
+**Faster iteration loop:** run `gradio app.py` instead of `python app.py`
+(same package, different entry point), it auto-reloads on file save so you
+don't have to stop/restart manually while tweaking the UI.
+
+**Quick temporary share link, no deploy needed:** in `app.py`, change the
+final `demo.launch(...)` call to add `share=True`. Gradio prints a public
+`https://xxxxx.gradio.live` URL valid for 72 hours, useful for a fast look
+before anything's pushed anywhere. It only stays live while your machine
+and terminal session are running.
+
+---
+
+## 2. Push to GitHub
+
+```bash
+git init
+git add .
+git commit -m "Initial theorem explorer"
+```
+
+Create a private repo under the Nexenda org on github.com (don't
+initialize it with a README, this project already has one), then:
+
+```bash
+git remote add origin https://github.com/nexendahq/<repo-name>.git
+git branch -M main
+git push -u origin main
+```
+
+Add teammates under the repo's **Settings → Collaborators and teams**.
+
+---
+
+## 3. Deploy to a Hugging Face Space (persistent live link)
+
+1. Create a new Space at huggingface.co, SDK: **Gradio**. Set visibility
+   to **Private** initially, since this is pre-launch.
+2. The Space is a git repo too. Add it as a second remote on the same
+   local project:
+   ```bash
+   git remote add space https://huggingface.co/spaces/nexendahq/<space-name>
+   git push space main
+   ```
+3. The Space rebuilds automatically on every push. `README.md`'s YAML
+   frontmatter at the top of the file already configures the title, SDK,
+   and app entry point, nothing extra to set in the HF UI.
+4. Once it's live, that URL works for anyone you invite, no one needs to
+   run anything locally to view or interact with it.
+
+Two placeholders in `README.md`'s frontmatter worth reviewing before
+going public: the `license` field (currently `apache-2.0`) and the
+"Read the paper" link (currently a placeholder pending Paper 1's
+publication).
+
+---
+
+## 4. Files in this folder
+
+| File | Purpose |
+|---|---|
+| `app.py` | The full Gradio app, both theorem panels, Nexenda theming |
+| `requirements.txt` | Pinned dependencies |
+| `README.md` | HF Space config (YAML frontmatter) + public-facing description |
+| `.gitignore` | Standard Python/Gradio ignores |
+| `HANDOFF.md` | This file |

README.md

@@ -1,14 +1,38 @@
 ---
-title: Council Ai Theorem Explorer
-emoji: 🔥
-colorFrom: blue
-colorTo: pink
+title: Council AI Theorem Explorer
+emoji: 🪶
+colorFrom: yellow
+colorTo: gray
 sdk: gradio
-sdk_version: 6.27.0
-python_version: '3.12'
+sdk_version: 6.24.0
 app_file: app.py
 pinned: false
-short_description: Nexenda council-ai-theorem-explorer
+license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Council AI — Theorem Explorer
+
+An interactive companion to *Council AI: Toward Deliberative Artificial Intelligence*
+(Michael Jidael, Udochukwu Nwokoma, Benjamin Ogbonna, et al., Nexenda, 2026).
+
+This Space implements exactly two things, both taken directly from the paper:
+
+- **Theorem 1 (Deliberation Convergence)** — the council state sequence converges
+  exponentially to a fixed point under a contractive deliberation operator.
+- **Theorem 2 (Multi-Expert Safety Bound)** — the probability of a catastrophic
+  error is bounded by `p·ρ^(k−1)` (or `p^k` in the alternate regime), where `p` is
+  individual expert error rate, `ρ` is inter-expert error correlation, and `k` is
+  the number of experts required for high-confidence agreement.
+
+Every number in the app is computed live from these formulas. Nothing here runs a
+trained model, and the app does not reference any product name, expert-cluster
+name, or internal architecture name beyond what appears in the published paper.
+
+Read the paper: *(link once published)*
+
+## Running locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```

app.py

@@ -0,0 +1,409 @@
+"""
+Council AI — Theorem Explorer
+------------------------------
+Interactive companion to "Council AI: Toward Deliberative Artificial Intelligence"
+(Michael Jidael, Udochukwu Nwokoma, Benjamin Ogbonna, et al., Nexenda, 2026).
+
+Implements exactly two things, both taken directly from the paper's proofs:
+
+  Theorem 1 (Deliberation Convergence):
+      ||H(t) - H*||_F <= gamma^t * ||H(0) - H*||_F
+
+  Theorem 2 (Multi-Expert Safety Bound):
+      P(catastrophic error) <= p * rho^(k-1)   if p <= rho
+      P(catastrophic error) <= p^k             if p >  rho
+
+No proprietary architecture names, expert-cluster names, or product names
+appear anywhere in this app or its outputs. Consistent with the naming
+constraints on Paper 1.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import gradio as gr
+
+# ---------------------------------------------------------------------------
+# Palettes — cool, not warm. Two full sets so theme toggling actually
+# re-renders the plots server-side, not just the CSS chrome.
+# ---------------------------------------------------------------------------
+def get_palette(is_dark: bool) -> dict:
+    if is_dark:
+        return dict(
+            bg="#0F1416", panel="#171D20", hairline="#232B2E",
+            text="#EAF2F2", muted="#93A6A8", faint="#5C6C6E",
+            accent="#45C9C2", green="#7FBF9E", red="#D97B67",
+        )
+    return dict(
+        bg="#F5F7F7", panel="#FFFFFF", hairline="#DCE4E4",
+        text="#14181A", muted="#4B5B5D", faint="#7C8B8D",
+        accent="#1E958D", green="#3E8A63", red="#B85440",
+    )
+
+
+def style_axes(fig, ax, pal):
+    """Apply a palette to a matplotlib figure/axes explicitly (never touches
+    global rcParams, so concurrent viewers on different themes don't clobber
+    each other's renders on a shared server)."""
+    fig.patch.set_facecolor(pal["bg"])
+    ax.set_facecolor(pal["panel"])
+    for spine in ax.spines.values():
+        spine.set_color(pal["hairline"])
+    ax.tick_params(colors=pal["faint"], labelsize=9)
+    ax.xaxis.label.set_color(pal["muted"])
+    ax.yaxis.label.set_color(pal["muted"])
+    ax.grid(alpha=0.35, color=pal["hairline"])
+
+
+# ---------------------------------------------------------------------------
+# Theorem 1 — Deliberation Convergence
+# ---------------------------------------------------------------------------
+def theorem1(gamma: float, rounds: int, d0: float, tau: float, is_dark: bool):
+    pal = get_palette(is_dark)
+    t = np.arange(0, rounds + 1)
+    dist = d0 * (gamma ** t)
+    agreement = np.clip(1 - dist / d0, 0, 1)
+
+    reached = np.argmax(agreement >= tau) if np.any(agreement >= tau) else None
+    consensus_round = int(reached) if reached is not None and agreement[reached] >= tau else None
+
+    fig, ax = plt.subplots(figsize=(7.5, 4.2))
+    style_axes(fig, ax, pal)
+    ax.axhline(tau, color=pal["red"], linestyle="--", linewidth=1.6, label="Consensus threshold τ")
+    ax.plot(t, agreement, color=pal["green"], linewidth=2.4, label="Agreement (1 − normalized distance)")
+    ax.plot(t, dist / d0, color=pal["accent"], linewidth=2.0, label="‖H(t)−H*‖ / ‖H(0)−H*‖  (Theorem 1)")
+
+    ax.set_xlabel("Deliberation round t")
+    ax.set_ylabel("Normalized value")
+    ax.set_ylim(-0.02, 1.05)
+    leg = ax.legend(loc="upper right", fontsize=8.5, framealpha=0.0)
+    for txt in leg.get_texts():
+        txt.set_color(pal["muted"])
+    fig.tight_layout()
+
+    stats = (
+        f"**Round consensus reached:** {'t = ' + str(consensus_round) if consensus_round is not None else 'not reached in given rounds'}\n\n"
+        f"**Residual disagreement at round T:** {dist[-1]:.4f}\n\n"
+        f"**Convergence rate:** γ = {gamma:.2f} (lower γ → faster convergence)"
+    )
+    return fig, stats
+
+
+DEFAULTS_T1 = (0.55, 12, 1.2, 0.95)
+
+
+def reset_theorem1(is_dark: bool):
+    fig, stats = theorem1(*DEFAULTS_T1, is_dark)
+    return (*DEFAULTS_T1, fig, stats)
+
+
+# ---------------------------------------------------------------------------
+# Theorem 2 — Multi-Expert Safety Bound
+# ---------------------------------------------------------------------------
+def safety_bound(p: float, rho: float, k: int) -> float:
+    if p <= rho:
+        return p * (rho ** (k - 1))
+    return p ** k
+
+
+def theorem2(p: float, rho: float, n: int, k: int, is_dark: bool):
+    pal = get_palette(is_dark)
+    k = min(k, n)
+    regime = "p ≤ ρ  →  bound = p·ρ^(k−1)" if p <= rho else "p > ρ  →  tighter bound = p^k"
+
+    ks = np.arange(1, n + 1)
+    bounds = np.array([safety_bound(p, rho, kk) for kk in ks])
+    current_bound = safety_bound(p, rho, k)
+
+    fig, ax = plt.subplots(figsize=(7.5, 4.2))
+    style_axes(fig, ax, pal)
+    ax.axhline(p, color=pal["red"], linestyle="--", linewidth=1.6, label=f"Single-model error rate (p = {p:.4f})")
+    ax.plot(ks, bounds, color=pal["accent"], linewidth=2.4, marker="o", markersize=3.5,
+            label="Council bound as k increases (Theorem 2)")
+    ax.scatter([k], [current_bound], color=pal["accent"], s=70, zorder=5,
+               edgecolor=pal["text"], linewidth=1)
+
+    ax.set_yscale("log")
+    ax.set_xlabel("Experts required for high-confidence agreement (k)")
+    ax.set_ylabel("P(catastrophic error), log scale")
+    leg = ax.legend(loc="upper right", fontsize=8.5, framealpha=0.0)
+    for txt in leg.get_texts():
+        txt.set_color(pal["muted"])
+    fig.tight_layout()
+
+    reduction = p / current_bound if current_bound > 0 else float("inf")
+    stats = (
+        f"**Regime:** {regime}\n\n"
+        f"**Single-model error rate (p):** {p:.4g}\n\n"
+        f"**Council bound at k={k}:** {current_bound:.4g}\n\n"
+        f"**Reduction factor:** {reduction:,.1f}×"
+    )
+    return fig, stats
+
+
+DEFAULTS_T2 = (0.01, 0.30, 10, 5)
+
+
+def reset_theorem2(is_dark: bool):
+    fig, stats = theorem2(*DEFAULTS_T2, is_dark)
+    return (*DEFAULTS_T2, fig, stats)
+
+
+# ---------------------------------------------------------------------------
+# Theme toggle — flips a shared state, restyles both plots server-side,
+# and (via the paired js= call below) flips the CSS chrome client-side
+# in the same click, so nothing waits on a round trip to feel instant.
+# ---------------------------------------------------------------------------
+def toggle_theme(is_dark, g, r, d0, tau, p, rho, n, k):
+    new_dark = not is_dark
+    fig1, s1 = theorem1(g, r, d0, tau, new_dark)
+    fig2, s2 = theorem2(p, rho, n, k, new_dark)
+    label = "🌙  Dark" if new_dark else "☀️  Light"
+    return new_dark, fig1, s1, fig2, s2, label
+
+
+TOGGLE_JS = """
+() => { document.body.classList.toggle('light-theme'); }
+"""
+
+# ---------------------------------------------------------------------------
+# CSS — cool palette (teal accent, not gold), richer button treatment,
+# and a light-theme override block driven by a body class toggled in JS.
+# ---------------------------------------------------------------------------
+CUSTOM_CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Instrument+Sans:ital,wght@0,400;0,500;0,600;0,700&family=Noto+Serif:ital,wght@0,500;1,400&display=swap');
+
+:root {
+    --bg: #0F1416;
+    --panel: #171D20;
+    --hairline: #232B2E;
+    --hairline-strong: #2E383B;
+    --text: #EAF2F2;
+    --muted: #93A6A8;
+    --faint: #5C6C6E;
+    --accent: #45C9C2;
+    --accent-soft: rgba(69,201,194,0.14);
+    --accent-dim: rgba(69,201,194,0.35);
+}
+body.light-theme {
+    --bg: #F5F7F7;
+    --panel: #FFFFFF;
+    --hairline: #DCE4E4;
+    --hairline-strong: #C7D1D1;
+    --text: #14181A;
+    --muted: #4B5B5D;
+    --faint: #7C8B8D;
+    --accent: #1E958D;
+    --accent-soft: rgba(30,149,141,0.10);
+    --accent-dim: rgba(30,149,141,0.30);
+}
+
+.gradio-container {
+    background-color: var(--bg) !important;
+    font-family: 'Instrument Sans', sans-serif !important;
+    transition: background-color 0.25s ease;
+}
+.gradio-container h1, .gradio-container h2, .gradio-container h3 {
+    font-family: 'Noto Serif', serif !important;
+    font-weight: 500 !important;
+    color: var(--text) !important;
+}
+.gradio-container, .gradio-container p, .gradio-container span, .gradio-container label {
+    color: var(--muted) !important;
+}
+.gradio-container blockquote {
+    font-family: 'Noto Serif', serif !important;
+    font-style: italic !important;
+    color: var(--text) !important;
+    border-left: 2px solid var(--accent) !important;
+    padding-left: 14px !important;
+    opacity: 0.92;
+}
+
+.gradio-container .block, .gradio-container .form {
+    background-color: var(--panel) !important;
+    border: 1px solid var(--hairline) !important;
+    border-radius: 8px !important;
+    transition: background-color 0.25s ease, border-color 0.25s ease;
+}
+
+.gradio-container .tab-nav {
+    border-bottom: 1px solid var(--hairline) !important;
+}
+.gradio-container .tab-nav button {
+    font-family: 'Instrument Sans', sans-serif !important;
+    color: var(--muted) !important;
+    transition: color 0.2s ease;
+}
+.gradio-container .tab-nav button.selected {
+    color: var(--accent) !important;
+    border-bottom-color: var(--accent) !important;
+}
+
+.gradio-container input[type=range] {
+    accent-color: var(--accent) !important;
+}
+
+.gradio-container .plot-container {
+    background-color: var(--panel) !important;
+    border-radius: 8px !important;
+}
+
+/* ---- richer buttons ---- */
+.gradio-container button.lg, .gradio-container button.sm, .gradio-container .gr-button {
+    border-radius: 8px !important;
+    font-weight: 600 !important;
+    letter-spacing: 0.01em;
+    transition: transform 0.12s ease, box-shadow 0.12s ease, border-color 0.15s ease, background-color 0.15s ease;
+    border-width: 1px !important;
+}
+.gradio-container button:hover {
+    transform: translateY(-1px);
+    box-shadow: 0 4px 14px rgba(0,0,0,0.18);
+}
+.gradio-container button:active {
+    transform: translateY(0);
+    box-shadow: inset 0 1px 4px rgba(0,0,0,0.25);
+}
+.gradio-container button:focus-visible {
+    outline: 2px solid var(--accent) !important;
+    outline-offset: 2px;
+}
+
+.gradio-container .secondary {
+    background-color: var(--panel) !important;
+    border: 1px solid var(--hairline-strong) !important;
+    color: var(--text) !important;
+}
+.gradio-container .secondary:hover {
+    border-color: var(--accent-dim) !important;
+    background-color: var(--accent-soft) !important;
+}
+
+#theme-toggle-btn {
+    background-color: var(--panel) !important;
+    border: 1px solid var(--hairline-strong) !important;
+    color: var(--text) !important;
+    border-radius: 999px !important;
+    padding: 6px 18px !important;
+    min-width: 0 !important;
+}
+#theme-toggle-btn:hover {
+    border-color: var(--accent) !important;
+    box-shadow: 0 0 0 3px var(--accent-soft) !important;
+}
+
+.gradio-container footer {
+    display: none !important;
+}
+"""
+
+HEAD_HTML = """
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+"""
+
+NEXENDA_THEME = gr.themes.Base(
+    primary_hue=gr.themes.colors.teal,
+    neutral_hue=gr.themes.colors.slate,
+    font=gr.themes.GoogleFont("Instrument Sans"),
+).set(
+    body_background_fill="#0F1416",
+    body_text_color="#93A6A8",
+    background_fill_primary="#171D20",
+    background_fill_secondary="#171D20",
+    border_color_primary="#2E383B",
+    block_background_fill="#171D20",
+    block_border_color="#232B2E",
+    block_title_text_color="#EAF2F2",
+    block_label_text_color="#93A6A8",
+    button_primary_background_fill="#45C9C2",
+    button_primary_background_fill_hover="#5AD6CF",
+    button_primary_text_color="#0F1416",
+    slider_color="#45C9C2",
+    color_accent="#45C9C2",
+    body_text_color_subdued="#5C6C6E",
+)
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+with gr.Blocks(title="Council AI — Theorem Explorer") as demo:
+    is_dark_state = gr.State(True)
+
+    with gr.Row():
+        with gr.Column(scale=5):
+            gr.Markdown(
+                "## Council AI — Theorem Explorer\n"
+                "Interactive companion to *Council AI: Toward Deliberative Artificial Intelligence* "
+                "(Nexenda, 2026). Both panels compute the paper's actual theorem statements live."
+            )
+        with gr.Column(scale=1, min_width=140):
+            theme_btn = gr.Button("🌙  Dark", elem_id="theme-toggle-btn", size="sm")
+
+    with gr.Tab("Theorem 1 — Deliberation Convergence"):
+        gr.Markdown(
+            "> *If the deliberation operator Φ is contractive with constant γ < 1, "
+            "the council state sequence converges exponentially to a unique fixed point: "
+            "‖H(t) − H\\*‖ ≤ γᵗ‖H(0) − H\\*‖.*"
+        )
+        with gr.Row():
+            with gr.Column(scale=1):
+                gamma_s = gr.Slider(0.1, 0.9, value=DEFAULTS_T1[0], step=0.01, label="Contraction rate γ")
+                rounds_s = gr.Slider(4, 30, value=DEFAULTS_T1[1], step=1, label="Deliberation rounds T")
+                d0_s = gr.Slider(0.2, 2.5, value=DEFAULTS_T1[2], step=0.05, label="Initial disagreement ‖H(0)−H*‖")
+                tau_s = gr.Slider(0.70, 0.99, value=DEFAULTS_T1[3], step=0.01, label="Consensus threshold τ")
+                reset1_btn = gr.Button("↺  Reset to defaults", size="sm", variant="secondary")
+                stats1 = gr.Markdown()
+            with gr.Column(scale=2):
+                plot1 = gr.Plot()
+
+        t1_inputs = [gamma_s, rounds_s, d0_s, tau_s, is_dark_state]
+        for ctrl in (gamma_s, rounds_s, d0_s, tau_s):
+            ctrl.change(theorem1, inputs=t1_inputs, outputs=[plot1, stats1])
+        reset1_btn.click(reset_theorem1, inputs=[is_dark_state],
+                          outputs=[gamma_s, rounds_s, d0_s, tau_s, plot1, stats1])
+        demo.load(theorem1, inputs=t1_inputs, outputs=[plot1, stats1])
+
+    with gr.Tab("Theorem 2 — Multi-Expert Safety Bound"):
+        gr.Markdown(
+            "> *With n experts, individual error rate p, pairwise error correlation ρ, "
+            "and k experts required for a high-confidence output: "
+            "P(catastrophic error) ≤ p·ρ^(k−1) when p ≤ ρ (the practically relevant regime); "
+            "the tighter bound pᵏ applies when p > ρ.*"
+        )
+        with gr.Row():
+            with gr.Column(scale=1):
+                p_s = gr.Slider(0.001, 0.15, value=DEFAULTS_T2[0], step=0.001, label="Individual error rate p")
+                rho_s = gr.Slider(0.0, 1.0, value=DEFAULTS_T2[1], step=0.01, label="Error correlation ρ")
+                n_s = gr.Slider(2, 15, value=DEFAULTS_T2[2], step=1, label="Total experts n")
+                k_s = gr.Slider(1, 15, value=DEFAULTS_T2[3], step=1, label="Agreement required k")
+                reset2_btn = gr.Button("↺  Reset to defaults", size="sm", variant="secondary")
+                stats2 = gr.Markdown()
+            with gr.Column(scale=2):
+                plot2 = gr.Plot()
+
+        t2_inputs = [p_s, rho_s, n_s, k_s, is_dark_state]
+        for ctrl in (p_s, rho_s, n_s, k_s):
+            ctrl.change(theorem2, inputs=t2_inputs, outputs=[plot2, stats2])
+        reset2_btn.click(reset_theorem2, inputs=[is_dark_state],
+                          outputs=[p_s, rho_s, n_s, k_s, plot2, stats2])
+        demo.load(theorem2, inputs=t2_inputs, outputs=[plot2, stats2])
+
+    # theme toggle: one click, two effects — CSS chrome flips instantly (js),
+    # and both plots re-render server-side in the matching palette (fn)
+    theme_btn.click(fn=None, inputs=None, outputs=None, js=TOGGLE_JS)
+    theme_btn.click(
+        toggle_theme,
+        inputs=[is_dark_state, gamma_s, rounds_s, d0_s, tau_s, p_s, rho_s, n_s, k_s],
+        outputs=[is_dark_state, plot1, stats1, plot2, stats2, theme_btn],
+    )
+
+    gr.Markdown(
+        "---\n"
+        "*This demo illustrates the mathematics proven in Theorems 1 and 2 of the Council AI paper. "
+        "It does not run any trained model. Numbers are user-selected inputs to the formal bounds, "
+        "not measurements from a deployed system.*"
+    )
+
+if __name__ == "__main__":
+    demo.launch(css=CUSTOM_CSS, theme=NEXENDA_THEME, head=HEAD_HTML)

index.html

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Gradio-Lite: Serverless Gradio Running Entirely in Your Browser</title>
+        <meta name="description" content="Gradio-Lite: Serverless Gradio Running Entirely in Your Browser">
+
+        <script type="module" crossorigin src="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.js"></script>
+        <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.css" />
+
+        <style>
+            html, body {
+                margin: 0;
+                padding: 0;
+                height: 100%;
+            }
+        </style>
+    </head>
+    <body>
+        <gradio-lite>
+            <gradio-file name="app.py" entrypoint>
+import gradio as gr
+
+from filters import as_gray
+
+def process(input_image):
+    output_image = as_gray(input_image)
+    return output_image
+
+demo = gr.Interface(
+    process,
+    "image",
+    "image",
+    examples=["lion.jpg", "logo.png"],
+)
+
+demo.launch()
+            </gradio-file>
+
+            <gradio-file name="filters.py">
+from skimage.color import rgb2gray
+
+def as_gray(image):
+    return rgb2gray(image)
+            </gradio-file>
+
+            <gradio-file name="lion.jpg" url="https://raw.githubusercontent.com/gradio-app/gradio/main/gradio/test_data/lion.jpg" />
+            <gradio-file name="logo.png" url="https://raw.githubusercontent.com/gradio-app/gradio/main/guides/assets/logo.png" />
+
+            <gradio-requirements>
+# Same syntax as requirements.txt
+scikit-image
+            </gradio-requirements>
+        </gradio-lite>
+    </body>
+</html>

pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "council-ai-theorem-explorer"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio==6.24.0",
+    "matplotlib>=3.8",
+    "numpy>=1.26",
+]

requirements.txt

@@ -0,0 +1,3 @@
+gradio==6.24.0
+numpy>=1.26
+matplotlib>=3.8