deeperthawt 1.0.0__tar.gz

deeperthawt-1.0.0/LICENSE.commercial.md

@@ -0,0 +1,53 @@
+# DeeperThawt — Dual-License Terms
+
+DeeperThawt is distributed under a **dual-license** model so it can serve both
+the open-source community and commercial embedders of proprietary products.
+
+## 1. Open core — AGPL-3.0
+
+The DeeperThawt open core (the reasoning, math, logic, verification, and
+knowledge engine source) is licensed under the **GNU Affero General Public
+License v3.0 (AGPL-3.0)**. You may copy, modify, and distribute it under the
+terms of AGPL-3.0, including the requirement that any network service running a
+modified version must offer its source to its users.
+
+- This makes the open core free to use, study, and improve.
+- Any project that *redistributes or hosts a modified version of the open core*
+  must do so under AGPL-3.0.
+
+## 2. Commercial license — paid
+
+If you want to use DeeperThawt in a way the AGPL does not permit — for example,
+embedding the engine inside a **closed-source product, plugin, or SaaS**, where
+you do **not** want to release your modifications under AGPL — you may purchase
+a **commercial license** from the DeeperThawt maintainer.
+
+The commercial license grants you, for a one-time or recurring fee:
+
+- A non-exclusive, worldwide, royalty-bearing right to **embed and redistribute**
+  DeeperThawt within your proprietary product **without** triggering the AGPL's
+  copyleft obligations.
+- The freedom to **obfuscate or keep your modifications proprietary**.
+- **Commercial support** for deployment, integration, and tuning.
+
+It does **not** transfer ownership of the DeeperThawt code. All code remains
+copyright of the DeeperThawt maintainer.
+
+## 3. Which do you need?
+
+| Use case | License |
+|----------|---------|
+| Use the engine as a library inside your open-source (AGPL-compatible) project | AGPL-3.0 |
+| Run the engine for your own research / internal tooling, not redistributed | AGPL-3.0 |
+| Host the engine as a service and offer its source to users | AGPL-3.0 |
+| Embed the engine inside a **closed-source product / SaaS** without open-sourcing your code | **Commercial license** |
+| Resell or sublicense the engine as a proprietary component | **Commercial license** |
+
+## 4. Contact
+
+To obtain a commercial license, contact the DeeperThawt maintainer (repo owner
+of `sudo-ai-git/deeperthawt`, sales via the DeeperThawt landing page).
+
+---
+
+© 2026 DeeperThawt maintainer. All rights reserved under the applicable license.

