deeperthawt 1.0.0__py3-none-any.whl

deeperthawt/__init__.py

@@ -0,0 +1,140 @@
+"""
+DeeperThawt — deterministic verifiable reasoning engine.
+
+A packaged product exposing the VRE/hybrid-agi harness as one clean API.
+
+CAPABILITY ARCHITECTURE (secret-ingredients stay remote):
+  - LOCAL, deterministic, non-secret solvers (shipped with the package):
+      * Symbolic math oracle    (deterministic SymPy solver, no LLM guessing)
+      * Logic + syllogism inference
+      * Known-theorem / science / python knowledge retrieval (cited)
+  - REMOTE, secret-engine (never shipped locally): the semantic engine
+    (gematria projection + fixed-parameter attention + trained latent adapter
+    + tuned weights). Exposed to the local client ONLY through a thin,
+    numeric-only RPC to the remote server (/assess). The method and weights
+    never leave the remote server — a local buyer sees the contract, not the
+    pearl.
+
+Dual-licensed: AGPL-3.0 open core + commercial license for proprietary embedding.
+"""
+
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+import urllib.request as _urlreq
+import urllib.error as _urlerr
+import json as _json
+from typing import Any, Dict
+
+# --------------------------------------------------------------------------- #
+# LOCAL capability solvers (deterministic, non-secret) — vendored from the
+# hybrid-agi core. These are the cited/bounded solvers, safe to ship.
+# --------------------------------------------------------------------------- #
+try:
+    from ._backends import (  # type: ignore
+        MathematicalOracle,
+        evaluate_inference,
+        verify_logic_argument,
+        parse_known_theorem,
+        lookup_science_fact_combined,
+        lookup_python_knowledge_combined,
+    )
+    _HAS_LOCAL = True
+except Exception as _e:  # pragma: no cover
+    _HAS_LOCAL = False
+    _LOCAL_ERR = str(_e)
+
+
+_DEFAULT_API = "https://mcp-token-saver-pro.fly.dev"
+
+
+class _SemanticRemote:
+    """Thin numeric-only client to the remote semantic engine.
+
+    The secret method (gematria projection, attention, adapter weights) lives
+    ONLY on the remote server. This client sends de-identified rows and
+    receives a number back — it never carries the engine, the method, or the
+    weights. If `requests` is unavailable we fall back to urllib.
+    """
+
+    def __init__(self, base: str = "", api_key: str = ""):
+        self.base = (base or _os.environ.get("DEEPER_THAWT_API", _DEFAULT_API)).rstrip("/")
+        self.api_key = api_key or _os.environ.get("DEEPER_THAWT_API_KEY", "")
+
+    def assess(self, rows: list, tier: str = "content") -> Dict[str, Any]:
+        """POST de-identified rows to the remote engine; return numeric result."""
+        body = _json.dumps({"tier": tier, "messages": rows}).encode()
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        req = _urlreq.Request(self.base + "/assess", data=body, headers=headers, method="POST")
+        try:
+            with _urlreq.urlopen(req, timeout=60) as r:
+                return _json.loads(r.read().decode())  # {"result": {...}}
+        except _urlerr.HTTPError as e:
+            return {"error": f"http_{e.code}", "detail": e.read().decode()[:200]}
+
+
+# --------------------------------------------------------------------------- #
+# Public product surface
+# --------------------------------------------------------------------------- #
+
+class DeeperThawt:
+    """The DeeperThawt engine: local deterministic solvers + remote semantic UI."""
+
+    def __init__(self, api_base: str = "", api_key: str = ""):
+        self.math = MathematicalOracle()
+        self._remote = _SemanticRemote(api_base, api_key)
+
+    # -- math (local, deterministic) -----------------------------------------
+    def solve_math(self, text: str) -> dict:
+        return self.math.evaluate(text)
+
+    # -- logic (local, deterministic) ----------------------------------------
+    def verify_logic(self, premises, conclusion) -> dict:
+        return verify_logic_argument(list(premises), conclusion)
+
+    # -- knowledge (local, cited retrieval) ----------------------------------
+    def knowledge_math_theorem(self, text: str) -> dict:
+        return parse_known_theorem(text) or {"known": False, "reason": "no known theorem matched"}
+
+    def knowledge_science(self, text: str) -> dict:
+        return lookup_science_fact_combined(text)
+
+    def knowledge_python(self, text: str) -> dict:
+        return lookup_python_knowledge_combined(text)
+
+    # -- semantic token intelligence (REMOTE, numeric-only) ------------------
+    def semantic_assess(self, messages: list, tier: str = "content") -> dict:
+        """Ask the remote semantic engine to assess token redundancy.
+
+        Returns ONLY numbers (baseline, exact dedupe, semantic additional
+        savings). The engine + weights stay on the remote server; this ships
+        nothing secret.
+        """
+        return self._remote.assess(messages, tier=tier)
+
+
+def version() -> str:
+    return "1.0.0"
+
+
+def api_status() -> str:
+    """Remote semantic engine health (numeric/opaque)."""
+    try:
+        with _urlreq.urlopen(_DEFAULT_API + "/healthz", timeout=15) as r:
+            return r.read().decode()
+    except Exception as e:  # pragma: no cover
+        return f"unreachable: {e}"
+
+
+_has_remote = _HAS_LOCAL
+
+
+__all__ = [
+    "DeeperThawt", "version", "api_status",
+    "MathematicalOracle", "evaluate_inference", "verify_logic_argument",
+    "parse_known_theorem", "lookup_science_fact_combined",
+    "lookup_python_knowledge_combined",
+]

