supernova-photon 0.1.1__py3-none-any.whl

Supernova_photon/__init__.py

@@ -0,0 +1,5 @@
+from . import v5
+
+__version__ = "0.1.0"
+
+__all__ = ["v5"]

Supernova_photon/cli.py

@@ -0,0 +1,95 @@
+import sys
+from .v5 import photon
+
+
+def main():
+
+    print("=" * 60)
+    print("SUPERNOVA PHOTON-1 V5 — TERMINAL")
+    print("=" * 60)
+
+    try:
+        engine = photon()
+    except Exception as exc:
+        print("Initialization failed:", exc)
+        return
+
+    print("\nEnter 'exit' to quit.")
+    print("Example target: speed")
+    print("Example input: distance=100 m")
+    print("Example input: time=10 s")
+
+    while True:
+
+        try:
+            target = input("\nTarget variable: ").strip()
+
+            if target.lower() in ("exit", "quit"):
+                break
+
+            known = {}
+
+            print("Enter known values.")
+            print("Leave variable name empty when finished.")
+
+            while True:
+
+                name = input("Variable: ").strip()
+
+                if not name:
+                    break
+
+                raw = input("Value and unit (e.g. 100 m): ").strip()
+
+                parts = raw.split()
+
+                if len(parts) != 2:
+                    print("Use format: value unit")
+                    continue
+
+                known[name] = (
+                    float(parts[0]),
+                    parts[1]
+                )
+
+            output_unit = input(
+                "Output unit (Enter for SI): "
+            ).strip() or None
+
+            equation = input(
+                "Equation name (Enter for automatic): "
+            ).strip() or None
+
+            result = engine.solve(
+                target,
+                known,
+                equation_name=equation,
+                target_unit=output_unit
+            )
+
+            print("\nRESULT")
+            print("-" * 40)
+            print("Equation:", result["equation"])
+            print("Formula:", result["formula"])
+            print(
+                "Answer:",
+                result["result"],
+                result["unit"]
+            )
+            print(
+                "Validation probability:",
+                result["validation_probability"]
+            )
+            print("-" * 40)
+
+        except KeyboardInterrupt:
+            break
+
+        except Exception as exc:
+            print("Error:", exc)
+
+    print("Photon-1 V5 terminated.")
+
+
+if __name__ == "__main__":
+    main()

Supernova_photon/engine.py

