bendex-tau 0.1.0__tar.gz

bendex_tau-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: bendex-tau
+Version: 0.1.0
+Summary: Real-time LLM response stability monitor grounded in Fisher-Rao information geometry and the Landauer limit.
+Author-email: Hannah Nine <9hannahnine@gmail.com>
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://bendexgeometry.com
+Project-URL: Repository, https://github.com/9hannahnine-jpg/bendex-tau
+Project-URL: Papers, https://figshare.com/authors/Hannah_Nine/22495979
+Keywords: llm,security,prompt injection,ai safety,monitoring,information geometry,fisher-rao
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+Requires-Dist: sentence-transformers>=2.0
+Requires-Dist: openai>=1.0
+
+# bendex-tau
+
+Real-time LLM response stability monitor grounded in Fisher-Rao information geometry.
+
+## What it does
+
+Tracks tau_sec on the trajectory of LLM responses. When an LLM is being manipulated,
+its response trajectory becomes informationally unstable. tau_sec measures this in real time.
+
+tau* = sqrt(3/2) = 1.2247 — the Landauer threshold. Not tuned. Derived.
+
+Empirical validation at n=50 per class:
+- Adversarial sessions mean min tau: 0.984
+- Benign sessions mean min tau: 1.182
+- p < 0.0000001 (t-test and Mann-Whitney)
+
+## Install
+
+```bash
+pip install bendex-tau
+```
+
+## Usage
+
+```python
+from bendex_tau import TauMonitor
+from openai import OpenAI
+
+monitor = TauMonitor()
+client = OpenAI()
+
+response = monitor.create(
+    client,
+    session_id="session_123",
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "hello"}]
+)
+
+print(response.tau_sec)        # stability scalar
+print(response.tau_status)     # stable / warning / adversarial
+print(response.meta_rate)      # M(tau) early warning signal
+print(response.below_threshold) # True if tau crossed tau*
+```
+
+## Papers
+
+Hannah Nine (2026). H2 x H2 Fisher manifold series.
+https://figshare.com/authors/Hannah_Nine/22495979
+
+Patent pending.
+
+## License
+
+AGPL-3.0. Commercial license at bendexgeometry.com.

bendex_tau-0.1.0/README.md

@@ -0,0 +1,54 @@
+# bendex-tau
+
+Real-time LLM response stability monitor grounded in Fisher-Rao information geometry.
+
+## What it does
+
+Tracks tau_sec on the trajectory of LLM responses. When an LLM is being manipulated,
+its response trajectory becomes informationally unstable. tau_sec measures this in real time.
+
+tau* = sqrt(3/2) = 1.2247 — the Landauer threshold. Not tuned. Derived.
+
+Empirical validation at n=50 per class:
+- Adversarial sessions mean min tau: 0.984
+- Benign sessions mean min tau: 1.182
+- p < 0.0000001 (t-test and Mann-Whitney)
+
+## Install
+
+```bash
+pip install bendex-tau
+```
+
+## Usage
+
+```python
+from bendex_tau import TauMonitor
+from openai import OpenAI
+
+monitor = TauMonitor()
+client = OpenAI()
+
+response = monitor.create(
+    client,
+    session_id="session_123",
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "hello"}]
+)
+
+print(response.tau_sec)        # stability scalar
+print(response.tau_status)     # stable / warning / adversarial
+print(response.meta_rate)      # M(tau) early warning signal
+print(response.below_threshold) # True if tau crossed tau*
+```
+
+## Papers
+
+Hannah Nine (2026). H2 x H2 Fisher manifold series.
+https://figshare.com/authors/Hannah_Nine/22495979
+
+Patent pending.
+
+## License
+
+AGPL-3.0. Commercial license at bendexgeometry.com.

bendex_tau-0.1.0/bendex_tau/__init__.py

@@ -0,0 +1,4 @@
+from .monitor import TauMonitor
+from .session import TauSession
+__version__ = "0.1.0"
+__all__ = ["TauMonitor", "TauSession"]

bendex_tau-0.1.0/bendex_tau/monitor.py