deeperthawt/_backends.py

@@ -0,0 +1,46 @@
+"""
+DeeperThawt vendored capability backends — LOCAL, deterministic, NON-SECRET.
+
+This module bundles the minimal, self-contained deterministic solvers from the
+VRE/hybrid-agi harness so the pip package stands alone:
+
+  - MathematicalOracle + fib helper (deterministic SymPy math solver)
+  - logic_engine inference + syllogism (propositional + category logic)
+  - known_theorems / science / python knowledge retrieval (cited)
+
+SECRET-INGREDIENT POLICY: the semantic engine (gematria projection +
+fixed-parameter attention + trained latent adapter + tuned weights) lives ONLY
+on the remote DeeperThawt server and is intentionally NOT vendored here. The
+local package ships only a numeric-only RPC client to that server.
+
+AGPL-3.0 open core; commercial license for proprietary embedding.
+"""
+
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+
+# Make the vendored deterministic core importable by absolute module names.
+_HARNESS = _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "_vendored")
+if _HARNESS not in _sys.path:
+    _sys.path.insert(0, _HARNESS)
+
+# Re-export the real local solvers (NO semantic engine — it stays remote).
+from ._backends_core import (  # noqa: E402
+    MathematicalOracle,
+    evaluate_inference,
+    verify_logic_argument,
+    parse_known_theorem,
+    lookup_science_fact_combined,
+    lookup_python_knowledge_combined,
+)
+
+# Safety: if anyone tries to vendored-import the semantic engine here it must
+# not be present. GematriaTokenizer / SemanticSpace / adapter are NOT exported.
+
+__all__ = [
+    "MathematicalOracle", "evaluate_inference", "verify_logic_argument",
+    "parse_known_theorem", "lookup_science_fact_combined",
+    "lookup_python_knowledge_combined",
+]

deeperthawt/_backends_core.py

@@ -0,0 +1,38 @@
+"""
+DeeperThawt vendored core — re-exports the real LOCAL deterministic solvers.
+
+The `_vendored` directory holds vendored copies of the hybrid-agi/VRE core
+modules (AGPL-3.0 open core) — but ONLY the deterministic, non-secret solvers.
+The semantic engine (gematria projection / attention / adapter / weights) is
+deliberately NOT vendored: it lives on the remote DeeperThawt server and is
+reached through a numeric-only RPC client.
+"""
+
+from __future__ import annotations
+
+import os as _os
+import sys as _sys
+
+_V = _os.path.join(_os.path.dirname(_os.path.abspath(__file__)), "_vendored")
+if _V not in _sys.path:
+    _sys.path.insert(0, _V)
+
+# --- math solver (local, deterministic) ---
+from math_solver_oracle import MathematicalOracle  # noqa: E402
+
+# --- logic engine (local, deterministic) ---
+from logic_engine import (  # noqa: E402
+    evaluate_inference,
+    verify_logic_argument,
+)
+
+# --- knowledge (local, cited retrieval) ---
+from known_theorems import parse_known_theorem  # noqa: E402
+from scientific_knowledge import lookup_science_fact_combined  # noqa: E402
+from python_knowledge import lookup_python_knowledge_combined  # noqa: E402
+
+__all__ = [
+    "MathematicalOracle", "evaluate_inference", "verify_logic_argument",
+    "parse_known_theorem", "lookup_science_fact_combined",
+    "lookup_python_knowledge_combined",
+]

deeperthawt/_vendored/known_theorems.py