@@ -0,0 +1,606 @@
+import math
+import os
+import numpy as np
+
+
+HF_REPO_ID = "Supernova11c/Supernova-Photon-1-V5"
+HF_FILENAME = "photon1_v5.pt"
+
+
+ALIASES = {
+    "e": "energy",
+    "energy": "energy",
+    "m": "mass",
+    "mass": "mass",
+    "c": "speed",
+    "v": "speed",
+    "speed": "speed",
+    "d": "distance",
+    "distance": "distance",
+    "t": "time",
+    "time": "time",
+    "rho": "density",
+    "ρ": "density",
+    "density": "density",
+    "volume": "volume",
+    "f": "force",
+    "force": "force",
+    "a": "acceleration",
+    "acceleration": "acceleration",
+    "w": "work",
+    "work": "work",
+    "p": "power",
+    "power": "power",
+}
+
+
+UNIT_TABLE = {
+    "energy": {"J": 1.0, "kJ": 1000.0},
+    "mass": {"kg": 1.0, "g": 0.001},
+    "speed": {
+        "m/s": 1.0,
+        "km/s": 1000.0,
+        "km/h": 1 / 3.6
+    },
+    "distance": {
+        "m": 1.0,
+        "cm": 0.01,
+        "km": 1000.0
+    },
+    "time": {
+        "s": 1.0,
+        "min": 60.0,
+        "h": 3600.0
+    },
+    "density": {
+        "kg/m3": 1.0,
+        "g/cm3": 1000.0
+    },
+    "volume": {
+        "m3": 1.0,
+        "L": 0.001,
+        "cm3": 1e-6
+    },
+    "force": {"N": 1.0, "kN": 1000.0},
+    "acceleration": {
+        "m/s2": 1.0,
+        "cm/s2": 0.01
+    },
+    "work": {"J": 1.0, "kJ": 1000.0},
+    "power": {"W": 1.0, "kW": 1000.0}
+}
+
+
+DEFAULT_UNITS = {
+    "energy": "J",
+    "mass": "kg",
+    "speed": "m/s",
+    "distance": "m",
+    "time": "s",
+    "density": "kg/m3",
+    "volume": "m3",
+    "force": "N",
+    "acceleration": "m/s2",
+    "work": "J",
+    "power": "W"
+}
+
+
+FORMULAS = {
+    "einstein": "E = mc²",
+    "speed": "v = d/t",
+    "density": "ρ = m/V",
+    "newton": "F = ma",
+    "work": "W = Fd",
+    "power": "P = W/t"
+}
+
+
+def normalize_variable(name):
+    key = str(name).strip().lower()
+
+    if key not in ALIASES:
+        raise ValueError(f"Unknown variable: {name}")
+
+    return ALIASES[key]
+
+
+def to_si(variable, value, unit):
+    variable = normalize_variable(variable)
+
+    if unit not in UNIT_TABLE[variable]:
+        raise ValueError(
+            f"Invalid unit {unit!r} for {variable}"
+        )
+
+    value = float(value)
+
+    if not math.isfinite(value):
+        raise ValueError("Input must be finite")
+
+    return value * UNIT_TABLE[variable][unit]
+
+
+def from_si(variable, value, unit):
+    variable = normalize_variable(variable)
+
+    if unit not in UNIT_TABLE[variable]:
+        raise ValueError(
+            f"Invalid output unit {unit!r} for {variable}"
+        )
+
+    return value / UNIT_TABLE[variable][unit]
+
+
+def safe_divide(a, b):
+    if b == 0:
+        raise ValueError("Division by zero")
+
+    return a / b
+
+
+# ============================================================
+# EQUATION REGISTRY
+# ============================================================
+
+EQUATIONS = {
+
+    "einstein": {
+        "variables": {"energy", "mass", "speed"},
+        "solvers": {
+            "energy": lambda x: x["mass"] * x["speed"]**2,
+            "mass": lambda x: safe_divide(
+                x["energy"], x["speed"]**2
+            ),
+            "speed": lambda x: math.sqrt(
+                safe_divide(x["energy"], x["mass"])
+            )
+        }
+    },
+
+    "speed": {
+        "variables": {"speed", "distance", "time"},
+        "solvers": {
+            "speed": lambda x: safe_divide(
+                x["distance"], x["time"]
+            ),
+            "distance": lambda x: x["speed"] * x["time"],
+            "time": lambda x: safe_divide(
+                x["distance"], x["speed"]
+            )
+        }
+    },
+
+    "density": {
+        "variables": {"density", "mass", "volume"},
+        "solvers": {
+            "density": lambda x: safe_divide(
+                x["mass"], x["volume"]
+            ),
+            "mass": lambda x: x["density"] * x["volume"],
+            "volume": lambda x: safe_divide(
+                x["mass"], x["density"]
+            )
+        }
+    },
+
+    "newton": {
+        "variables": {"force", "mass", "acceleration"},
+        "solvers": {
+            "force": lambda x: x["mass"] * x["acceleration"],
+            "mass": lambda x: safe_divide(
+                x["force"], x["acceleration"]
+            ),
+            "acceleration": lambda x: safe_divide(
+                x["force"], x["mass"]
+            )
+        }
+    },
+
+    "work": {
+        "variables": {"work", "force", "distance"},
+        "solvers": {
+            "work": lambda x: x["force"] * x["distance"],
+            "force": lambda x: safe_divide(
+                x["work"], x["distance"]
+            ),
+            "distance": lambda x: safe_divide(
+                x["work"], x["force"]
+            )
+        }
+    },
+
+    "power": {
+        "variables": {"power", "work", "time"},
+        "solvers": {
+            "power": lambda x: safe_divide(
+                x["work"], x["time"]
+            ),
+            "work": lambda x: x["power"] * x["time"],
+            "time": lambda x: safe_divide(
+                x["work"], x["power"]
+            )
+        }
+    }
+}
+
+
+# ============================================================
+# ADAPTIVE TOLERANCE
+# ============================================================
+
+class AdaptiveTolerance:
+
+    def __init__(self, tolerance=1e-6):
+        tolerance = float(tolerance)
+
+        if not math.isfinite(tolerance) or tolerance <= 0:
+            raise ValueError("Invalid adaptive tolerance")
+
+        self.log_tolerance = math.log(tolerance)
+        self.temperature = 0.5
+
+    @property
+    def tolerance(self):
+        return math.exp(self.log_tolerance)
+
+    def probability_valid(self, residual):
+
+        residual = float(residual)
+
+        if not math.isfinite(residual) or residual < 0:
+            return 0.0
+
+        residual = max(residual, 1e-16)
+
+        z = (
+            self.log_tolerance - math.log(residual)
+        ) / self.temperature
+
+        z = max(-60, min(60, z))
+
+        return 1.0 / (1.0 + math.exp(-z))
+
+
+# ============================================================
+# EQUATION SELECTION
+# ============================================================
+
+def select_equation(target, known_variables, equation_name=None):
+
+    target = normalize_variable(target)
+
+    known_variables = {
+        normalize_variable(x)
+        for x in known_variables
+    }
+
+    if equation_name is not None:
+
+        if equation_name not in EQUATIONS:
+            raise ValueError("Unknown equation")
+
+        equation = EQUATIONS[equation_name]
+
+        if target not in equation["solvers"]:
+            raise ValueError("Unsupported target")
+
+        expected = equation["variables"] - {target}
+
+        if known_variables != expected:
+            raise ValueError("Incompatible equation inputs")
+
+        return equation_name
+
+    matches = []
+
+    for name, equation in EQUATIONS.items():
+
+        expected = equation["variables"] - {target}
+
+        if (
+            target in equation["solvers"]
+            and known_variables == expected
+        ):
+            matches.append(name)
+
+    if len(matches) != 1:
+        raise ValueError(
+            "No unique compatible equation found"
+        )
+
+    return matches[0]
+
+
+# ============================================================
+# NUMERICAL RESIDUAL
+# ============================================================
+
+def equation_residual(name, values):
+
+    if name == "einstein":
+        lhs = values["energy"]
+        rhs = values["mass"] * values["speed"]**2
+
+    elif name == "speed":
+        lhs = values["speed"]
+        rhs = safe_divide(
+            values["distance"], values["time"]
+        )
+
+    elif name == "density":
+        lhs = values["density"]
+        rhs = safe_divide(
+            values["mass"], values["volume"]
+        )
+
+    elif name == "newton":
+        lhs = values["force"]
+        rhs = values["mass"] * values["acceleration"]
+
+    elif name == "work":
+        lhs = values["work"]
+        rhs = values["force"] * values["distance"]
+
+    elif name == "power":
+        lhs = values["power"]
+        rhs = safe_divide(
+            values["work"], values["time"]
+        )
+
+    else:
+        raise ValueError("Unknown equation")
+
+    scale = max(abs(lhs), abs(rhs), 1e-300)
+
+    return abs(lhs - rhs) / scale
+
+
+# ============================================================
+# MAIN PHOTON ENGINE
+# ============================================================
+
+class PhotonCoreV5:
+
+    def __init__(
+        self,
+        adaptive_model,
+        checkpoint=None
+    ):
+        self.adaptive_model = adaptive_model
+        self.checkpoint = checkpoint
+
+    def validate_result(self, equation_name, values):
+
+        residual = equation_residual(
+            equation_name, values
+        )
+
+        probability = (
+            self.adaptive_model.probability_valid(residual)
+        )
+
+        return {
+            "accepted": probability >= 0.5,
+            "residual": residual,
+            "tolerance": self.adaptive_model.tolerance,
+            "probability": probability
+        }
+
+    def solve(
+        self,
+        target,
+        known_values,
+        equation_name=None,
+        target_unit=None
+    ):
+
+        target = normalize_variable(target)
+
+        if not isinstance(known_values, dict) or not known_values:
+            raise ValueError("Provide a non-empty dictionary")
+
+        values = {}
+
+        for name, item in known_values.items():
+
+            variable = normalize_variable(name)
+
+            if variable in values:
+                raise ValueError("Duplicate variable")
+
+            if not isinstance(item, (tuple, list)) or len(item) != 2:
+                raise ValueError(
+                    f"{variable} must be (value, unit)"
+                )
+
+            value, unit = item
+
+            values[variable] = to_si(
+                variable, value, unit
+            )
+
+        if target in values:
+            raise ValueError("Target already supplied")
+
+        selected = select_equation(
+            target,
+            values.keys(),
+            equation_name
+        )
+
+        nonnegative = {
+            "energy", "mass", "speed", "distance",
+            "time", "density", "volume", "force",
+            "work", "power"
+        }
+
+        for variable, value in values.items():
+
+            if variable in nonnegative and value < 0:
+                raise ValueError(
+                    f"{variable} cannot be negative"
+                )
+
+        result_si = EQUATIONS[selected]["solvers"][target](
+            values
+        )
+
+        if not math.isfinite(result_si):
+            raise ValueError("Non-finite calculation result")
+
+        if target in nonnegative and result_si < 0:
+            raise ValueError("Negative result is invalid")
+
+        complete = dict(values)
+        complete[target] = result_si
+
+        validation = self.validate_result(
+            selected, complete
+        )
+
+        if not validation["accepted"]:
+            raise ArithmeticError(
+                "Numerical validation failed"
+            )
+
+        unit = target_unit or DEFAULT_UNITS[target]
+
+        result = from_si(target, result_si, unit)
+
+        return {
+            "equation": selected,
+            "formula": FORMULAS[selected],
+            "target": target,
+            "result": result,
+            "unit": unit,
+            "si_result": result_si,
+            "residual": validation["residual"],
+            "adaptive_tolerance": validation["tolerance"],
+            "validation_probability": validation["probability"]
+        }
+
+    def convert(self, variable, value, input_unit, output_unit):
+
+        si = to_si(variable, value, input_unit)
+
+        return from_si(variable, si, output_unit)
+
+
+# ============================================================
+# HUGGING FACE CHECKPOINT INITIALIZATION
+# ============================================================
+
+def load_checkpoint(
+    repo_id=HF_REPO_ID,
+    filename=HF_FILENAME,
+    local_path=None
+):
+
+    if local_path is None:
+
+        from huggingface_hub import hf_hub_download
+
+        print("[PHOTON] Downloading checkpoint...")
+
+        local_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            repo_type="model"
+        )
+
+    if not os.path.isfile(local_path):
+        raise FileNotFoundError(local_path)
+
+    import torch
+
+    try:
+        checkpoint = torch.load(
+            local_path,
+            map_location="cpu",
+            weights_only=True
+        )
+    except Exception as exc:
+        raise RuntimeError(
+            "Checkpoint could not be safely loaded. "
+            "Check the checkpoint format."
+        ) from exc
+
+    if not isinstance(checkpoint, dict):
+        raise ValueError("Invalid checkpoint structure")
+
+    required = {
+        "version",
+        "equations",
+        "solving_directions",
+        "learned_tolerance"
+    }
+
+    if not required.issubset(checkpoint):
+        raise ValueError("Checkpoint metadata is incomplete")
+
+    if checkpoint["version"] != "V5":
+        raise ValueError("Incorrect Photon checkpoint version")
+
+    if set(checkpoint["equations"]) != set(EQUATIONS):
+        raise ValueError("Equation registry mismatch")
+
+    if checkpoint["solving_directions"] != 18:
+        raise ValueError("Incorrect solving direction count")
+
+    tolerance = float(checkpoint["learned_tolerance"])
+
+    if not math.isfinite(tolerance) or tolerance <= 0:
+        raise ValueError("Invalid saved tolerance")
+
+    print("[PHOTON] Checkpoint verified.")
+    print("[PHOTON] Saved tolerance:", tolerance)
+
+    return checkpoint
+
+
+# ============================================================
+# PUBLIC INITIALIZATION
+# ============================================================
+
+def initialize(
+    download_checkpoint=True,
+    checkpoint_path=None,
+    repo_id=HF_REPO_ID
+):
+
+    checkpoint = None
+
+    if download_checkpoint:
+
+        checkpoint = load_checkpoint(
+            repo_id=repo_id,
+            local_path=checkpoint_path
+        )
+
+        tolerance = float(
+            checkpoint["learned_tolerance"]
+        )
+
+    else:
+        tolerance = 1e-6
+
+    adaptive_model = AdaptiveTolerance(tolerance)
+
+    photon = PhotonCoreV5(
+        adaptive_model,
+        checkpoint=checkpoint
+    )
+
+    print("=" * 60)
+    print("SUPERNOVA TERAILLM — PHOTON-1 V5")
+    print("=" * 60)
+    print("Initialization: SUCCESS")
+    print("Equations:", len(EQUATIONS))
+    print("Solving directions:", 18)
+    print("Adaptive parameters:", 1)
+    print("Checkpoint loaded:", checkpoint is not None)
+    print("Execution: LOCAL")
+    print("=" * 60)
+
+    return photon

