tritlib 2.1.1__tar.gz → 2.1.2__tar.gz

{tritlib-2.1.1 → tritlib-2.1.2}/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/), and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [2.1.2] — 2026-11-04
+
+### Fixed
+
+- `py.typed` is now shipped in the wheel.
+- The sdist no longer includes local tool configuration
+
 ## [2.1.1] — 2026-07-21
 
 ### Fixed
@@ -12,7 +19,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
   the dividend. 2.1.0 fixed the quotient decision but kept correcting
   the remainder only after the loop, one unit at a time, against a
   drift that triples per trit: `divmod(TritArray(-2586565449575, 27),
-  TritArray(-4, 27))` needed ~10¹² iterations, i.e. never returned.
+TritArray(-4, 27))` needed ~10¹² iterations, i.e. never returned.
   The result was correct whenever it did return, so the identity
   `a == b·q + r` kept the bug hidden.
 
@@ -31,15 +38,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/), and this
 
 ### Documentation
 
-- `Trits.__divmod__`, `TritArray.__divmod__` and the *Division
-  pitfalls* section of `CLAUDE.md` described the 2.1.0 state, where the
+- `Trits.__divmod__`, `TritArray.__divmod__` and the _Division
+  pitfalls_ section of `CLAUDE.md` described the 2.1.0 state, where the
   magnitude comparison alone was believed to maintain
   `|pr| ≤ |d| / 2`. They now document why it does not, and record the
   even-divisor case as the reason to test small even divisors
   explicitly: random fuzzing essentially never draws 2, 4 or 6, which
   is how this survived a full pass.
 - Documented that an even divisor admits two valid `(quotient,
-  remainder)` pairs when the remainder reaches exactly `|d| / 2`, and
+remainder)` pairs when the remainder reaches exactly `|d| / 2`, and
   which one this implementation returns —
   `divmod(Trits(10), Trits(4))` is `(3, -2)`, not `(2, 2)`.
 

{tritlib-2.1.1 → tritlib-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: tritlib
-Version: 2.1.1
+Version: 2.1.2
 Summary: Balanced ternary arithmetic and multi-valued logic library
 Project-URL: Homepage, https://codeberg.org/setnex-org/tritlib
 Project-URL: Repository, https://codeberg.org/setnex-org/tritlib
@@ -20,7 +20,7 @@ Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Description-Content-Type: text/markdown
 
-# tritlib — v2.0
+# tritlib — v2.1
 
 A pure Python library for balanced ternary arithmetic, multi-valued logic, and floating-point representation.
 
@@ -62,7 +62,7 @@ tritlib provides the building blocks for balanced ternary processor simulation:
 - Per-trit access (`__getitem__`) and immutable modification (`set`)
 - Sign extraction and absolute value
 - Consensus / anti-consensus (trit-level agreement detection)
-- Logic system dispatch independent of data types (LMODE selection)
+- Logic system dispatch independent of data types (mirrors the per-instruction logic selector of the Setnex ISA)
 - Tekum floating-point decode/encode for FPU simulation
 
 ## Installation

{tritlib-2.1.1 → tritlib-2.1.2}/README.md

@@ -1,4 +1,4 @@
-# tritlib — v2.0
+# tritlib — v2.1
 
 A pure Python library for balanced ternary arithmetic, multi-valued logic, and floating-point representation.
 
@@ -40,7 +40,7 @@ tritlib provides the building blocks for balanced ternary processor simulation:
 - Per-trit access (`__getitem__`) and immutable modification (`set`)
 - Sign extraction and absolute value
 - Consensus / anti-consensus (trit-level agreement detection)
-- Logic system dispatch independent of data types (LMODE selection)
+- Logic system dispatch independent of data types (mirrors the per-instruction logic selector of the Setnex ISA)
 - Tekum floating-point decode/encode for FPU simulation
 
 ## Installation

{tritlib-2.1.1 → tritlib-2.1.2}/pyproject.toml

@@ -2,9 +2,19 @@
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.build.targets.sdist]
+include = [
+  "src/",
+  "tests/",
+  "CHANGELOG.md",
+  "LICENSE",
+  "README.md",
+  "pyproject.toml",
+]
+
 [project]
 name = "tritlib"
-version = "2.1.1"
+version = "2.1.2"
 description = "Balanced ternary arithmetic and multi-valued logic library"
 readme = "README.md"
 license = "MIT"

tritlib-2.1.1/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(python -)",
-      "Bash(timeout 400 /home/newick/Programmes/setnex/tritlib/.venv/bin/python -m pytest test_regressions.py -q -p no:cacheprovider --timeout=60)",
-      "Bash(timeout 400 /home/newick/Programmes/setnex/tritlib/.venv/bin/python -m pytest test_regressions.py -q -p no:cacheprovider -k \"not full_width and not remainder_is_reduced\")"
-    ]
-  }
-}

