apophatic-engine 0.1.0__tar.gz

apophatic_engine-0.1.0/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

apophatic_engine-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: apophatic_engine
+Version: 0.1.0
+Summary: Apophatic noise-subtraction filter (¬X) for LLMs.
+Author: xerx593
+Project-URL: Homepage, https://github.com/xerx593/apophatic-engine
+Project-URL: Theory Framework, https://github.com/xerx593/nicht-theory
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# Apophatic Engine (`apophatic-engine`)
+
+> *Apophatic Noise Subtraction ($\neg X$) for Neural Inference and System Optimization.*
+
+The **Apophatic Engine** implements token-by-token noise subtraction ($\neg X$) derived from the **Nicht-Theory** theoretical framework. Instead of maximizing speculative probabilities ($1$-logic), the filter penalizes assertion pressure ($P_A$) and relaxes high-entropy tokens directly into the **Sufficient Invariant Baseline ($B_0$)**.
+
+## Theoretical Grounding
+This repository provides the operational code implementation for Paper IV (*Apophatic Inference Engine*) of the [Nicht-Theory Framework](https://github.com/xerx593/nicht-theory).
+
+## Quickstart
+```python
+from apophatic_filter import ApophaticEngine
+import numpy as np
+
+engine = ApophaticEngine(sigma_threshold=0.40)
+logits = np.array([1.2, 1.1, 1.3, 1.0])  # High-noise logits
+
+result = engine.apply_apophatic_filter(logits, step=1)
+print(result)
+# Output: {'status': 'RELAX_TO_BASELINE', 'output_token': '[B_0: SILENCE / UNASSERTED]'}

apophatic_engine-0.1.0/README.md

@@ -0,0 +1,20 @@
+# Apophatic Engine (`apophatic-engine`)
+
+> *Apophatic Noise Subtraction ($\neg X$) for Neural Inference and System Optimization.*
+
+The **Apophatic Engine** implements token-by-token noise subtraction ($\neg X$) derived from the **Nicht-Theory** theoretical framework. Instead of maximizing speculative probabilities ($1$-logic), the filter penalizes assertion pressure ($P_A$) and relaxes high-entropy tokens directly into the **Sufficient Invariant Baseline ($B_0$)**.
+
+## Theoretical Grounding
+This repository provides the operational code implementation for Paper IV (*Apophatic Inference Engine*) of the [Nicht-Theory Framework](https://github.com/xerx593/nicht-theory).
+
+## Quickstart
+```python
+from apophatic_filter import ApophaticEngine
+import numpy as np
+
+engine = ApophaticEngine(sigma_threshold=0.40)
+logits = np.array([1.2, 1.1, 1.3, 1.0])  # High-noise logits
+
+result = engine.apply_apophatic_filter(logits, step=1)
+print(result)
+# Output: {'status': 'RELAX_TO_BASELINE', 'output_token': '[B_0: SILENCE / UNASSERTED]'}

apophatic_engine-0.1.0/apophatic_engine/__init__.py

@@ -0,0 +1,3 @@
+from .filter import ApophaticEngine
+
+__all__ = ["ApophaticEngine"]

apophatic_engine-0.1.0/apophatic_engine/filter.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+
+class ApophaticEngine:
+    """Apophatic Inference Engine (AIE)
+
+    Applies apophatic negation (¬X) to strip speculative token noise
+    and force low-confidence assertions to decay into the 0-Baseline (B_0).
+    """
+
+    def __init__(self, sigma_threshold: float = 0.45, gamma_decay: float = 0.1):
+        """Parameters
+
+        ----------
+        sigma_threshold : float
+            Epistemic noise boundary. Distributions with noise above this threshold
+            are suppressed into baseline silence.
+        gamma_decay : float
+            Decay rate for assertion pressure over generation steps.
+        """
+        self.sigma_threshold = sigma_threshold
+        self.gamma_decay = gamma_decay
+
+    def compute_assertion_penalty(
+        self, logits: np.ndarray, step: int
+    ) -> np.ndarray:
+        """Calculates Assertion Pressure P_A(t) for candidate tokens."""
+        probs = np.exp(logits) / np.sum(np.exp(logits))
+        assertion_pressure = (1.0 - probs) * np.exp(-self.gamma_decay * step)
+        return assertion_pressure
+
+    def apply_apophatic_filter(self, logits: np.ndarray, step: int = 1) -> dict:
+        """Applies the ¬X operator to filter logits.
+
+        If epistemic noise exceeds threshold, returns RELAX_TO_BASELINE.
+        Otherwise, returns the non-assertive invariant token ID.
+        """
+        probs = np.exp(logits) / np.sum(np.exp(logits))
+        max_confidence = np.max(probs)
+        sigma = 1.0 - max_confidence
+
+        if sigma > self.sigma_threshold:
+            return {
+                "status": "RELAX_TO_BASELINE",
+                "output_token": "[B_0: SILENCE / UNASSERTED]",
+                "sigma": float(sigma),
+                "action": "¬X applied (Assertion Pressure P_A -> 0)",
+            }
+
+        P_A = self.compute_assertion_penalty(logits, step)
+        filtered_logits = logits - P_A
+        best_token_id = np.argmax(filtered_logits)
+
+        return {
+            "status": "INVARIANT_OUTPUT",
+            "token_id": int(best_token_id),
+            "sigma": float(sigma),
+            "action": "Token cleared through baseline check",
+        }

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

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: apophatic_engine
+Version: 0.1.0
+Summary: Apophatic noise-subtraction filter (¬X) for LLMs.
+Author: xerx593
+Project-URL: Homepage, https://github.com/xerx593/apophatic-engine
+Project-URL: Theory Framework, https://github.com/xerx593/nicht-theory
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# Apophatic Engine (`apophatic-engine`)
+
+> *Apophatic Noise Subtraction ($\neg X$) for Neural Inference and System Optimization.*
+
+The **Apophatic Engine** implements token-by-token noise subtraction ($\neg X$) derived from the **Nicht-Theory** theoretical framework. Instead of maximizing speculative probabilities ($1$-logic), the filter penalizes assertion pressure ($P_A$) and relaxes high-entropy tokens directly into the **Sufficient Invariant Baseline ($B_0$)**.
+
+## Theoretical Grounding
+This repository provides the operational code implementation for Paper IV (*Apophatic Inference Engine*) of the [Nicht-Theory Framework](https://github.com/xerx593/nicht-theory).
+
+## Quickstart
+```python
+from apophatic_filter import ApophaticEngine
+import numpy as np
+
+engine = ApophaticEngine(sigma_threshold=0.40)
+logits = np.array([1.2, 1.1, 1.3, 1.0])  # High-noise logits
+
+result = engine.apply_apophatic_filter(logits, step=1)
+print(result)
+# Output: {'status': 'RELAX_TO_BASELINE', 'output_token': '[B_0: SILENCE / UNASSERTED]'}

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+apophatic_engine/__init__.py
+apophatic_engine/filter.py
+apophatic_engine.egg-info/PKG-INFO
+apophatic_engine.egg-info/SOURCES.txt
+apophatic_engine.egg-info/dependency_links.txt
+apophatic_engine.egg-info/requires.txt
+apophatic_engine.egg-info/top_level.txt
+tests/test_engine.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+numpy>=1.20.0

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

@@ -0,0 +1 @@
+apophatic_engine

apophatic_engine-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+#### **B. `pyproject.toml` (For future PyPI publishing)**
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "apophatic_engine"
+version = "0.1.0"
+authors = [
+  { name="xerx593" },
+]
+description = "Apophatic noise-subtraction filter (¬X) for LLMs."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.20.0",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: The Unlicense (Unlicense)",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/xerx593/apophatic-engine"
+"Theory Framework" = "https://github.com/xerx593/nicht-theory"

apophatic_engine-0.1.0/setup.cfg

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

apophatic_engine-0.1.0/tests/test_engine.py

@@ -0,0 +1,40 @@
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT))
+
+import numpy as np
+from apophatic_engine import ApophaticEngine
+
+
+def test_clear_signal():
+    engine = ApophaticEngine(sigma_threshold=0.40)
+    logits = np.array([0.1, 0.2, 5.0, 0.05])
+    res = engine.apply_apophatic_filter(logits, step=1)
+    assert res["status"] == "INVARIANT_OUTPUT"
+    assert res["token_id"] == 2
+
+
+def test_speculative_noise_relaxation():
+    engine = ApophaticEngine(sigma_threshold=0.40)
+    logits = np.array([1.1, 1.05, 1.12, 0.98])
+    res = engine.apply_apophatic_filter(logits, step=1)
+    assert res["status"] == "RELAX_TO_BASELINE"
+    assert res["output_token"] == "[B_0: SILENCE / UNASSERTED]"
+
+
+def test_step_decay_dynamics():
+    engine = ApophaticEngine(gamma_decay=0.2)
+    logits = np.array([2.0, 1.5, 0.5])
+    p1 = engine.compute_assertion_penalty(logits, step=1)
+    p2 = engine.compute_assertion_penalty(logits, step=2)
+    # Assertion pressure P_A decays over time steps
+    assert np.all(p2 < p1)
+
+
+if __name__ == "__main__":
+    test_clear_signal()
+    test_speculative_noise_relaxation()
+    test_step_decay_dynamics()
+    print("All extended unit tests passed successfully.")