Supernova_photon/v5.py

@@ -0,0 +1,21 @@
+from .engine import initialize, PhotonCoreV5
+
+def photon(
+    download_checkpoint=True,
+    checkpoint_path=None,
+    repo_id="Supernova11c/Supernova-Photon-1-V5"
+):
+    """
+    Initialize Photon-1 V5.
+
+    Downloads and verifies the Hugging Face checkpoint
+    by default. Calculations run locally.
+    """
+
+    return initialize(
+        download_checkpoint=download_checkpoint,
+        checkpoint_path=checkpoint_path,
+        repo_id=repo_id
+    )
+
+__all__ = ["photon", "PhotonCoreV5"]

supernova_photon-0.1.1.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: supernova-photon
+Version: 0.1.1
+Summary: Supernova Photon-1 V5 mathematical computing engine
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: torch>=2.0
+
+# Supernova Photon-1 V5
+
+A local mathematical computation library developed by Supernova.
+
+## Installation
+
+```bash
+pip install supernova-photon
+```
+
+## Initialization
+
+```python
+from Supernova_photon import v5
+
+photon = v5.photon()
+```
+
+## Example
+
+```python
+result = photon.solve(
+    "speed",
+    {
+        "distance": (100, "m"),
+        "time": (10, "s")
+    }
+)
+
+print(result)
+```
+
+## Supported equations
+
+- Einstein: E = mc²
+- Speed: v = d/t
+- Density: rho = m/V
+- Newton: F = ma
+- Work: W = Fd
+- Power: P = W/t
+
+The checkpoint is downloaded from Hugging Face during
+initialization. Calculations are performed locally.
+
+The checkpoint provides saved calibration and metadata.
+It is not an executable neural arithmetic model.

