Add deterministic numeric-consistency checker (flags prose number slips)

app.py

@@ -26,7 +26,7 @@ for _p in (str(_ROOT), str(_MONOREPO)):
 import gradio as gr  # noqa: E402
 
 from shared import i18n  # noqa: E402  (visuals are local; only i18n is shared)
-from core import export, infer, render  # noqa: E402
+from core import export, infer, numcheck, render  # noqa: E402
 
 LOGO_PATH = _ROOT / "assets" / "logo.svg"
 _LOGO_SVG = LOGO_PATH.read_text(encoding="utf-8")
@@ -163,6 +163,11 @@ body.cf-forging #cf-header .cf-logo{ filter:drop-shadow(0 6px 22px rgba(255,138,
 .cf-pass{ background:rgba(74,222,128,.14); border-color:rgba(74,222,128,.5); color:#bbf7d0; }
 .cf-fail{ background:rgba(248,113,113,.13); border-color:rgba(248,113,113,.45); color:#fecaca; }
 .cf-demo{ font-style:italic; opacity:.85; margin-top:6px; font-size:.85rem; }
+.cf-numwarn{ margin-top:8px; padding:8px 12px; border-radius:10px; font-size:.84rem;
+  background:rgba(255,193,7,.10); border:1px solid rgba(255,193,7,.40); color:#ffe2a6; }
+.cf-numwarn b{ color:#ffd479; }
+.cf-numwarn ul{ margin:4px 0 0; padding-left:18px; }
+.cf-numwarn li{ margin:2px 0; }
 .cf-hint{ font-size:.82rem; opacity:.65; margin:4px 2px; }
 
 /* ---------- empty state (illustrated) ---------- */
@@ -254,7 +259,8 @@ def _empty_state(lang: str) -> str:
             '<p>' + i18n.t("cf.result_empty", lang) + '</p></div>')
 
 
-def _chips_html(flags: dict, lang: str, demo: bool, reason: str | None = None) -> str:
+def _chips_html(flags: dict, lang: str, demo: bool, reason: str | None = None,
+                num_warns: list | None = None) -> str:
     labels = {
         "schema": i18n.t("cf.q_schema", lang),
         "noleak": i18n.t("cf.q_noleak", lang),
@@ -271,6 +277,10 @@ def _chips_html(flags: dict, lang: str, demo: bool, reason: str | None = None) -
                      + '">' + mark + ' ' + labels[key] + '</span>')
     head = '<div class="cf-chips">' + "".join(chips) + '</div>'
     head += '<div class="cf-demo">⚠ ' + i18n.t("cf.disclaimer", lang) + '</div>'
+    if num_warns:
+        items = "".join("<li>" + w + "</li>" for w in num_warns)
+        head += ('<div class="cf-numwarn"><b>⚠ ' + i18n.t("cf.numcheck_title", lang)
+                 + '</b><ul>' + items + '</ul></div>')
     if demo:
         note = "cf.busy_note" if reason == "busy" else "cf.demo_note"
         head += '<div class="cf-demo">' + i18n.t(note, lang) + '</div>'
@@ -309,7 +319,9 @@ def forge(domain, topic, level, case_lang, theory, ui_lang_label):
         return
 
     flags = render.quality_flags(obj, res.get("errors", []), res.get("warnings", []))
-    chips = _chips_html(flags, lang, res.get("demo", False), res.get("reason"))
+    clang_obj = obj.get("language", "pt")
+    num_warns = [] if res.get("demo") else numcheck.check(obj, clang_obj)
+    chips = _chips_html(flags, lang, res.get("demo", False), res.get("reason"), num_warns)
     case_md = render.render_case(obj)
     note_md = render.render_note(obj)
     title = obj.get("title", "case")

core/numcheck.py

@@ -0,0 +1,122 @@
+"""Deterministic numeric-consistency checker (no LLM, instant, free).
+
+A ≤4B model generating freehand still slips on prose numbers (e.g. "gera R$375k/dia"
+when 5.000 rides × R$25 = R$125k). The teacher/code-audit fixes the TRAINING corpus,
+but the live student isn't audited at inference (that would 3× latency + burn ZeroGPU
+quota). So instead the Space runs this cheap pattern-checker over the generated case and
+**flags** likely inconsistencies for the author to verify — fitting the authoring/review
+model. It WARNS, never silently "fixes" prose.
+
+Conservative by design: only flags when it confidently extracts a relationship.
+"""
+
+from __future__ import annotations
+
+import re
+
+_UNIT = r"(?:corridas?|viagens?|unidades?|clientes?|pedidos?|atendimentos?|" \
+        r"rides?|trips?|units?|customers?|orders?)"
+_PERDAY = r"(?:por dia|/\s*dia|ao dia|di[aá]ri[ao]s?|per day|/\s*day|daily|por m[eê]s|/\s*m[eê]s|monthly|per month)"
+
+
+def _num(text: str) -> float | None:
+    """Parse a pt-BR/en number, honoring mil/milhão (and thousands/decimal seps)."""
+    t = text.lower()
+    mult = 1.0
+    if "milh" in t or "million" in t or "mi " in t:
+        mult = 1_000_000.0
+    elif "mil" in t or "thousand" in t:
+        mult = 1_000.0
+    m = re.search(r"\d[\d.,]*", t)
+    if not m:
+        return None
+    n = m.group(0)
+    if "," in n and "." in n:          # pt-BR: '.' thousands, ',' decimal
+        n = n.replace(".", "").replace(",", ".")
+    elif "," in n:                     # only comma → decimal sep
+        n = n.replace(",", ".")
+    else:                             # only dots → thousands sep (375.000)
+        if re.search(r"\.\d{3}\b", n):
+            n = n.replace(".", "")
+    try:
+        return float(n) * mult
+    except ValueError:
+        return None
+
+
+def _money(seg: str):
+    """First R$/$ amount in a fragment (carrying mil/milhão words after it)."""
+    m = re.search(r"(?:R\$|\$)\s*([\d.,]+(?:\s*(?:mil|milh[õo]es?|milh[ãa]o|million|thousand))?)", seg, re.I)
+    return _num(m.group(1)) if m else None
+
+
+def _close(a: float, b: float, tol: float = 0.05) -> bool:
+    if a is None or b is None:
+        return True
+    big = max(abs(a), abs(b), 1.0)
+    return abs(a - b) / big <= tol
+
+
+def _fmt(v: float) -> str:
+    v = round(v)
+    return f"{v:,.0f}".replace(",", ".")
+
+
+def _sentences(text: str) -> list[str]:
+    return re.split(r"(?<=[.;:])\s+|\n", text)
+
+
+def check(obj: dict, lang: str = "pt") -> list[str]:
+    """Return author-facing warnings about likely numeric inconsistencies."""
+    if not obj:
+        return []
+    c = obj.get("case") or {}
+    data = c.get("data") or []
+    text = " ".join([c.get("context", "")] + [str(d) for d in data]
+                    + [str(e.get("content", "")) for e in (c.get("exhibits") or [])])
+    warns: list[str] = []
+
+    # --- 1) daily/monthly revenue ≈ quantity × unit price -------------------
+    # quantity per period (prefer "média"/"total"/largest)
+    qtys = [_num(m.group(0)) for m in
+            re.finditer(rf"\d[\d.,]*\s*{_UNIT}[^.]*?{_PERDAY}", text, re.I)]
+    qtys = [q for q in qtys if q]
+    unit_price = None
+    mp = re.search(rf"(?:R\$|\$)\s*([\d.,]+)\s*(?:por|/|each|per)\s*{_UNIT}", text, re.I)
+    if mp:
+        unit_price = _num(mp.group(1))
+    # the revenue sentence: has "receita/gera/faturamento" + a per-period amount
+    rev = None
+    for s in _sentences(text):
+        if re.search(r"receita|fatur|gera|revenue|generat|bring", s, re.I) and re.search(_PERDAY, s, re.I):
+            rev = _money(s)
+            if rev:
+                break
+    if qtys and unit_price and rev:
+        q = max(qtys)
+        if not _close(q * unit_price, rev):
+            warns.append(
+                (f"receita ({_fmt(rev)}) não bate com {_fmt(q)} × {_fmt(unit_price)} = "
+                 f"{_fmt(q * unit_price)}" if lang == "pt" else
+                 f"revenue ({_fmt(rev)}) doesn't match {_fmt(q)} × {_fmt(unit_price)} = "
+                 f"{_fmt(q * unit_price)}"))
+
+    # --- 2) cost + profit ≈ price ------------------------------------------
+    def _find(label_re):
+        m = re.search(rf"(?:{label_re})[^.]*?(?:R\$|\$)\s*([\d.,]+)", text, re.I)
+        return _num(m.group(1)) if m else None
+
+    custo = _find(r"custo|cost")
+    lucro = _find(r"lucro|margem de lucro|profit")
+    preco = _find(r"pre[çc]o|price")
+    if custo and lucro and preco and not _close(custo + lucro, preco):
+        warns.append(
+            (f"custo ({_fmt(custo)}) + lucro ({_fmt(lucro)}) = {_fmt(custo + lucro)} "
+             f"≠ preço ({_fmt(preco)})" if lang == "pt" else
+             f"cost ({_fmt(custo)}) + profit ({_fmt(lucro)}) = {_fmt(custo + lucro)} "
+             f"≠ price ({_fmt(preco)})"))
+
+    return warns
+
+
+__all__ = ["check"]

pipeline/prompts.py

@@ -43,7 +43,7 @@ Responda APENAS com um objeto JSON, sem markdown, sem comentários, exatamente n
     "decision_point":"<a pergunta concreta que o protagonista PRECISA decidir>",
     "context":       "<organização, setor e atores envolvidos>",
     "data":          ["<fato quantitativo ilustrativo, em unidade consistente, SEM citação fabricada>", "... (>=3)"],
-    "exhibits":      [{"title": "<anexo opcional>", "content": "<tabela/quadro>"}],
+    "exhibits":      [{"title": "<anexo opcional>", "content": "<SÓ dados dados/premissas — sem coluna de projeção computada>"}],
     "alternatives":  ["<argumento p/ um caminho>", "<argumento p/ outro>", "... (>=2)"],
     "closing":       "<revisita o dilema NO ponto de decisão — NUNCA revela a escolha>",
     "references":    ["<referência APA>"]
@@ -86,14 +86,19 @@ Regras invioláveis:
    origem, use rótulo genérico e honesto ("dados internos", "estimativa da equipe"), sem
    relatório/ano/instituição fabricados. Em "data_sources", afirme que os números são
    ILUSTRATIVOS/FICTÍCIOS para fins de ensino.
-5. O PROTAGONISTA (com nome) aparece JÁ no "hook"/"context" — nunca surge só no fechamento.
+5. EXHIBITS = SÓ DADO DADO (valores atuais, premissas, elasticidades). NUNCA monte
+   tabela de PROJEÇÃO computada (proibido coluna tipo "impacto de X%", "faturamento
+   estimado", "demanda projetada" derivada de elasticidade). Se precisar mostrar uma
+   conta, faça UM exemplo trabalhado, passo a passo, na "analysis" da nota — nunca uma
+   tabela que encadeia cálculos. Sem linhas repetidas/padding.
+6. O PROTAGONISTA (com nome) aparece JÁ no "hook"/"context" — nunca surge só no fechamento.
    Use nomes variados e plausíveis (evite repetir sobrenomes).
-6. A "analysis" da nota, se mostrar contas, usa EXATAMENTE os números do caso e os resolve
+7. A "analysis" da nota, se mostrar contas, usa EXATAMENTE os números do caso e os resolve
    CORRETAMENTE. Confira a aritmética — o professor vai ensinar isso como gabarito.
-7. As "discussion_questions" cobrem os objetivos — pelo menos uma por objetivo.
-8. O caso é FICÇÃO PLAUSÍVEL e ORIGINAL: invente empresa, pessoas e números coerentes.
+8. As "discussion_questions" cobrem os objetivos — pelo menos uma por objetivo.
+9. O caso é FICÇÃO PLAUSÍVEL e ORIGINAL: invente empresa, pessoas e números coerentes.
    Não copie nenhuma organização real específica.
-9. Escreva todo o conteúdo em {lang_name}. Tom narrativo, concreto, sem moralizar."""
+10. Escreva todo o conteúdo em {lang_name}. Tom narrativo, concreto, sem moralizar."""
 
 
 _SEED_EXTRACTION = """\
@@ -223,5 +228,84 @@ def build_audit_prompt(pair_obj: dict) -> list[dict]:
     ]
 
 
+# ---------------------------------------------------------------------------
+# Code-sandbox numeric auditor (teacher writes Python; code does the arithmetic).
+# Two rounds: (1) write a script that recomputes derived numbers from the stated
+# inputs → execute in a tiny arithmetic-only sandbox → (2) rewrite the JSON to match.
+# ---------------------------------------------------------------------------
+
+_CODE_AUDIT_SYS = (
+    "Você é um editor quantitativo meticuloso. Você NUNCA faz aritmética de cabeça: "
+    "você escreve Python que recalcula os números a partir dos inputs declarados."
+)
+
+_CODE_FORMULAS = """\
+Relações-chave (use exatamente):
+- Elasticidade-preço e: uma variação de P% no preço gera (e*P)% na quantidade. Se o caso
+  declarar um "impacto na demanda" mas DER a elasticidade, RECALCULE o impacto da elasticidade.
+- Receita = preço x quantidade. Um corte de X% no preço multiplica a receita por
+  (1 - X/100) * (1 + variacao_quantidade). NUNCA esqueça o fator do corte de preço.
+- Payback (meses) = investimento_inicial / ganho_mensal, só se ganho_mensal > 0
+  (economia ou lucro extra; nunca sobre um custo que AUMENTA).
+- Percentuais/margens/somas/totais: recalcule com precisão."""
+
+
+def build_audit_script_prompt(pair_obj: dict) -> list[dict]:
+    """Round 1: teacher writes a Python script that recomputes the derived numbers."""
+    import json as _json
+    case_json = _json.dumps(pair_obj, ensure_ascii=False)
+    return [
+        {"role": "system", "content": _CODE_AUDIT_SYS},
+        {"role": "user", "content":
+            "Aqui está um caso de ensino em JSON. Identifique TODO número DERIVADO "
+            "(percentuais, payback, receita/demanda projetada, totais, margens) e escreva "
+            "um script Python que calcule o valor CORRETO de cada um a partir dos números "
+            "de input declarados.\n\n" + _CODE_FORMULAS + "\n\n"
+            "Defina `result` = dict {rótulo curto -> valor numérico correto}. Use SOMENTE "
+            "aritmética e números literais — sem imports, sem I/O, sem loops. Responda "
+            "APENAS com o bloco de código Python.\n\nCASO:\n" + case_json},
+    ]
+
+
+def build_numeric_rewrite_prompt(pair_obj: dict, computed: dict) -> list[dict]:
+    """Round 2: rewrite the JSON so every number matches the code-computed values."""
+    import json as _json
+    return [
+        {"role": "system", "content":
+            "Você corrige números em casos de ensino. Responde só com o JSON inteiro."},
+        {"role": "user", "content":
+            "Reescreva o JSON do caso para que TODO número fique consistente com estes "
+            "valores corretos já computados:\n" + _json.dumps(computed, ensure_ascii=False)
+            + "\n\nMude só os números errados; preserve a prosa e a estrutura; tabela e texto "
+            "usam o MESMO valor. Responda APENAS com o JSON.\n\nCASO:\n"
+            + _json.dumps(pair_obj, ensure_ascii=False)},
+    ]
+
+
+def extract_code(text: str) -> str:
+    """Pull the Python block out of a round-1 reply (tolerates fences/<think>)."""
+    import re
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
+    m = re.search(r"```(?:python)?\s*(.*?)```", text, flags=re.DOTALL)
+    return (m.group(1) if m else text).strip()
+
+
+def run_numeric_sandbox(code: str) -> dict:
+    """Execute the teacher's arithmetic-only script; return its `result` dict.
+
+    Restricted: no imports and only a handful of safe builtins, so the executed
+    code can do arithmetic but nothing else.
+    """
+    safe = {"round": round, "abs": abs, "min": min, "max": max,
+            "sum": sum, "len": len, "float": float, "int": int}
+    glb = {"__builtins__": safe}
+    loc: dict = {}
+    exec(code, glb, loc)  # noqa: S102 — sandboxed arithmetic only
+    res = loc.get("result")
+    return res if isinstance(res, dict) else {}
+
+
 __all__ = ["Seed", "build_generation_prompt", "build_minimal_prompt",
-           "build_seed_extraction_prompt", "build_audit_prompt"]
+           "build_seed_extraction_prompt", "build_audit_prompt",
+           "build_audit_script_prompt", "build_numeric_rewrite_prompt",
+           "extract_code", "run_numeric_sandbox"]

shared/i18n.py

@@ -107,6 +107,7 @@ _T = {
         "en": "⚡ The GPU is busy or the free quota was reached — showing a sample meanwhile. Try forging again in a moment.",
         "pt": "⚡ A GPU está ocupada ou a cota grátis acabou — exibindo uma amostra. Tente forjar de novo em instantes.",
     },
+    "cf.numcheck_title": {"en": "Numbers to double-check", "pt": "Números pra conferir"},
     "cf.disclaimer": {
         "en": "Figures are illustrative/fictional — verify them before classroom use.",
         "pt": "Números são ilustrativos/fictícios — confira antes de usar em aula.",