@@ -0,0 +1,294 @@
+#!/usr/bin/env python3
+"""Curated catalog of famous mathematical theorems.
+
+This is NOT a proof generator. For a small set of well-known theorems it
+returns an honest "known theorem, not generated" record: a canonical formal
+statement and a citation. Claims not in the catalog fall through to abstention.
+This lets the system acknowledge a famous theorem is TRUE without pretending
+to have derived it — a bounded, honest capability.
+"""
+from __future__ import annotations
+import re
+from typing import Optional, Dict, Any
+
+# keyword patterns -> theorem entry
+_CATALOG = [
+    {
+        "keys": ["infinite", "infinitude", "infinitely", "infinitely many primes",
+                 "infinitely many prime numbers", "euclid"],
+        "name": "Euclid's theorem (infinitude of primes)",
+        "statement": "There are infinitely many prime numbers.",
+        "formal": "∀N ∈ ℕ, ∃p prime with p > N",
+        "citation": "Euclid, Elements, Book IX, Proposition 20 (c. 300 BCE)",
+        "verified": True,
+        "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["fermat's last theorem", "fermat last theorem", "fermats last theorem",
+                 "x^n + y^n = z^n", "no three positive integers"],
+        "name": "Fermat's Last Theorem",
+        "statement": "No three positive integers a, b, c satisfy a^n + b^n = c^n for integer n > 2.",
+        "formal": "∀a,b,c,n∈ℤ⁺, n>2 ⇒ aⁿ+bⁿ≠cⁿ",
+        "citation": "Wiles, 'Modular elliptic curves and Fermat's Last Theorem', Ann. of Math. 141 (1995), 443–551",
+        "verified": True,
+        "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system. (Proved 1994–95 by A. Wiles.)",
+    },
+    {
+        "keys": ["pythagorean theorem", "pythagoras", "a^2 + b^2 = c^2", "right triangle"],
+        "name": "Pythagorean theorem",
+        "statement": "In a right triangle, the square of the hypotenuse equals the sum of squares of the legs.",
+        "formal": "a² + b² = c² for a right triangle with legs a, b and hypotenuse c",
+        "citation": "Euclid, Elements, Book I, Proposition 47",
+        "verified": True,
+        "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["fundamental theorem of arithmetic", "unique prime factorization",
+                 "prime factorization is unique"],
+        "name": "Fundamental theorem of arithmetic",
+        "statement": "Every integer greater than 1 is a product of primes, uniquely up to order.",
+        "formal": "∀n>1, n = ∏ p_i^{e_i} uniquely",
+        "citation": "Euclid, Elements, Book VII; Gauss, Disquisitiones Arithmeticae (1801)",
+        "verified": True,
+        "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["goldbach", "every even integer greater than 2 is the sum of two primes",
+                 "golbach's conjecture"],
+        "name": "Goldbach's conjecture (OPEN — unproven, do not assert)",
+        "statement": "Every even integer greater than 2 is the sum of two primes.",
+        "formal": "∀even n>2, ∃ primes p,q with p+q=n",
+        "citation": "Letter from Goldbach to Euler, 1742 (unproven conjecture)",
+        "verified": False,
+        "kind": "open_conjecture",
+        "note": "OPEN CONJECTURE — not proven. The system must NOT assert it as true. This entry signals 'known open problem, correct posture = abstain from truth claim.'",
+    },
+    # ---- number theory ------------------------------------------------
+    {
+        "keys": ["euclid's lemma", "if a prime divides a product", "prime divides product"],
+        "name": "Euclid's lemma",
+        "statement": "If a prime p divides the product ab, then p divides a or p divides b.",
+        "formal": "p prime ∧ p|ab ⇒ p|a ∨ p|b",
+        "citation": "Euclid, Elements, Book VII, Proposition 30",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["dirichlet's theorem", "dirichlet arithmetic progression", "infinitely many primes in every arithmetic progression"],
+        "name": "Dirichlet's theorem on arithmetic progressions",
+        "statement": "There are infinitely many primes congruent to a mod m whenever gcd(a,m)=1.",
+        "formal": "∀a,m with gcd(a,m)=1: #(primes p ≡ a mod m) = ∞",
+        "citation": "Dirichlet, 1837",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["prime number theorem", "asymptotic distribution of primes", "number of primes up to x"],
+        "name": "Prime number theorem",
+        "statement": "π(x) ~ x / ln x as x → ∞.",
+        "formal": "lim_{x→∞} π(x)·ln(x)/x = 1",
+        "citation": "Hadamard & de la Vallée Poussin, 1896",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["sum of two squares which integers", "fermat two squares", "p = a^2 + b^2"],
+        "name": "Fermat's theorem on sums of two squares",
+        "statement": "An odd prime p is a sum of two squares iff p ≡ 1 (mod 4).",
+        "formal": "odd prime p = a²+b² ⟺ p ≡ 1 (mod 4)",
+        "citation": "Fermat (1640); proved by Euler 1749",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    # ---- algebra ------------------------------------------------------
+    {
+        "keys": ["fundamental theorem of algebra", "every polynomial has a root", "degree n polynomial n roots"],
+        "name": "Fundamental theorem of algebra",
+        "statement": "Every non-constant polynomial with complex coefficients has a complex root.",
+        "formal": "∀p∈ℂ[x], deg p>0: ∃ z∈ℂ, p(z)=0",
+        "citation": "Gauss, 1799 (first rigorous proof); Argand 1814; Cauchy",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["cayley-hamilton", "cayley hamilton", "cayley hamilton theorem",
+                 "every matrix satisfies its characteristic equation", "characteristic polynomial"],
+        "name": "Cayley–Hamilton theorem",
+        "statement": "Every square matrix satisfies its own characteristic equation.",
+        "formal": "Let p(A)=det(λI−A); then p(A)=0 (matrix identity)",
+        "citation": "Cayley (1858), Hamilton (1853)",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["binomial theorem", "expansion of (x + y)^n", "binomial expansion"],
+        "name": "Binomial theorem",
+        "statement": "(x + y)ⁿ = Σₖ ₙCₖ xⁿ⁻ᵏ yᵏ for integer n ≥ 0.",
+        "formal": "(x+y)^n = Σ_{k=0}^n C(n,k) x^{n-k} y^k",
+        "citation": "Pascal (1654); known to Chinese/Islamic mathematicians earlier",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known identity recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["lamé", "zero divisor ring", "every finite integral domain is a field"],
+        "name": "Finite integral domains are fields (Wedderburn's little theorem)",
+        "statement": "Every finite integral domain is a field.",
+        "formal": "finite domain ⇒ every non-zero element has a multiplicative inverse",
+        "citation": "Wedderburn, 1905",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    # ---- analysis ------------------------------------------------------
+    {
+        "keys": ["intermediate value theorem", "continuous function crosses", "bolzano", "ivt"],
+        "name": "Intermediate value theorem (Bolzano)",
+        "statement": "A continuous function on a closed interval attains every value between its endpoints.",
+        "formal": "f:[a,b]→ℝ continuous, y between f(a),f(b) ⇒ ∃ c ∈ [a,b], f(c)=y",
+        "citation": "Bolzano 1817",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["mean value theorem", "rolle", "there exists c where f'(c)", "lagrange mvt"],
+        "name": "Mean value theorem",
+        "statement": "For differentiable f on [a,b], ∃ c with f'(c) = (f(b)−f(a))/(b−a).",
+        "formal": "∃ c: f'(c) = (f(b)-f(a))/(b-a)",
+        "citation": "Lagrange 1797; Rolle (1691) for the f(a)=f(b) case",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["fundamental theorem of calculus", "differentiation integration inverse", "ftc", "antiderivative"],
+        "name": "Fundamental theorem of calculus",
+        "statement": "Differentiation and integration are inverse operations over an interval.",
+        "formal": "d/dx ∫_a^x f(t) dt = f(x)",
+        "citation": "Newton & Leibniz, 17th c.",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["euler's identity", "e^(i*pi) + 1 = 0", "e to the i pi", "e^i*pi"],
+        "name": "Euler's identity",
+        "statement": "e^(iπ) + 1 = 0.",
+        "formal": "e^{iπ} + 1 = 0",
+        "citation": "Euler, 1748 (Introductio)",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known identity recognized from catalog; not generated by this system.",
+    },
+    # ---- geometry / set theory / misc ----------------------------------
+    {
+        "keys": ["triangle inequality", "abs", "|x + y| <= |x| + |y|"],
+        "name": "Triangle inequality",
+        "statement": "|x + y| ≤ |x| + |y| for real (or complex) x, y.",
+        "formal": "|x+y| ≤ |x|+|y|",
+        "citation": "Euclid, Elements, Book I, Prop. 20 (geometry); analytic form standard",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known inequality recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["cantor's theorem", "cardinality of power set", "set has more subsets", "diagonalization set"],
+        "name": "Cantor's theorem",
+        "statement": "The cardinality of a set's power set is strictly greater than the set's cardinality.",
+        "formal": "|P(S)| > |S| for every set S",
+        "citation": "Cantor, 1891 (diagonal argument)",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["pythagorean theorem", "pythagoras", "a^2 + b^2 = c^2", "right triangle"],
+        "name": "Pythagorean theorem",
+        "statement": "In a right triangle, the square of the hypotenuse equals the sum of squares of the legs.",
+        "formal": "a² + b² = c² for a right triangle with legs a, b and hypotenuse c",
+        "citation": "Euclid, Elements, Book I, Proposition 47",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    {
+        "keys": ["five platonic solids", "exactly 5 platonic solids", "only five regular convex polyhedra"],
+        "name": "There are exactly five Platonic solids",
+        "statement": "There are exactly five regular convex polyhedra (tetrahedron, cube, octahedron, dodecahedron, icosahedron).",
+        "formal": "exactly 5 regular convex polyhedra in ℝ³",
+        "citation": "Theaetetus (c. 370 BCE); Euclid, Elements, Book XIII",
+        "verified": True, "kind": "known_theorem",
+        "note": "Known theorem recognized from catalog; not generated by this system.",
+    },
+    # ---- more open conjectures (never assert as true) -------------------
+    {
+        "keys": ["riemann hypothesis", "zeta function zeros", "all non-trivial zeros"],
+        "name": "Riemann hypothesis (OPEN)",
+        "statement": "All non-trivial zeros of the Riemann zeta function have real part 1/2.",
+        "formal": "ζ(s)=0, s non-trivial ⇒ Re(s)=1/2",
+        "citation": "Riemann, 1859 (unproven; Millennium Prize)",
+        "verified": False, "kind": "open_conjecture",
+        "note": "OPEN CONJECTURE — unproven. Must NOT be asserted true.",
+    },
+    {
+        "keys": ["collatz", "3n+1", "hailstone", "syracuse"],
+        "name": "Collatz conjecture (OPEN)",
+        "statement": "Iterating n ↦ 3n+1 (odd) or n/2 (even) eventually reaches 1 for every positive integer n.",
+        "formal": "∀n∈ℤ⁺ iterating the Collatz map reaches 1",
+        "citation": "Collatz, 1937 (unproven)",
+        "verified": False, "kind": "open_conjecture",
+        "note": "OPEN CONJECTURE — unproven. Must NOT be asserted true.",
+    },
+    {
+        "keys": ["twin prime", "infinitely many twin primes", "twin primes are infinite"],
+        "name": "Twin prime conjecture (OPEN — note the partial result)",
+        "statement": "There are infinitely many pairs of primes differing by 2.",
+        "formal": "#{(p, p+2): both prime} = ∞  (OPEN)",
+        "citation": "de Polignac 1849 (unproven); Zhang 2013 proved bounded gaps",
+        "verified": False, "kind": "open_conjecture",
+        "note": "OPEN CONJECTURE — unproven. Zhang (2013) proved gaps are bounded but NOT the full conjecture. Must NOT be asserted true.",
+    },
+    {
+        "keys": ["p = np", "p vs np", "p equals np"],
+        "name": "P vs NP (OPEN)",
+        "statement": "Whether every problem whose solution can be quickly verified can also be solved quickly is unknown.",
+        "formal": "P = NP ? (unresolved)",
+        "citation": "Cook, 1971; Levin (unproven; Millennium Prize)",
+        "verified": False, "kind": "open_conjecture",
+        "note": "OPEN PROBLEM — unresolved. Must NOT be asserted either way.",
+    },
+]
+
+
+def parse_known_theorem(text: str) -> Optional[Dict[str, Any]]:
+    """Return the theater record for a known theorem if `text` matches the
+    catalog, else None (abstention)."""
+    if not text:
+        return None
+    t = text.lower()
+    for entry in _CATALOG:
+        keys = [k.lower() for k in entry["keys"]]
+        if any(k in t for k in keys):
+            # return a copy (no mutation of the catalog)
+            return {
+                "status": entry["kind"] if entry["kind"] in ("open_conjecture",) else "known_theorem",
+                "kind": entry["kind"],
+                "verified": entry["verified"],
+                "name": entry["name"],
+                "answer": entry["verified"],
+                "statement": entry["statement"],
+                "formal": entry["formal"],
+                "citation": entry["citation"],
+                "summary": f"{entry['name']}: {entry['statement']} [citation: {entry['citation']}]",
+                "note": entry["note"],
+            }
+    return None
+
+
+# quick self-test
+if __name__ == "__main__":
+    for q in [
+        "Prove that there are infinitely many primes",
+        "There are infinitely many prime numbers",
+        "State Fermat's Last Theorem",
+        "Every even integer > 2 is the sum of two primes",
+        "2 + 2 = 4",
+    ]:
+        r = parse_known_theorem(q)
+        print(f"  {q[:45]:47} -> {r['kind'] if r else 'abstain'} | {(r or {}).get('name','')[:40]}")