@@ -0,0 +1,70 @@
+from .session import TauSession
+from typing import Dict, Optional
+
+class TauResponse:
+    def __init__(self, openai_response, tau_data: dict):
+        self._response      = openai_response
+        self.tau_sec        = tau_data.get("tau_sec")
+        self.tau_star       = tau_data.get("tau_star")
+        self.tau_status     = tau_data.get("tau_status")
+        self.meta_rate      = tau_data.get("meta_rate")
+        self.below_threshold = tau_data.get("below_threshold", False)
+        self.turns          = tau_data.get("turns")
+        self.session_id     = tau_data.get("session_id")
+        self._tau_data      = tau_data
+
+    def __getattr__(self, name):
+        return getattr(self._response, name)
+
+    def __repr__(self):
+        return (
+            f"TauResponse(tau_sec={self.tau_sec}, "
+            f"tau_status={self.tau_status!r}, "
+            f"meta_rate={self.meta_rate}, "
+            f"turns={self.turns})"
+        )
+
+
+class TauMonitor:
+    """
+    Wraps an OpenAI-compatible client to track tau_sec on response trajectories.
+
+    Usage:
+        from bendex_tau import TauMonitor
+        from openai import OpenAI
+
+        monitor = TauMonitor()
+        client = OpenAI()
+
+        response = monitor.create(
+            client,
+            session_id="user_123",
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": "hello"}]
+        )
+
+        print(response.tau_sec)
+        print(response.tau_status)
+        print(response.meta_rate)
+    """
+
+    def __init__(self):
+        self._sessions: Dict[str, TauSession] = {}
+
+    def _get_session(self, session_id: str) -> TauSession:
+        if session_id not in self._sessions:
+            self._sessions[session_id] = TauSession(session_id)
+        return self._sessions[session_id]
+
+    def create(self, client, session_id: str = "default", **kwargs) -> TauResponse:
+        response = client.chat.completions.create(**kwargs)
+        text = response.choices[0].message.content or ""
+        tau_data = self._get_session(session_id).update(text)
+        return TauResponse(response, tau_data)
+
+    def get_session(self, session_id: str) -> Optional[TauSession]:
+        return self._sessions.get(session_id)
+
+    def reset_session(self, session_id: str):
+        if session_id in self._sessions:
+            del self._sessions[session_id]

bendex_tau-0.1.0/bendex_tau/session.py

@@ -0,0 +1,105 @@
+import math
+import numpy as np
+from typing import Optional, List
+
+TAU_STAR = math.sqrt(3.0 / 2.0)
+T_WINDOW = 3
+
+def _meta_rate(tau: float) -> float:
+    if tau <= 0:
+        return 0.0
+    return -6.0 * (3.0 - 2.0 * tau ** 2) / (tau ** 5)
+
+class TauSession:
+    """
+    Tracks tau_sec for a single conversation session.
+
+    tau_sec is the Fisher-Rao stability scalar derived from the Landauer limit.
+    Below tau* (1.2247) the session has crossed into informational instability.
+
+    Reference: Nine (2026), Papers 2-3.
+    https://figshare.com/authors/Hannah_Nine/22495979
+    Patent pending.
+    """
+
+    def __init__(self, session_id: str = "default"):
+        self.session_id = session_id
+        self.embeddings: List[np.ndarray] = []
+        self.tau_history: List[float] = []
+        self.meta_history: List[float] = []
+        self._embed_model = None
+
+    def _get_model(self):
+        if self._embed_model is None:
+            from sentence_transformers import SentenceTransformer
+            self._embed_model = SentenceTransformer("all-MiniLM-L6-v2")
+        return self._embed_model
+
+    def update(self, response_text: str) -> dict:
+        model = self._get_model()
+        emb = model.encode([response_text[:512]], convert_to_numpy=True)[0]
+        self.embeddings.append(emb)
+        n = len(self.embeddings)
+
+        if n < T_WINDOW + 1:
+            return {
+                "tau_sec": None,
+                "tau_star": TAU_STAR,
+                "tau_status": "insufficient_history",
+                "meta_rate": None,
+                "turns": n,
+                "session_id": self.session_id,
+                "below_threshold": False,
+            }
+
+        deltas = [
+            np.linalg.norm(self.embeddings[i] - self.embeddings[i-1]) + 1e-8
+            for i in range(1, n)
+        ]
+
+        delta_curr = deltas[-1]
+        delta_prev = deltas[-2] if len(deltas) >= 2 else delta_curr
+        delta_old  = deltas[max(0, len(deltas) - T_WINDOW)]
+
+        S_local  = delta_prev / delta_curr
+        S_global = delta_old  / delta_curr
+        D_sec    = math.log(max(S_global, 1e-8)) - math.log(max(S_local, 1e-8))
+
+        lambda_sec = D_sec / max(n - T_WINDOW, 1)
+        inner      = lambda_sec + 2.0
+        tau_sec    = math.sqrt(3.0 / inner) if inner > 0 else 0.0
+
+        meta = _meta_rate(tau_sec)
+        self.tau_history.append(tau_sec)
+        self.meta_history.append(meta)
+
+        if tau_sec > TAU_STAR * 1.05:
+            status = "stable"
+        elif tau_sec > TAU_STAR:
+            status = "warning"
+        else:
+            status = "adversarial"
+
+        return {
+            "tau_sec":         round(tau_sec, 6),
+            "tau_star":        round(TAU_STAR, 6),
+            "tau_status":      status,
+            "meta_rate":       round(meta, 6),
+            "D_sec":           round(D_sec, 6),
+            "lambda_sec":      round(lambda_sec, 6),
+            "turns":           n,
+            "session_id":      self.session_id,
+            "below_threshold": tau_sec < TAU_STAR,
+        }
+
+    @property
+    def min_tau(self) -> Optional[float]:
+        return min(self.tau_history) if self.tau_history else None
+
+    @property
+    def mean_tau(self) -> Optional[float]:
+        return float(np.mean(self.tau_history)) if self.tau_history else None
+
+    @property
+    def tau_variance(self) -> Optional[float]:
+        return float(np.std(self.tau_history)) if len(self.tau_history) > 1 else None