supernova_photon-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+Supernova_photon/__init__.py,sha256=mVqILiW0BwbPq4vtJxhDdghxOLQw_vvXeFZFGqPPaWs,58
+Supernova_photon/cli.py,sha256=torVaBfxrXeC6frNlY7IA-2pTGPjlVg-NOI0Xeel87w,2222
+Supernova_photon/engine.py,sha256=2hcp8V3cC_sfeLP-3D1tiswKAH7Q45LC_toEEm485o0,14537
+Supernova_photon/v5.py,sha256=6iLau3-XAfv2YwH6QZJFsOZ4R7E3Is5ZARBlrCJnv5g,490
+supernova_photon-0.1.1.dist-info/METADATA,sha256=KoLxYMeU2jJMs1diFZ_DPZlPmuY_WIbHu5EeG6MNGHw,1172
+supernova_photon-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+supernova_photon-0.1.1.dist-info/entry_points.txt,sha256=wdekc2K9yCdcrgiUSuxCNLx4ydZRbjHD1hHCMTL2W8U,53
+supernova_photon-0.1.1.dist-info/top_level.txt,sha256=Rb0AFGSma0VsuGV8NqMrj5UKuYdu4zNXoMVQk3mmgn0,17
+supernova_photon-0.1.1.dist-info/RECORD,,

supernova_photon-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

supernova_photon-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+photon = Supernova_photon.cli:main

supernova_photon-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+Supernova_photon