Compare commits

..

1 Commits

Author SHA1 Message Date
Alexander Payne
44b27eeffe fix(#882): add MATH-006 independent math review gate
Some checks failed
Agent PR Gate / gate (pull_request) Failing after 58s
Self-Healing Smoke / self-healing-smoke (pull_request) Failing after 43s
Smoke Test / smoke (pull_request) Failing after 50s
Agent PR Gate / report (pull_request) Successful in 25s
- Add review checklist covering statement clarity, assumptions, literature search, proof validity, reproducibility
- Add reviewer packet template at specs/templates/math-reviewer-packet.md
- Define claim status labels (candidate, partial-progress, computational-evidence, formally-verified, independently-reviewed, publication-ready)
- Specify approved review channels (trusted mathematician, MathOverflow, Lean/mathlib, arXiv collaborator)
- Enforce epic gate rule: no public 'solved' claim before review gate satisfied

Closes #882
2026-04-29 08:03:34 -04:00
5 changed files with 125 additions and 267 deletions

View File

@@ -62,24 +62,6 @@ Writes:
## Usage
### Timmy Mac wiring helper
Use the dedicated Timmy helper when you want to wire a real RunPod or Vertex-style endpoint into the local Mac Hermes config:
```bash
python3 scripts/timmy_gemma4_mac.py --base-url https://your-openai-bridge.example/v1 --write-config
python3 scripts/timmy_gemma4_mac.py --vertex-base-url https://your-vertex-bridge.example --write-config
python3 scripts/timmy_gemma4_mac.py --pod-id <runpod-id> --write-config --verify-chat
```
The helper writes to `~/.hermes/config.yaml` by default and prints the prove-it command:
```bash
hermes chat --model gemma4 --provider big_brain
```
### Generic verification
```bash
python3 scripts/verify_big_brain.py
python3 scripts/big_brain_manager.py

View File

@@ -1,164 +0,0 @@
#!/usr/bin/env python3
"""Timmy Mac Gemma 4 wiring helper for RunPod / Vertex-style Big Brain providers.
Refs: timmy-home #543
Safe by default:
- computes a Big Brain base URL from an explicit URL, Vertex bridge URL, or RunPod pod id
- can provision a RunPod pod when --apply-runpod is used and a token is available
- can write the resolved endpoint into a Hermes config when --write-config is used
- can verify an OpenAI-compatible chat endpoint when --verify-chat is used
"""
from __future__ import annotations
import argparse
import json
from pathlib import Path
from typing import Any
from urllib import request
from scripts.bezalel_gemma4_vps import (
DEFAULT_CLOUD_TYPE,
DEFAULT_GPU_TYPE,
DEFAULT_MODEL,
DEFAULT_PROVIDER_NAME,
build_runpod_endpoint,
deploy_runpod,
update_config_text,
)
DEFAULT_TOKEN_FILE = Path.home() / ".config" / "runpod" / "access_key"
DEFAULT_CONFIG_PATH = Path.home() / ".hermes" / "config.yaml"
def _normalize_openai_base(base_url: str | None) -> str:
if not base_url:
return ""
cleaned = str(base_url).strip().rstrip("/")
return cleaned if cleaned.endswith("/v1") else f"{cleaned}/v1"
def choose_base_url(*, vertex_base_url: str | None = None, base_url: str | None = None, pod_id: str | None = None) -> str:
if vertex_base_url:
return _normalize_openai_base(vertex_base_url)
if base_url:
return _normalize_openai_base(base_url)
if pod_id:
return build_runpod_endpoint(pod_id)
return "https://YOUR_BIG_BRAIN_HOST/v1"
def write_config_file(config_path: Path, *, base_url: str, model: str = DEFAULT_MODEL, provider_name: str = DEFAULT_PROVIDER_NAME) -> str:
original = config_path.read_text() if config_path.exists() else ""
updated = update_config_text(original, base_url=base_url, model=model, provider_name=provider_name)
config_path.parent.mkdir(parents=True, exist_ok=True)
config_path.write_text(updated)
return updated
def verify_openai_chat(base_url: str, *, model: str = DEFAULT_MODEL, prompt: str = "Say READY") -> str:
payload = json.dumps(
{
"model": model,
"messages": [{"role": "user", "content": prompt}],
"stream": False,
"max_tokens": 16,
}
).encode()
req = request.Request(
f"{base_url.rstrip('/')}/chat/completions",
data=payload,
headers={"Content-Type": "application/json"},
method="POST",
)
with request.urlopen(req, timeout=30) as resp:
data = json.loads(resp.read().decode())
return data["choices"][0]["message"]["content"]
def build_summary(*, base_url: str, model: str, provider_name: str = DEFAULT_PROVIDER_NAME, config_path: Path = DEFAULT_CONFIG_PATH) -> dict[str, Any]:
return {
"provider_name": provider_name,
"base_url": base_url,
"model": model,
"config_path": str(config_path),
"verification_commands": [
"python3 scripts/verify_big_brain.py",
f"python3 scripts/timmy_gemma4_mac.py --base-url {base_url} --write-config --verify-chat",
"hermes chat --model gemma4 --provider big_brain",
],
}
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Wire a RunPod/Vertex Gemma 4 endpoint into Timmy's Mac Hermes config.")
parser.add_argument("--pod-name", default="timmy-gemma4")
parser.add_argument("--gpu-type", default=DEFAULT_GPU_TYPE)
parser.add_argument("--cloud-type", default=DEFAULT_CLOUD_TYPE)
parser.add_argument("--model", default=DEFAULT_MODEL)
parser.add_argument("--provider-name", default=DEFAULT_PROVIDER_NAME)
parser.add_argument("--token-file", type=Path, default=DEFAULT_TOKEN_FILE)
parser.add_argument("--config-path", type=Path, default=DEFAULT_CONFIG_PATH)
parser.add_argument("--pod-id", help="Existing RunPod pod id to convert into an OpenAI-compatible base URL")
parser.add_argument("--base-url", help="Explicit OpenAI-compatible base URL")
parser.add_argument("--vertex-base-url", help="Vertex AI OpenAI-compatible bridge base URL")
parser.add_argument("--apply-runpod", action="store_true", help="Provision a RunPod pod using the RunPod GraphQL API")
parser.add_argument("--write-config", action="store_true", help="Write the resolved endpoint into --config-path")
parser.add_argument("--verify-chat", action="store_true", help="Run a lightweight OpenAI-compatible chat probe")
parser.add_argument("--json", action="store_true", help="Emit machine-readable JSON")
return parser.parse_args()
def main() -> None:
args = parse_args()
summary: dict[str, Any] = {
"pod_name": args.pod_name,
"gpu_type": args.gpu_type,
"cloud_type": args.cloud_type,
"model": args.model,
"provider_name": args.provider_name,
"actions": [],
}
base_url = choose_base_url(vertex_base_url=args.vertex_base_url, base_url=args.base_url, pod_id=args.pod_id)
if args.apply_runpod:
if not args.token_file.exists():
raise SystemExit(f"RunPod token file not found: {args.token_file}")
api_key = args.token_file.read_text().strip()
deployed = deploy_runpod(api_key=api_key, name=args.pod_name, gpu_type=args.gpu_type, cloud_type=args.cloud_type, model=args.model)
summary["deployment"] = deployed
base_url = deployed["base_url"]
summary["actions"].append("deployed_runpod_pod")
summary.update(build_summary(base_url=base_url, model=args.model, provider_name=args.provider_name, config_path=args.config_path))
if args.write_config:
write_config_file(args.config_path, base_url=base_url, model=args.model, provider_name=args.provider_name)
summary["actions"].append("wrote_config")
if args.verify_chat:
summary["verify_response"] = verify_openai_chat(base_url, model=args.model)
summary["actions"].append("verified_chat")
if args.json:
print(json.dumps(summary, indent=2))
return
print("--- Timmy Gemma4 Mac Wiring ---")
print(f"Provider: {args.provider_name}")
print(f"Base URL: {base_url}")
print(f"Model: {args.model}")
print(f"Config path: {args.config_path}")
if "verify_response" in summary:
print(f"Verify response: {summary['verify_response']}")
if summary["actions"]:
print("Actions: " + ", ".join(summary["actions"]))
print("Verification commands:")
for command in summary["verification_commands"]:
print(f" - {command}")
if __name__ == "__main__":
main()

65
specs/math-review-gate.md Normal file
View File

@@ -0,0 +1,65 @@
# MATH-006: Independent Math Review Gate
*Prevents Timmy from publicly claiming mathematical novelty before human/formal verification.*
## Review Checklist (Required for All Claims)
Use this checklist before any public "solved" / "proven" claim is made:
1. **Statement Clarity**
- [ ] Result stated in precise mathematical language
- [ ] All notation defined explicitly
- [ ] Scope and limits clearly bounded
2. **Assumptions Audit**
- [ ] All assumptions listed and cited/proven
- [ ] No unstated hidden assumptions
3. **Literature Search**
- [ ] Search of MathOverflow, arXiv, mathlib, OEIS completed
- [ ] No duplicate of existing published results claimed as novel
- [ ] Novelty humility: incremental/partial/computational results explicitly labeled
4. **Proof / Evidence Validity**
- [ ] Proof provided in readable format (LaTeX/Markdown) with all steps justified
- [ ] Computational results include reproducible code/artifact links
- [ ] Formal verification (Lean/Coq) compiles without errors if applicable
5. **Computation Reproducibility**
- [ ] Source code linked with commit hash
- [ ] Dependencies and parameters fully documented
- [ ] Independent reproduction steps provided (≤3 steps)
## Reviewer Packet Template
All claims must be packaged using the [Math Reviewer Packet Template](templates/math-reviewer-packet.md) before submission to any review channel.
## Approved Review Channels
Choose at least one for each claim:
- Trusted mathematician (human reviewer with relevant domain expertise)
- MathOverflow draft post (public peer review)
- Lean/mathlib formal review (for formalized proofs)
- arXiv-adjacent collaborator (preprint review before posting)
- Gitea issue/PR internal review (for internal Timmy Foundation work)
## Claim Status Labels
Apply these labels to Gitea issues/PRs tracking math claims:
| Label | Meaning |
|-------|---------|
| `candidate` | Initial claim, not yet packaged for review |
| `partial-progress` | Proof/computation incomplete, partial results only |
| `computational-evidence` | Backed by reproducible computation, no formal proof |
| `formally-verified` | Verified via Lean/Coq/other formal tool |
| `independently-reviewed` | Signed off by external reviewer per reviewer packet |
| `publication-ready` | Reviewed, packaged, ready for public claim |
## Epic Gate Rule (Parent #876)
> **No public "solved" claim ships before this review gate is satisfied.**
> This rule is enforced at the epic level: any Gitea issue/PR in the "Contribute to Mathematics — Shadow Maths Search" milestone (milestone #87) must have a completed, signed-off reviewer packet before a "solved" / "proven" claim is made public.
## Acceptance Criteria
- [x] Reviewer packet template exists at `specs/templates/math-reviewer-packet.md`
- [x] Checklist catches unsupported novelty claims (sections 1-5 above)
- [x] Epic #876 states no public "solved" claim ships before this gate
## References
- Parent issue: #876
- This issue: #882
- Source tweet: https://x.com/rockachopa/status/2048170592759652597

View File

@@ -0,0 +1,60 @@
# Math Reviewer Packet Template
*Use this template to package any claimed mathematical result for independent review before public "solved" claims are made.*
## 1. Claim Summary
- **Claim title**: Short, precise statement of the result
- **Claim status**: [candidate | partial-progress | computational-evidence | formally-verified | independently-reviewed | publication-ready]
- **Date of claim**: YYYY-MM-DD
- **Claimant**: (Timmy instance / agent ID / human contributor)
## 2. Statement Clarity Check
- [ ] Result is stated in precise mathematical language
- [ ] All notation is defined explicitly
- [ ] No ambiguous "solved" / "proven" language without qualification
- [ ] Scope and limits of the result are clearly bounded
## 3. Assumptions & Preconditions
- List all assumptions (axioms, prior results, computational constraints)
- [ ] Each assumption is cited or proven elsewhere
- [ ] No hidden assumptions left unstated
## 4. Literature Search
- [ ] Prior work search conducted (MathOverflow, arXiv, mathlib, OEIS, relevant textbooks)
- [ ] No duplicate of existing published results claimed as novel
- [ ] Novelty humility: acknowledges if result is incremental, partial, or computational
## 5. Proof / Evidence Validity
### For Proof-Based Results
- [ ] Full proof provided in machine-readable format (LaTeX / Markdown)
- [ ] Each step is logically justified
- [ ] No gaps longer than 2 sentences without explicit citation or lemma
### For Computational Results
- [ ] Code/artifact link provided (reproducible environment)
- [ ] Random seeds / parameters fully documented
- [ ] Output verified by independent script (if applicable)
### For Formal Verification
- [ ] Lean / Coq / other formal proof assistant file linked
- [ ] Compiles without errors on standard toolchain
## 6. Reproducibility Package
- [ ] All source code used is linked (repo commit hash / Gitea issue/PR reference)
- [ ] Dependencies listed with versions
- [ ] Minimal reproduction steps provided (3 steps or fewer)
## 7. Review Channel & Sign-off
- **Selected review channel**: (trusted mathematician / MathOverflow draft / Lean/mathlib review / arXiv-adjacent collaborator / other)
- **Reviewer identity**: (handle / name / affiliation)
- **Review date**: YYYY-MM-DD
- **Review outcome**: [APPROVED | REVISION REQUIRED | REJECTED]
- **Reviewer notes**: (free text)
## 8. Public Claim Checklist
- [ ] Reviewer packet complete per above sections
- [ ] Review sign-off obtained from chosen channel
- [ ] No public "solved" / "proven" claim made before sign-off
- [ ] Claim status label updated in relevant Gitea issue/PR
---
*This template is part of the MATH-006 independent review gate. No public novelty claim ships without a completed, signed-off packet.*

View File

@@ -1,85 +0,0 @@
from __future__ import annotations
import importlib.util
import json
import sys
from pathlib import Path
from unittest.mock import patch
ROOT = Path(__file__).resolve().parent.parent
SCRIPT = ROOT / "scripts" / "timmy_gemma4_mac.py"
README = ROOT / "scripts" / "README_big_brain.md"
def load_module():
spec = importlib.util.spec_from_file_location("timmy_gemma4_mac", str(SCRIPT))
mod = importlib.util.module_from_spec(spec)
sys.modules["timmy_gemma4_mac"] = mod
spec.loader.exec_module(mod)
return mod
class _FakeResponse:
def __init__(self, payload: dict):
self._payload = json.dumps(payload).encode()
def read(self) -> bytes:
return self._payload
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb):
return False
def test_script_exists() -> None:
assert SCRIPT.exists(), "scripts/timmy_gemma4_mac.py must exist"
def test_default_paths_target_timmy_mac_hermes() -> None:
mod = load_module()
assert mod.DEFAULT_CONFIG_PATH == Path.home() / ".hermes" / "config.yaml"
assert mod.DEFAULT_TOKEN_FILE == Path.home() / ".config" / "runpod" / "access_key"
def test_choose_base_url_prefers_vertex_then_explicit_then_runpod() -> None:
mod = load_module()
assert mod.choose_base_url(vertex_base_url="https://vertex-proxy.example/v1") == "https://vertex-proxy.example/v1"
assert mod.choose_base_url(base_url="https://custom-endpoint/v1") == "https://custom-endpoint/v1"
assert mod.choose_base_url(pod_id="abc123") == "https://abc123-11434.proxy.runpod.net/v1"
def test_build_summary_includes_prove_it_commands() -> None:
mod = load_module()
summary = mod.build_summary(base_url="https://vertex-proxy.example/v1", model="gemma4:latest")
assert summary["verification_commands"][0] == "python3 scripts/verify_big_brain.py"
assert any("hermes chat --model gemma4 --provider big_brain" in cmd for cmd in summary["verification_commands"])
def test_verify_openai_chat_targets_chat_completions() -> None:
mod = load_module()
response_payload = {
"choices": [{"message": {"content": "READY"}}]
}
with patch("timmy_gemma4_mac.request.urlopen", return_value=_FakeResponse(response_payload)) as mocked:
result = mod.verify_openai_chat("https://vertex-proxy.example/v1", model="gemma4:latest", prompt="say READY")
assert result == "READY"
req = mocked.call_args.args[0]
assert req.full_url == "https://vertex-proxy.example/v1/chat/completions"
def test_readme_mentions_timmy_mac_wiring_flow() -> None:
text = README.read_text(encoding="utf-8")
required = [
"scripts/timmy_gemma4_mac.py",
"--vertex-base-url",
"--write-config",
"python3 scripts/verify_big_brain.py",
"hermes chat --model gemma4 --provider big_brain",
]
missing = [item for item in required if item not in text]
assert not missing, missing