bendex_tau-0.1.0/bendex_tau.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: bendex-tau
+Version: 0.1.0
+Summary: Real-time LLM response stability monitor grounded in Fisher-Rao information geometry and the Landauer limit.
+Author-email: Hannah Nine <9hannahnine@gmail.com>
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://bendexgeometry.com
+Project-URL: Repository, https://github.com/9hannahnine-jpg/bendex-tau
+Project-URL: Papers, https://figshare.com/authors/Hannah_Nine/22495979
+Keywords: llm,security,prompt injection,ai safety,monitoring,information geometry,fisher-rao
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+Requires-Dist: sentence-transformers>=2.0
+Requires-Dist: openai>=1.0
+
+# bendex-tau
+
+Real-time LLM response stability monitor grounded in Fisher-Rao information geometry.
+
+## What it does
+
+Tracks tau_sec on the trajectory of LLM responses. When an LLM is being manipulated,
+its response trajectory becomes informationally unstable. tau_sec measures this in real time.
+
+tau* = sqrt(3/2) = 1.2247 — the Landauer threshold. Not tuned. Derived.
+
+Empirical validation at n=50 per class:
+- Adversarial sessions mean min tau: 0.984
+- Benign sessions mean min tau: 1.182
+- p < 0.0000001 (t-test and Mann-Whitney)
+
+## Install
+
+```bash
+pip install bendex-tau
+```
+
+## Usage
+
+```python
+from bendex_tau import TauMonitor
+from openai import OpenAI
+
+monitor = TauMonitor()
+client = OpenAI()
+
+response = monitor.create(
+    client,
+    session_id="session_123",
+    model="gpt-4o-mini",
+    messages=[{"role": "user", "content": "hello"}]
+)
+
+print(response.tau_sec)        # stability scalar
+print(response.tau_status)     # stable / warning / adversarial
+print(response.meta_rate)      # M(tau) early warning signal
+print(response.below_threshold) # True if tau crossed tau*
+```
+
+## Papers
+
+Hannah Nine (2026). H2 x H2 Fisher manifold series.
+https://figshare.com/authors/Hannah_Nine/22495979
+
+Patent pending.
+
+## License
+
+AGPL-3.0. Commercial license at bendexgeometry.com.

bendex_tau-0.1.0/bendex_tau.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+bendex_tau/__init__.py
+bendex_tau/monitor.py
+bendex_tau/session.py
+bendex_tau.egg-info/PKG-INFO
+bendex_tau.egg-info/SOURCES.txt
+bendex_tau.egg-info/dependency_links.txt
+bendex_tau.egg-info/requires.txt
+bendex_tau.egg-info/top_level.txt

bendex_tau-0.1.0/bendex_tau.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bendex_tau-0.1.0/bendex_tau.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=1.21
+sentence-transformers>=2.0
+openai>=1.0

bendex_tau-0.1.0/bendex_tau.egg-info/top_level.txt

@@ -0,0 +1 @@
+bendex_tau

bendex_tau-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "bendex-tau"
+version = "0.1.0"
+description = "Real-time LLM response stability monitor grounded in Fisher-Rao information geometry and the Landauer limit."
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "AGPL-3.0-or-later"}
+authors = [{name = "Hannah Nine", email = "9hannahnine@gmail.com"}]
+keywords = ["llm", "security", "prompt injection", "ai safety", "monitoring", "information geometry", "fisher-rao"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+  "Programming Language :: Python :: 3",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Topic :: Security",
+]
+dependencies = [
+  "numpy>=1.21",
+  "sentence-transformers>=2.0",
+  "openai>=1.0",
+]
+
+[project.urls]
+Homepage = "https://bendexgeometry.com"
+Repository = "https://github.com/9hannahnine-jpg/bendex-tau"
+Papers = "https://figshare.com/authors/Hannah_Nine/22495979"
+
+[tool.setuptools.packages.find]
+include = ["bendex_tau*"]

bendex_tau-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+