tritlib-2.1.1/CLAUDE.md

@@ -1,79 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Règle absolue
-
-**Il t'est interdit de coder.** Tu ne dois jamais modifier la logique d'un fichier `.py` de ce dépôt. La seule modification autorisée dans un fichier `.py` est l'écriture ou la mise à jour de **docstrings**, et uniquement lorsque l'utilisateur le demande explicitement. Toute autre édition de code (ajout/suppression de fonctions, modification d'une expression, refactoring, correction de bug, etc.) est interdite, même si elle semble triviale ou évidente. Lecture, recherche, analyse et explication restent autorisées.
-
-## Commands
-
-Setup and test:
-```bash
-python -m venv .venv
-source .venv/bin/activate
-pip install -e ".[dev]"
-python -m pytest                          # full suite
-python -m pytest tests/test_tfloat.py     # single file
-python -m pytest tests/test_tfloat.py::test_name   # single test
-python -m pytest --cov=tritlib            # with coverage
-```
-
-Build distribution: `python -m build` (hatchling backend, declared in `pyproject.toml`).
-
-Python ≥ 3.11 required. No runtime dependencies — only `pytest` and `pytest-cov` for dev.
-
-## Architecture
-
-### Layering of the core types
-
-`Trit` → `Trits` → `TritArray` → `TFloat`. Each layer is built on the one below and they must be edited consistent with that direction:
-
-- **`Trit`** (`trit.py`) — single balanced ternary digit ∈ {N, Z, P}. Provides `half_add`/`full_add` returning `(sum, carry)` where carry is itself a Trit (ternary carry, not binary).
-- **`Trits`** (`trits.py`) — arbitrary-precision balanced ternary integer, built as a tuple of `Trit` in **little-endian** order. Division uses the double trial quotient method; result follows symmetric Euclidean semantics (remainder may be negative).
-- **`TritArray`** (`tritarray.py`) — fixed-width register-like word at arbitrary width. Three addition modes (`__add__` truncates, `add_with_carry` returns `(result, carry: Trit)`, `add_saturating` clamps). Operations construct via `type(self)._from_trits(trits, width)` (subclass-preserving dispatch) which truncates rather than raising — this is intentional hardware simulation behaviour.
-- **`Trybble`** / **`Tryte`** / **`Word`** (`trybble.py`, `tryte.py`, `word.py`) — width-locked subclasses (3 / 9 / 27 trits) aligned with Setnex ISA v0.8. Each declares a `WIDTH` class attribute, an `__init__(self, value)` that forwards to `TritArray.__init__(value, WIDTH)`, and an override of `_from_trits` that ignores any `width` argument and forces `WIDTH`. Arithmetic between same-typed instances preserves the subtype via `type(self)._from_trits`. `to_width(w)` on a subclass returns a base `TritArray` (changing width exits the locked contract).
-- **`TFloat`** (`tfloat.py`) — Tekum tapered precision float (arXiv:2512.10964). Stores raw as a `TritArray` (even width ≥ 8, not necessarily 9 or 27). Regime/exponent/fraction/sign are properties derived on demand. Arithmetic (`+`, `*`, `/`) is implemented natively at the trit level via `TritArray` operations (mantissa, double-width products, work-scale bounds), then re-encoded through `_finalize`.
-
-All types are **immutable**: `__setattr__` raises, `__slots__` enforces fields, and every operation returns a new instance. Do not add mutators.
-
-Internal storage is **little-endian** (least significant trit first), but string repr and constructor input strings are **big-endian** (`"+-0+"` reads MSB-to-LSB). Watch this direction reversal when editing.
-
-### Logic-system dispatch
-
-The five logic systems live in `src/tritlib/logic/`. Each subclasses `TernaryLogic` (in `base.py`) and only needs to override the operators where it diverges from defaults (most override only `imply_op`).
-
-`Trit`'s `&`, `|`, `~`, and `imply` look up the active logic via a `ContextVar` (`_current_logic` in `context.py`). When unset, fast inlined Kleene paths are used (no dispatch overhead). The `logic_mode(system)` context manager swaps the active system for the duration of a `with` block. New logic systems should be added by subclassing `TernaryLogic` and exporting from `logic/__init__.py`.
-
-`pluralize` (in `logic/plural.py`) evaluates a callable across all five systems and reports convergence/divergence — use it when reasoning about whether an expression is logic-system-sensitive.
-
-### Tekum format invariants
-
-When touching `TFloat`:
-- Width must be **even and ≥ 8**. Constructors validate this.
-- Three special values are stored as the raw `Tryte`: zero (all Z), infinity (all P), NaR (all N). The `_special` slot caches which one. Arithmetic on specials follows **wheel-algebra** semantics (e.g., `x/0 = ∞`, `0/0 = NaR`, `∞/∞ = NaR`) — see `__add__`, `__mul__`, `__truediv__` for the dispatch tables.
-- Tekum's defining property: **truncation is rounding**. When reducing precision, slice the anchor; no carry propagation needed. The `_finalize` helper centralises this.
-- Cross-width `==` returns `NotImplemented` (no silent coercion).
-- `from_float` is the private `_from_float` since 1.3.0; external callers should use the `TFloat(value, width=…)` constructor.
-
-### Division pitfalls (Trits / TritArray)
-
-There is exactly **one** division algorithm, in `Trits.__divmod__`. `TritArray.__divmod__` converts both operands with `to_trits()`, divides there, and packs the results back at the operand width (both always fit, so nothing is truncated). Do not reintroduce a second, fixed-width implementation: the partial remainder reaches `1.5 × |d|` mid-loop, so a `TritArray` comparison at the operand width wraps silently and returns an unreduced remainder — the identity `a == b·q + r` still holds, which is why it hid behind the tests for so long.
-
-Four things in `Trits.__divmod__` are load-bearing:
-
-- **The quotient trit is chosen by magnitude**, comparing `V + V` against `±|d|` where `V = 3·pr + t` is the partial remainder scaled by 3 plus the next dividend trit. Deciding on the sign of the leading trit alone (the pre-2.1.0 code) triples the partial remainder at each step — a 52-trit division drifted to `4·10²² × |d|` and never terminated in practice.
-- **The quotient is accumulated, not collected**: `q = q·3 ± 1`, never a list of trits appended to. A trit pushed into a list can no longer be revised, and the next point depends on revising it.
-- **The remainder is corrected inside the loop, not after it.** One trit cannot always reduce `V`: with `|pr| ≤ |d|/2` the scaled value reaches `1.5·|d| + 1`, while the three possible trits only span `[−1.5·|d|, +1.5·|d|]`. The overshoot is by exactly 1, and it is reachable **for every even divisor** (odd divisors are safe, since `|pr| ≤ (|d|−1)/2` keeps `|V|` in range). The inner loop writes what amounts to a quotient digit of ±2 at that rank; `q + Trits(1)` renormalises it by carrying into the ranks already produced, which balanced ternary addition does for free. It runs at most once per trit. Correcting only at the end still terminates, but one unit at a time against a drift that triples per trit: a 27-trit division by 2 needs ~10¹² iterations, i.e. never. This was the 2.1.1 fix; `2.1.0` shipped the magnitude comparison alone and was still unusable for even divisors.
-- **Every trit of the dividend is consumed**, starting from `q = pr = Trits(0)`. Do not "optimise" back either the `partial_rest = s[:len(d)-1]` pre-load or the `if len(self) < len(other): return Trits(0), self` shortcut; the latter returned an unreduced remainder (`34 / 58` gave `(0, 34)` instead of `(1, −24)`), i.e. a second remainder convention inside the same function.
-
-Remainder semantics are symmetric/balanced: `|r| ≤ |b|/2`, so the remainder takes whichever sign minimises its magnitude — **not** the sign of the dividend (`divmod(Trits(-200), Trits(-57)) == (Trits(4), Trits(28))`). For an even divisor the remainder can hit exactly `|b|/2`, where two `(q, r)` pairs satisfy the contract; the loop's own choice is what ships (`divmod(Trits(10), Trits(4)) == (Trits(3), Trits(-2))`). Do not freeze the other one in a test.
-
-Any test touching division must assert `2·|r| ≤ |b|` alongside `b·q + r == a`. The identity alone passes even when the algorithm is broken — it held throughout both the 2.1.0 and 2.1.1 bugs. Test small **even** divisors explicitly, at full width: random divisors essentially never hit 2, 4 or 6, which is how the even-divisor case survived a full fuzzing pass.
-
-## Conventions to follow
-
-- Type-hinted, immutable, dunder-rich public API. Add `__hash__`, `__eq__`, and `@total_ordering` where comparable; raise `AttributeError` from `__setattr__`.
-- Operators returning `NotImplemented` (not raising) for unsupported operand types — except `__divmod__`, which raises `TypeError` to match Python's `divmod` protocol.
-- New public symbols must be re-exported from the appropriate `__init__.py` and added to `__all__`.
-- Docstrings on public classes and methods; the project ships `py.typed` for downstream mypy users.