mobius-number 0.1.0__tar.gz

mobius_number-0.1.0/.gitignore

@@ -0,0 +1,13 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.pytest_cache/
+.mypy_cache/
+.tox/
+.venv/
+venv/

mobius_number-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jay Carpenter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

mobius_number-0.1.0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: mobius-number
+Version: 0.1.0
+Summary: Complementary residue arithmetic — 0.1 + 0.2 = 0.3, exactly.
+Project-URL: Homepage, https://github.com/JustNothingJay/mobius-number
+Project-URL: Repository, https://github.com/JustNothingJay/mobius-number
+Project-URL: Issues, https://github.com/JustNothingJay/mobius-number/issues
+Author: Jay Carpenter
+License: MIT
+License-File: LICENSE
+Keywords: IEEE-754,arithmetic,complementary-residue,exact,floating-point,mobius,precision,rational
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# MöbiusNumber
+
+**0.1 + 0.2 = 0.3. Exactly.**
+
+```python
+from mobius_number import M
+
+>>> 0.1 + 0.2 == 0.3
+False
+
+>>> M("0.1") + M("0.2") == M("0.3")
+True
+```
+
+A number type that carries its own correction. No rounding error. No epsilon comparisons. No workarounds.
+
+## Install
+
+```
+pip install mobius-number
+```
+
+## The Problem
+
+Every computer in the world gets this wrong:
+
+```python
+>>> 0.1 + 0.2
+0.30000000000000004
+
+>>> 0.1 + 0.2 == 0.3
+False
+```
+
+This has been true since 1985 when IEEE 754 was published. The reason: computers store numbers in base 2. The number 0.1 in binary is a repeating fraction — like 1/3 in decimal (0.333...). It gets rounded. Then 0.2 gets rounded. The rounding errors stack.
+
+Every workaround — arbitrary precision, interval arithmetic, posit numbers — tries to fix the math layer while leaving the foundation untouched: the number is stored in the form the transistor speaks, and the human adapts.
+
+**What if the representation served the number instead?**
+
+## The Idea
+
+DNA has two strands. Every base carries its complement — A pairs with T, G pairs with C. There is no excess. The complement consumes what the original doesn't cover.
+
+A Möbius strip has one surface. Traversing the full loop covers both "sides" and returns to the origin.
+
+A MöbiusNumber stores two strands:
+
+- **The binary strand** — `float64`, hardware-fast, carries rounding error
+- **The rational strand** — exact `Fraction`, no loss, no repeating
+
+They are not two separate representations. They are one object. The binary strand is the shadow. The rational strand is the substance. **On collapse, the rational governs.**
+
+```
+CURRENT (IEEE 754):
+  Store 0.1 → 0.1000000000000000055511...
+  Residue:     0.0000000000000000055511...  ← THROWN AWAY
+
+MöbiusNumber:
+  Binary strand:   0.1000000000000000055511...
+  Rational strand: 1/10
+  Anti (residue):  exact_value − binary_value
+  Collapse:        the rational governs → 0.1 exactly
+```
+
+Arithmetic propagates both strands. When you add two MöbiusNumbers, the rationals add exactly. The floats add approximately. **The error exists but is never consulted for truth.** The anti-strand is always present, always correct, and annihilates the rounding error on collapse.
+
+## Proof
+
+```
+$ python -c "from mobius_number import M; print(M('0.1') + M('0.2') == M('0.3'))"
+True
+```
+
+### The Famous Failures — All Fixed
+
+| Test | IEEE 754 | MöbiusNumber |
+|------|----------|--------------|
+| `0.1 + 0.2 == 0.3` | **False** | **True** |
+| `(1/49) * 49 == 1` | **False** | **True** |
+| `(1 + 1e-16) - 1` | **0.0** (total loss) | **1e-16** (exact) |
+| `0.1 * 10 == 1.0` | True¹ | True |
+| `$10 / 3 * 3 == $10` | True¹ | True |
+| `0.01 * 100 == 1.0` | True¹ | True |
+| `(1/7) * 7 == 1` | **False** | **True** |
+| `0.001 added 1000×` | **False** | **True** |
+
+¹ IEEE 754 gets these by luck — the rounding errors happen to cancel. The MöbiusNumber gets them by construction.
+
+### Strand Anatomy
+
+```python
+from mobius_number import M
+
+n = M("0.1")
+print(n.diagnose())
+# {
+#   'binary_strand': 0.1,
+#   'rational_strand': '1/10',
+#   'residue': '-1/180143985094819840',
+#   'residue_float': -5.55e-18,
+#   'collapsed': 0.1
+# }
+```
+
+The residue is the anti-strand — the exact complement of the binary error. It exists. It is never discarded. On collapse, the Möbius strip closes.
+
+## Usage
+
+```python
+from mobius_number import M
+
+# Basic arithmetic
+a = M("0.1")
+b = M("0.2")
+c = a + b          # M('3/10')
+c.collapse()        # 0.3
+
+# Financial
+price = M("19.99")
+tax = price * M("0.0825")
+total = price + tax  # Exact
+
+# Comparison — the rational governs
+M("0.1") + M("0.2") == M("0.3")  # True — always
+
+# Interop with plain numbers
+M("0.5") + 1        # M('3/2')
+3 * M("0.1")         # M('3/10')
+
+# Inspect the strands
+n = M("0.1")
+n.approx             # 0.1 (the float — fast, lossy)
+n.exact              # Fraction(1, 10) (the truth)
+n.residue            # Fraction(-1, 180143985094819840)
+```
+
+## Why Not Just Use `Fraction`?
+
+You can. Python's `fractions.Fraction` gives exact rational arithmetic. But:
+
+1. **Speed** — MöbiusNumber carries a float for fast approximate work. Use `.approx` in hot loops, `.collapse()` when you need truth.
+2. **Drop-in intent** — `M("0.1")` reads like a number. `Fraction("0.1")` reads like a workaround.
+3. **The conceptual point** — the number and its correction are one object. The anti-strand is not a separate operation. It is intrinsic. Like DNA. Like a Möbius strip.
+
+## How It Works
+
+Every MöbiusNumber is internally:
+
+```
+(_approx: float, _exact: Fraction)
+```
+
+- **Construction from string**: `M("0.1")` → `_exact = Fraction("0.1") = 1/10`; `_approx = float(1/10)`
+- **Construction from float**: `M(0.1)` → recovers the rational intent via `limit_denominator`
+- **Arithmetic**: both strands propagate independently through `+`, `-`, `*`, `/`, `**`
+- **Comparison**: always uses `_exact` — the rational strand governs all equality and ordering
+- **Collapse**: `float(_exact)` — the Möbius traversal returns the exact value
+
+No external dependencies. Pure Python. Works on 3.9+.
+
+## The Name
+
+A Möbius strip is a surface with one side. If you trace a line along it, you cover both "sides" and return to the origin having traversed the whole thing. There is no front and back — only one continuous surface.
+
+A MöbiusNumber is a number with one identity. The binary approximation and the exact rational are not two things — they are one object that, when fully traversed, resolves to the truth. The representation IS the correction.
+
+## Author
+
+Jay Carpenter — [SECS Research](https://github.com/JustNothingJay/SECS_Research)
+
+## License
+
+MIT

mobius_number-0.1.0/README.md

@@ -0,0 +1,174 @@
+# MöbiusNumber
+
+**0.1 + 0.2 = 0.3. Exactly.**
+
+```python
+from mobius_number import M
+
+>>> 0.1 + 0.2 == 0.3
+False
+
+>>> M("0.1") + M("0.2") == M("0.3")
+True
+```
+
+A number type that carries its own correction. No rounding error. No epsilon comparisons. No workarounds.
+
+## Install
+
+```
+pip install mobius-number
+```
+
+## The Problem
+
+Every computer in the world gets this wrong:
+
+```python
+>>> 0.1 + 0.2
+0.30000000000000004
+
+>>> 0.1 + 0.2 == 0.3
+False
+```
+
+This has been true since 1985 when IEEE 754 was published. The reason: computers store numbers in base 2. The number 0.1 in binary is a repeating fraction — like 1/3 in decimal (0.333...). It gets rounded. Then 0.2 gets rounded. The rounding errors stack.
+
+Every workaround — arbitrary precision, interval arithmetic, posit numbers — tries to fix the math layer while leaving the foundation untouched: the number is stored in the form the transistor speaks, and the human adapts.
+
+**What if the representation served the number instead?**
+
+## The Idea
+
+DNA has two strands. Every base carries its complement — A pairs with T, G pairs with C. There is no excess. The complement consumes what the original doesn't cover.
+
+A Möbius strip has one surface. Traversing the full loop covers both "sides" and returns to the origin.
+
+A MöbiusNumber stores two strands:
+
+- **The binary strand** — `float64`, hardware-fast, carries rounding error
+- **The rational strand** — exact `Fraction`, no loss, no repeating
+
+They are not two separate representations. They are one object. The binary strand is the shadow. The rational strand is the substance. **On collapse, the rational governs.**
+
+```
+CURRENT (IEEE 754):
+  Store 0.1 → 0.1000000000000000055511...
+  Residue:     0.0000000000000000055511...  ← THROWN AWAY
+
+MöbiusNumber:
+  Binary strand:   0.1000000000000000055511...
+  Rational strand: 1/10
+  Anti (residue):  exact_value − binary_value
+  Collapse:        the rational governs → 0.1 exactly
+```
+
+Arithmetic propagates both strands. When you add two MöbiusNumbers, the rationals add exactly. The floats add approximately. **The error exists but is never consulted for truth.** The anti-strand is always present, always correct, and annihilates the rounding error on collapse.
+
+## Proof
+
+```
+$ python -c "from mobius_number import M; print(M('0.1') + M('0.2') == M('0.3'))"
+True
+```
+
+### The Famous Failures — All Fixed
+
+| Test | IEEE 754 | MöbiusNumber |
+|------|----------|--------------|
+| `0.1 + 0.2 == 0.3` | **False** | **True** |
+| `(1/49) * 49 == 1` | **False** | **True** |
+| `(1 + 1e-16) - 1` | **0.0** (total loss) | **1e-16** (exact) |
+| `0.1 * 10 == 1.0` | True¹ | True |
+| `$10 / 3 * 3 == $10` | True¹ | True |
+| `0.01 * 100 == 1.0` | True¹ | True |
+| `(1/7) * 7 == 1` | **False** | **True** |
+| `0.001 added 1000×` | **False** | **True** |
+
+¹ IEEE 754 gets these by luck — the rounding errors happen to cancel. The MöbiusNumber gets them by construction.
+
+### Strand Anatomy
+
+```python
+from mobius_number import M
+
+n = M("0.1")
+print(n.diagnose())
+# {
+#   'binary_strand': 0.1,
+#   'rational_strand': '1/10',
+#   'residue': '-1/180143985094819840',
+#   'residue_float': -5.55e-18,
+#   'collapsed': 0.1
+# }
+```
+
+The residue is the anti-strand — the exact complement of the binary error. It exists. It is never discarded. On collapse, the Möbius strip closes.
+
+## Usage
+
+```python
+from mobius_number import M
+
+# Basic arithmetic
+a = M("0.1")
+b = M("0.2")
+c = a + b          # M('3/10')
+c.collapse()        # 0.3
+
+# Financial
+price = M("19.99")
+tax = price * M("0.0825")
+total = price + tax  # Exact
+
+# Comparison — the rational governs
+M("0.1") + M("0.2") == M("0.3")  # True — always
+
+# Interop with plain numbers
+M("0.5") + 1        # M('3/2')
+3 * M("0.1")         # M('3/10')
+
+# Inspect the strands
+n = M("0.1")
+n.approx             # 0.1 (the float — fast, lossy)
+n.exact              # Fraction(1, 10) (the truth)
+n.residue            # Fraction(-1, 180143985094819840)
+```
+
+## Why Not Just Use `Fraction`?
+
+You can. Python's `fractions.Fraction` gives exact rational arithmetic. But:
+
+1. **Speed** — MöbiusNumber carries a float for fast approximate work. Use `.approx` in hot loops, `.collapse()` when you need truth.
+2. **Drop-in intent** — `M("0.1")` reads like a number. `Fraction("0.1")` reads like a workaround.
+3. **The conceptual point** — the number and its correction are one object. The anti-strand is not a separate operation. It is intrinsic. Like DNA. Like a Möbius strip.
+
+## How It Works
+
+Every MöbiusNumber is internally:
+
+```
+(_approx: float, _exact: Fraction)
+```
+
+- **Construction from string**: `M("0.1")` → `_exact = Fraction("0.1") = 1/10`; `_approx = float(1/10)`
+- **Construction from float**: `M(0.1)` → recovers the rational intent via `limit_denominator`
+- **Arithmetic**: both strands propagate independently through `+`, `-`, `*`, `/`, `**`
+- **Comparison**: always uses `_exact` — the rational strand governs all equality and ordering
+- **Collapse**: `float(_exact)` — the Möbius traversal returns the exact value
+
+No external dependencies. Pure Python. Works on 3.9+.
+
+## The Name
+
+A Möbius strip is a surface with one side. If you trace a line along it, you cover both "sides" and return to the origin having traversed the whole thing. There is no front and back — only one continuous surface.
+
+A MöbiusNumber is a number with one identity. The binary approximation and the exact rational are not two things — they are one object that, when fully traversed, resolves to the truth. The representation IS the correction.
+
+## Author
+
+Jay Carpenter — [SECS Research](https://github.com/JustNothingJay/SECS_Research)
+
+## License
+
+MIT

mobius_number-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mobius-number"
+version = "0.1.0"
+description = "Complementary residue arithmetic — 0.1 + 0.2 = 0.3, exactly."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [
+    { name = "Jay Carpenter" },
+]
+keywords = [
+    "floating-point",
+    "arithmetic",
+    "precision",
+    "IEEE-754",
+    "exact",
+    "rational",
+    "mobius",
+    "complementary-residue",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://github.com/JustNothingJay/mobius-number"
+Repository = "https://github.com/JustNothingJay/mobius-number"
+Issues = "https://github.com/JustNothingJay/mobius-number/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mobius_number"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

mobius_number-0.1.0/src/mobius_number/__init__.py

@@ -0,0 +1,29 @@
+"""
+MöbiusNumber — Complementary Residue Arithmetic
+
+Every number is stored as two strands:
+  - The binary approximation (float64, hardware-fast)
+  - The exact rational identity (numerator/denominator, no loss)
+
+They are not two representations. They are one object — like DNA's
+double helix, like a Möbius strip traversed fully. The approximation
+and its anti coexist. On collapse, the rational governs.
+
+The float gives you speed.
+The rational gives you truth.
+Collapse gives you both.
+
+    >>> from mobius_number import M
+    >>> M("0.1") + M("0.2") == M("0.3")
+    True
+
+Jay Carpenter, 2026
+"""
+
+from mobius_number.core import MobiusNumber
+
+# Convenience alias
+M = MobiusNumber
+
+__version__ = "0.1.0"
+__all__ = ["MobiusNumber", "M"]

mobius_number-0.1.0/src/mobius_number/core.py

@@ -0,0 +1,223 @@
+"""
+MöbiusNumber core implementation.
+
+A number that carries its own correction. Two strands — the binary
+approximation and the exact rational identity — coexist as one object.
+On collapse, the rational governs.
+
+The structure mirrors DNA: every base carries its complement.
+The topology is Möbius: traversing the full loop returns the exact value.
+"""
+
+from fractions import Fraction
+from typing import Union
+
+
+class MobiusNumber:
+    """
+    A number that carries its own correction.
+
+    Internally:
+      _approx  : float    — the binary strand (fast, lossy)
+      _exact   : Fraction  — the anti strand (exact, complete)
+
+    The float is the shadow. The Fraction is the substance.
+    Collapse = the Möbius traversal → exact output.
+
+    Construction:
+      MobiusNumber("0.1")      — from string (purest: "0.1" means exactly 1/10)
+      MobiusNumber(0.1)        — from float (recovers rational intent)
+      MobiusNumber(1)          — from int (exact)
+      MobiusNumber(Fraction(1, 10))  — from Fraction (exact)
+    """
+
+    __slots__ = ('_approx', '_exact')
+
+    def __init__(self, value: Union[int, float, str, Fraction, 'MobiusNumber']):
+        if isinstance(value, MobiusNumber):
+            self._approx = value._approx
+            self._exact = value._exact
+        elif isinstance(value, Fraction):
+            self._exact = value
+            self._approx = float(value)
+        elif isinstance(value, int):
+            self._exact = Fraction(value)
+            self._approx = float(value)
+        elif isinstance(value, float):
+            self._approx = value
+            self._exact = Fraction(value).limit_denominator(10**15)
+        elif isinstance(value, str):
+            self._exact = Fraction(value)
+            self._approx = float(self._exact)
+        else:
+            raise TypeError(f"Cannot create MobiusNumber from {type(value)}")
+
+    # ------------------------------------------------------------------
+    # Strand access
+    # ------------------------------------------------------------------
+
+    @property
+    def approx(self) -> float:
+        """The binary strand — hardware-fast, carries rounding error."""
+        return self._approx
+
+    @property
+    def exact(self) -> Fraction:
+        """The rational strand — exact, no loss."""
+        return self._exact
+
+    @property
+    def residue(self) -> Fraction:
+        """The anti-strand: exact_value − binary_approximation."""
+        return self._exact - Fraction(self._approx)
+
+    # ------------------------------------------------------------------
+    # Collapse — the Möbius traversal
+    # ------------------------------------------------------------------
+
+    def collapse(self) -> float:
+        """
+        Traverse the full Möbius loop.
+        Binary approximation + anti-strand residue → exact value.
+        """
+        return float(self._exact)
+
+    # ------------------------------------------------------------------
+    # Arithmetic — both strands propagate
+    # ------------------------------------------------------------------
+
+    def __add__(self, other):
+        other = _coerce(other)
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = self._exact + other._exact
+        result._approx = self._approx + other._approx
+        return result
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        other = _coerce(other)
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = self._exact - other._exact
+        result._approx = self._approx - other._approx
+        return result
+
+    def __rsub__(self, other):
+        other = _coerce(other)
+        return other.__sub__(self)
+
+    def __mul__(self, other):
+        other = _coerce(other)
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = self._exact * other._exact
+        result._approx = self._approx * other._approx
+        return result
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __truediv__(self, other):
+        other = _coerce(other)
+        if other._exact == 0:
+            raise ZeroDivisionError("MobiusNumber division by zero")
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = self._exact / other._exact
+        result._approx = self._approx / other._approx
+        return result
+
+    def __rtruediv__(self, other):
+        other = _coerce(other)
+        return other.__truediv__(self)
+
+    def __neg__(self):
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = -self._exact
+        result._approx = -self._approx
+        return result
+
+    def __abs__(self):
+        result = MobiusNumber.__new__(MobiusNumber)
+        result._exact = abs(self._exact)
+        result._approx = abs(self._approx)
+        return result
+
+    def __pow__(self, exp):
+        if isinstance(exp, int):
+            result = MobiusNumber.__new__(MobiusNumber)
+            result._exact = self._exact ** exp
+            result._approx = self._approx ** exp
+            return result
+        return NotImplemented
+
+    # ------------------------------------------------------------------
+    # Comparison — the rational governs, always
+    # ------------------------------------------------------------------
+
+    def __eq__(self, other):
+        if not isinstance(other, (MobiusNumber, int, float, str, Fraction)):
+            return NotImplemented
+        other = _coerce(other)
+        return self._exact == other._exact
+
+    def __ne__(self, other):
+        if not isinstance(other, (MobiusNumber, int, float, str, Fraction)):
+            return NotImplemented
+        other = _coerce(other)
+        return self._exact != other._exact
+
+    def __lt__(self, other):
+        other = _coerce(other)
+        return self._exact < other._exact
+
+    def __le__(self, other):
+        other = _coerce(other)
+        return self._exact <= other._exact
+
+    def __gt__(self, other):
+        other = _coerce(other)
+        return self._exact > other._exact
+
+    def __ge__(self, other):
+        other = _coerce(other)
+        return self._exact >= other._exact
+
+    # ------------------------------------------------------------------
+    # Display
+    # ------------------------------------------------------------------
+
+    def __repr__(self):
+        return f"M('{self._exact}')"
+
+    def __str__(self):
+        return str(float(self._exact))
+
+    def __float__(self):
+        return float(self._exact)
+
+    def __int__(self):
+        return int(self._exact)
+
+    def __hash__(self):
+        return hash(self._exact)
+
+    # ------------------------------------------------------------------
+    # Diagnostic
+    # ------------------------------------------------------------------
+
+    def diagnose(self) -> dict:
+        """Return both strands and the residue between them."""
+        return {
+            "binary_strand": self._approx,
+            "rational_strand": str(self._exact),
+            "residue": str(self.residue),
+            "residue_float": float(self.residue),
+            "collapsed": self.collapse(),
+        }
+
+
+def _coerce(value) -> MobiusNumber:
+    """Convert a raw value into a MobiusNumber."""
+    if isinstance(value, MobiusNumber):
+        return value
+    return MobiusNumber(value)

mobius_number-0.1.0/tests/test_mobius.py

@@ -0,0 +1,293 @@
+"""Tests for MöbiusNumber — complementary residue arithmetic."""
+
+import pytest
+from fractions import Fraction
+from mobius_number import MobiusNumber, M
+
+
+# =====================================================================
+# THE PROOF: 0.1 + 0.2 = 0.3
+# =====================================================================
+
+class TestTheProof:
+    """The problem that started it all."""
+
+    def test_ieee754_fails(self):
+        """IEEE 754 gets this wrong. This is not a bug — it's the spec."""
+        assert 0.1 + 0.2 != 0.3  # The 41-year-old problem
+
+    def test_mobius_solves_it(self):
+        """MöbiusNumber gets it right."""
+        assert M("0.1") + M("0.2") == M("0.3")
+
+    def test_collapse_is_exact(self):
+        result = M("0.1") + M("0.2")
+        assert result.collapse() == 0.3
+
+    def test_error_is_zero(self):
+        result = M("0.1") + M("0.2")
+        target = M("0.3")
+        assert result.exact - target.exact == Fraction(0)
+
+
+# =====================================================================
+# CONSTRUCTION
+# =====================================================================
+
+class TestConstruction:
+    """Every input path must produce the correct rational strand."""
+
+    def test_from_string(self):
+        n = M("0.1")
+        assert n.exact == Fraction(1, 10)
+
+    def test_from_int(self):
+        n = M(42)
+        assert n.exact == Fraction(42)
+        assert n.approx == 42.0
+
+    def test_from_float(self):
+        n = M(0.5)
+        assert n.exact == Fraction(1, 2)
+
+    def test_from_fraction(self):
+        n = M(Fraction(1, 7))
+        assert n.exact == Fraction(1, 7)
+
+    def test_from_mobius(self):
+        a = M("3.14")
+        b = M(a)
+        assert b.exact == a.exact
+
+    def test_from_negative_string(self):
+        n = M("-0.1")
+        assert n.exact == Fraction(-1, 10)
+
+    def test_from_zero(self):
+        n = M(0)
+        assert n.exact == Fraction(0)
+        assert n.approx == 0.0
+
+    def test_invalid_type_raises(self):
+        with pytest.raises(TypeError):
+            M([1, 2, 3])
+
+
+# =====================================================================
+# ARITHMETIC
+# =====================================================================
+
+class TestArithmetic:
+    """Both strands must propagate through every operation."""
+
+    def test_addition(self):
+        assert (M("0.1") + M("0.2")).exact == Fraction(3, 10)
+
+    def test_subtraction(self):
+        assert (M("0.3") - M("0.1")).exact == Fraction(1, 5)
+
+    def test_multiplication(self):
+        assert (M("0.1") * M("10")).exact == Fraction(1)
+
+    def test_division(self):
+        assert (M("1") / M("3")).exact == Fraction(1, 3)
+
+    def test_negation(self):
+        assert (-M("0.5")).exact == Fraction(-1, 2)
+
+    def test_abs(self):
+        assert abs(M("-7")).exact == Fraction(7)
+
+    def test_power(self):
+        assert (M("3") ** 2).exact == Fraction(9)
+
+    def test_division_by_zero(self):
+        with pytest.raises(ZeroDivisionError):
+            M("1") / M("0")
+
+    def test_radd(self):
+        result = 1 + M("0.5")
+        assert result.exact == Fraction(3, 2)
+
+    def test_rsub(self):
+        result = 1 - M("0.3")
+        assert result.exact == Fraction(7, 10)
+
+    def test_rmul(self):
+        result = 3 * M("0.1")
+        assert result.exact == Fraction(3, 10)
+
+    def test_rtruediv(self):
+        result = 1 / M("3")
+        assert result.exact == Fraction(1, 3)
+
+
+# =====================================================================
+# THE FAMOUS FAILURES
+# =====================================================================
+
+class TestFamousFailures:
+    """Every classic IEEE 754 failure, corrected."""
+
+    def test_sum_point_one_ten_times(self):
+        """0.1 added 10 times should equal 1.0."""
+        total = M("0.0")
+        for _ in range(10):
+            total = total + M("0.1")
+        assert total == M("1.0")
+
+    def test_one_forty_ninth_times_forty_nine(self):
+        """(1/49) * 49 should equal 1."""
+        assert (M("1") / M("49")) * M("49") == M("1")
+
+    def test_one_third_times_three(self):
+        """(1/3) * 3 should equal 1."""
+        assert (M("1") / M("3")) * M("3") == M("1")
+
+    def test_ten_divided_by_three_times_three(self):
+        """$10.00 / 3 * 3 should equal $10.00."""
+        assert (M("10") / M("3")) * M("3") == M("10")
+
+    def test_catastrophic_cancellation(self):
+        """(1 + 1e-16) - 1 should equal 1e-16, not 0."""
+        result = (M("1") + M("0.0000000000000001")) - M("1")
+        assert result.exact == Fraction(1, 10**16)
+        assert result.collapse() == 1e-16
+
+    def test_ieee_catastrophic_cancellation_loses(self):
+        """IEEE 754 loses this entirely — returns 0."""
+        assert (1.0 + 1e-16) - 1.0 == 0.0  # Total information loss
+
+    def test_one_seventh_round_trip(self):
+        """1/7 * 7 = 1 exactly."""
+        assert (M("1") / M("7")) * M("7") == M("1")
+
+    def test_penny_accumulation(self):
+        """Add $0.01 one hundred times = $1.00."""
+        total = M("0.0")
+        for _ in range(100):
+            total = total + M("0.01")
+        assert total == M("1.0")
+
+
+# =====================================================================
+# COMPARISON — THE RATIONAL GOVERNS
+# =====================================================================
+
+class TestComparison:
+    """Equality and ordering use the rational strand, not the float."""
+
+    def test_equality(self):
+        assert M("0.1") == M("0.1")
+
+    def test_inequality(self):
+        assert M("0.1") != M("0.2")
+
+    def test_less_than(self):
+        assert M("0.1") < M("0.2")
+
+    def test_less_equal(self):
+        assert M("0.1") <= M("0.1")
+        assert M("0.1") <= M("0.2")
+
+    def test_greater_than(self):
+        assert M("0.2") > M("0.1")
+
+    def test_greater_equal(self):
+        assert M("0.2") >= M("0.2")
+        assert M("0.2") >= M("0.1")
+
+    def test_cross_type_equality(self):
+        assert M("5") == M(5)
+
+    def test_hash_consistency(self):
+        """Equal MöbiusNumbers must have equal hashes."""
+        a = M("0.1") + M("0.2")
+        b = M("0.3")
+        assert hash(a) == hash(b)
+
+    def test_usable_as_dict_key(self):
+        d = {M("0.3"): "found"}
+        key = M("0.1") + M("0.2")
+        assert d[key] == "found"
+
+
+# =====================================================================
+# STRAND ANATOMY
+# =====================================================================
+
+class TestStrands:
+    """The residue (anti-strand) must be the exact complement."""
+
+    def test_residue_of_point_one(self):
+        n = M("0.1")
+        # residue = exact - Fraction(approx)
+        # exact is 1/10, approx is the nearest float
+        assert n.residue == Fraction(1, 10) - Fraction(0.1)
+
+    def test_residue_of_integer_is_zero(self):
+        n = M(1)
+        assert n.residue == Fraction(0)
+
+    def test_residue_of_half_is_zero(self):
+        n = M("0.5")
+        assert n.residue == Fraction(0)  # 0.5 is exact in binary
+
+    def test_diagnose_returns_dict(self):
+        d = M("0.1").diagnose()
+        assert "binary_strand" in d
+        assert "rational_strand" in d
+        assert "residue" in d
+        assert "collapsed" in d
+
+
+# =====================================================================
+# DISPLAY
+# =====================================================================
+
+class TestDisplay:
+    """String output must show the collapsed (exact) value."""
+
+    def test_str(self):
+        assert str(M("0.3")) == "0.3"
+
+    def test_repr(self):
+        assert repr(M("0.1")) == "M('1/10')"
+
+    def test_float_conversion(self):
+        assert float(M("0.5")) == 0.5
+
+    def test_int_conversion(self):
+        assert int(M("42")) == 42
+
+
+# =====================================================================
+# ACCUMULATION STRESS
+# =====================================================================
+
+class TestAccumulation:
+    """Errors must not compound across long chains."""
+
+    def test_thousand_additions(self):
+        """0.001 * 1000 = 1.0 exactly."""
+        total = M("0.0")
+        for _ in range(1000):
+            total = total + M("0.001")
+        assert total == M("1.0")
+
+    def test_chained_division_multiplication(self):
+        """(((1 / 3) / 7) / 11) * 11 * 7 * 3 = 1."""
+        n = M("1")
+        n = n / M("3")
+        n = n / M("7")
+        n = n / M("11")
+        n = n * M("11")
+        n = n * M("7")
+        n = n * M("3")
+        assert n == M("1")
+
+    def test_financial_chain(self):
+        """$100 split 7 ways, then reassembled."""
+        share = M("100") / M("7")
+        total = share * M("7")
+        assert total == M("100")