deeperthawt-1.0.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: deeperthawt
+Version: 1.0.0
+Summary: DeeperThawt — deterministic verifiable reasoning engine: symbolic math solver, logic inference, knowledge retrieval, FSS verification, and semantic token intelligence. Dual-licensed (AGPL-3.0 open core + commercial license for embedding).
+Author: DeeperThawt maintainer
+License: AGPL-3.0-only (open core); commercial license available for embedding
+Project-URL: Homepage, https://sudo-ai-git.github.io/deeperthawt/
+Project-URL: Repository, https://github.com/sudo-ai-git/deeperthawt
+Keywords: verifiable-reasoning,deterministic,math-solver,logic,no-hallucination,token-intelligence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.commercial.md
+Requires-Dist: numpy>=1.24
+Requires-Dist: sympy>=1.10
+Provides-Extra: payments
+Requires-Dist: requests>=2.31; extra == "payments"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# DeeperThawt
+
+**Deterministic verifiable reasoning engine** — solves hard math, verifies logic, retrieves cited knowledge, and detects semantically-near token waste — with **zero hallucination**, because the answers are computed, not guessed.
+
+- **Symbolic math oracle** — deterministic SymPy solver: integrals, systems, Fibonacci, primes, modular arithmetic, inequality. Verifies true claims (`2 + 2 = 4` → **TRUE**), refutes false ones (`2 + 2 = 5` → **REFUTED**, with witnesses), and honestly abstains on what it can't prove.
+- **Logic engine** — modus ponens/tollens, syllogism, conjunction, double-negation. `verified / invalid / insufficient` — never guesses.
+- **Cited knowledge** — known theorems (Euclid, Fermat, etc.), science facts, Python knowledge. Retrieval with citations, *not* generation.
+- **Semantic token intelligence** — the secret engine (gematria projection + fixed-parameter attention + trained latent adapter) runs **server-side** and returns only numbers. It finds the near-duplicate token waste exact-dedupe misses.
+
+## Architecture: secret ingredients stay remote
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │  DeeperThawt (pip package, local)                           │
+  │                                                            │
+  │  · math oracle          (deterministic, SHIPPED)            │
+  │  · logic engine         (deterministic, SHIPPED)            │
+  │  · cited knowledge      (deterministic, SHIPPED)            │
+  │  · semantic RPC client  (numeric-only, SHIPPED)             │
+  │                        ╭───────────────────╮               │
+  └────────────────────────┤  POST /assess     │───────────────┘
+                           │  (de-identified)  │
+                           │        ▼          │
+                           │  REMOTE server    │
+                           │  · gematria proj. │  ══ THE SECRET ══
+                           │  · attention      │  engine + tuned
+                           │  · trained adapter│  weights live
+                           │  · tuned weights  │  ONLY HERE
+                           ╰───────────────────╯
+```
+
+The **secret ingredients** — the semantic projection method, the fixed-parameter attention, the trained latent adapter, and the tuned weights — are **never shipped locally**. A local buyer gets a pip package with the deterministic solvers and a thin RPC client; the secret engine runs only on the remote DeeperThawt server behind a paid entitlement gate, returning **numbers only**.
+
+## Install
+
+```bash
+pip install deeperthawt
+# or from source:
+git clone https://github.com/sudo-ai-git/deeperthawt.git
+cd deeperthawt && pip install -e .
+```
+
+## Quick start
+
+```python
+from deeperthawt import DeeperThawt
+
+engine = DeeperThawt()
+
+# Hard math — deterministic, no LLM guessing
+engine.solve_math("integral of x^2 from 0 to 1")   # solved, 1/3
+engine.solve_math("2 + 2 = 5")                     # refuted, with witness
+engine.solve_math("2 + 2 = 4")                     # verified True
+
+# Logic
+engine.verify_logic(
+    ["if it rains then the ground is wet", "it rains"],
+    "the ground is wet")                           # {"status": "valid"}
+
+# Cited knowledge
+engine.knowledge_math_theorem("infinitely many primes")  # Euclid, cited
+engine.knowledge_science("why is the sky blue")          # fact + reference
+
+# Semantic token intelligence — runs on the REMOTE server
+engine = DeeperThawt(api_base="https://mcp-token-saver-pro.fly.dev")
+engine.semantic_assess([...messages...])            # returns numbers only
+```
+
+## CLI
+
+```bash
+deeperthawt math "integral of x^2 from 0 to 1"
+deeperthawt logic "if it rains then the ground is wet; it rains" "the ground is wet"
+deeperthawt theorem "infinitely many primes"
+deeperthawt science "why is the sky blue"
+deeperthawt python "list comprehension"
+deeperthawt selfcheck        # 8/8 capability smoke test
+```
+
+## The honesty contract
+
+1. **Deterministic** — same input → same answer, every time. No stochastic LLM in the scoring path. You can re-run and reproduce.
+2. **No hallucination** — the engine solves/verifies/refutes what it can *prove*, and **abstains** (says "not verifiable") on what it can't. It never invents an answer.
+3. **Opaque but auditable** — the deterministic solvers are open (AGPL). The semantic engine is server-side; you see the **contract and the number**, not the method.
+4. **What it doesn't claim** — DeeperThawt does not generate prose, write code, or "reason" generally. It *computes* and *verifies*. The claims on this page are about provable operations.
+
+## License: dual-license
+
+- **Open core (AGPL-3.0)**: the deterministic solvers (math, logic, knowledge) are open source under AGPL.
+- **Commercial license**: available for embedding DeeperThawt inside a **closed-source product or SaaS** without AGPL obligations. See [`LICENSE.commercial.md`](LICENSE.commercial.md).
+
+For a commercial license, contact the maintainer via the [landing page](https://sudo-ai-git.github.io/deeperthawt/).
+
+© 2026 DeeperThawt maintainer.

deeperthawt-1.0.0/README.md

@@ -0,0 +1,94 @@
+# DeeperThawt
+
+**Deterministic verifiable reasoning engine** — solves hard math, verifies logic, retrieves cited knowledge, and detects semantically-near token waste — with **zero hallucination**, because the answers are computed, not guessed.
+
+- **Symbolic math oracle** — deterministic SymPy solver: integrals, systems, Fibonacci, primes, modular arithmetic, inequality. Verifies true claims (`2 + 2 = 4` → **TRUE**), refutes false ones (`2 + 2 = 5` → **REFUTED**, with witnesses), and honestly abstains on what it can't prove.
+- **Logic engine** — modus ponens/tollens, syllogism, conjunction, double-negation. `verified / invalid / insufficient` — never guesses.
+- **Cited knowledge** — known theorems (Euclid, Fermat, etc.), science facts, Python knowledge. Retrieval with citations, *not* generation.
+- **Semantic token intelligence** — the secret engine (gematria projection + fixed-parameter attention + trained latent adapter) runs **server-side** and returns only numbers. It finds the near-duplicate token waste exact-dedupe misses.
+
+## Architecture: secret ingredients stay remote
+
+```
+  ┌────────────────────────────────────────────────────────────┐
+  │  DeeperThawt (pip package, local)                           │
+  │                                                            │
+  │  · math oracle          (deterministic, SHIPPED)            │
+  │  · logic engine         (deterministic, SHIPPED)            │
+  │  · cited knowledge      (deterministic, SHIPPED)            │
+  │  · semantic RPC client  (numeric-only, SHIPPED)             │
+  │                        ╭───────────────────╮               │
+  └────────────────────────┤  POST /assess     │───────────────┘
+                           │  (de-identified)  │
+                           │        ▼          │
+                           │  REMOTE server    │
+                           │  · gematria proj. │  ══ THE SECRET ══
+                           │  · attention      │  engine + tuned
+                           │  · trained adapter│  weights live
+                           │  · tuned weights  │  ONLY HERE
+                           ╰───────────────────╯
+```
+
+The **secret ingredients** — the semantic projection method, the fixed-parameter attention, the trained latent adapter, and the tuned weights — are **never shipped locally**. A local buyer gets a pip package with the deterministic solvers and a thin RPC client; the secret engine runs only on the remote DeeperThawt server behind a paid entitlement gate, returning **numbers only**.
+
+## Install
+
+```bash
+pip install deeperthawt
+# or from source:
+git clone https://github.com/sudo-ai-git/deeperthawt.git
+cd deeperthawt && pip install -e .
+```
+
+## Quick start
+
+```python
+from deeperthawt import DeeperThawt
+
+engine = DeeperThawt()
+
+# Hard math — deterministic, no LLM guessing
+engine.solve_math("integral of x^2 from 0 to 1")   # solved, 1/3
+engine.solve_math("2 + 2 = 5")                     # refuted, with witness
+engine.solve_math("2 + 2 = 4")                     # verified True
+
+# Logic
+engine.verify_logic(
+    ["if it rains then the ground is wet", "it rains"],
+    "the ground is wet")                           # {"status": "valid"}
+
+# Cited knowledge
+engine.knowledge_math_theorem("infinitely many primes")  # Euclid, cited
+engine.knowledge_science("why is the sky blue")          # fact + reference
+
+# Semantic token intelligence — runs on the REMOTE server
+engine = DeeperThawt(api_base="https://mcp-token-saver-pro.fly.dev")
+engine.semantic_assess([...messages...])            # returns numbers only
+```
+
+## CLI
+
+```bash
+deeperthawt math "integral of x^2 from 0 to 1"
+deeperthawt logic "if it rains then the ground is wet; it rains" "the ground is wet"
+deeperthawt theorem "infinitely many primes"
+deeperthawt science "why is the sky blue"
+deeperthawt python "list comprehension"
+deeperthawt selfcheck        # 8/8 capability smoke test
+```
+
+## The honesty contract
+
+1. **Deterministic** — same input → same answer, every time. No stochastic LLM in the scoring path. You can re-run and reproduce.
+2. **No hallucination** — the engine solves/verifies/refutes what it can *prove*, and **abstains** (says "not verifiable") on what it can't. It never invents an answer.
+3. **Opaque but auditable** — the deterministic solvers are open (AGPL). The semantic engine is server-side; you see the **contract and the number**, not the method.
+4. **What it doesn't claim** — DeeperThawt does not generate prose, write code, or "reason" generally. It *computes* and *verifies*. The claims on this page are about provable operations.
+
+## License: dual-license
+
+- **Open core (AGPL-3.0)**: the deterministic solvers (math, logic, knowledge) are open source under AGPL.
+- **Commercial license**: available for embedding DeeperThawt inside a **closed-source product or SaaS** without AGPL obligations. See [`LICENSE.commercial.md`](LICENSE.commercial.md).
+
+For a commercial license, contact the maintainer via the [landing page](https://sudo-ai-git.github.io/deeperthawt/).
+
+© 2026 DeeperThawt maintainer.

deeperthawt-1.0.0/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-1.0.0/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-1.0.0/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",
+]