tritlib 1.2.3__tar.gz → 2.1.2__tar.gz

tritlib-2.1.2/CHANGELOG.md

@@ -0,0 +1,348 @@
+# Changelog
+
+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
+
+- `Trits.__divmod__` still drifted for **every even divisor**, whatever
+  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.
+  The result was correct whenever it did return, so the identity
+  `a == b·q + r` kept the bug hidden.
+
+  A single quotient trit cannot always reduce the scaled remainder:
+  with `|pr| ≤ |d| / 2`, `V = 3·pr + t` reaches `1.5·|d| + 1`, while
+  the three possible trits only span `[−1.5·|d|, +1.5·|d|]`. The
+  overshoot is by exactly one and is reachable for every even divisor;
+  odd divisors are safe because `|pr| ≤ (|d| − 1) / 2` keeps `|V|` in
+  range. The correction now happens inside the loop, at most once per
+  trit, which amounts to writing a quotient digit of ±2 at that rank —
+  balanced ternary addition carries it into the ranks already produced.
+
+- `Trits.__divmod__` accumulates the quotient (`q = 3·q ± 1`) instead
+  of collecting trits into a list. A trit appended to a list cannot be
+  revised, which is what the in-loop correction requires.
+
+### Documentation
+
+- `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
+  which one this implementation returns —
+  `divmod(Trits(10), Trits(4))` is `(3, -2)`, not `(2, 2)`.
+
+### Added
+
+- `tests/test_trits.py::test_divmod_even_divisors` — small even
+  divisors at full width, the case none of the existing tests or
+  fuzzing runs covered.
+
+## [2.1.0] — 2026-07-21
+
+### Fixed
+
+- `TritArray.__divmod__` returned an unreduced remainder whenever the
+  divisor exceeded roughly a third of the width's range (about 29 % of
+  random operand pairs at width 9). The quotient decision and the final
+  correction loop compared `V + V` at the operand width, which wrapped
+  silently. `divmod(TritArray(7872, 9), TritArray(-7887, 9))` gave
+  `(0, 7872)` instead of `(-1, -15)`. The identity `a == b·q + r` held
+  throughout, which is why the tests never caught it.
+- `TritArray.__divmod__` now delegates to `Trits.__divmod__` instead of
+  duplicating the algorithm at fixed width. Division must run at
+  arbitrary precision: the intermediate partial remainder reaches
+  `1.5 × |divisor|`.
+- `Trits.__divmod__` chose each quotient trit from the sign of the
+  leading trit alone, so the partial remainder doubled at every step
+  and the one-unit-at-a-time correction loop had to run an
+  astronomical number of iterations (a 52-trit division drifted to
+  `4·10²² × |d|`). The decision is now made on magnitude, restoring the
+  `|pr| ≤ |d| / 2` invariant.
+- `Trits.__divmod__` dropped the `len(self) < len(other)` shortcut,
+  which returned an unreduced remainder and amounted to a second
+  remainder convention inside the same function: `divmod(34, 58)` gave
+  `(0, 34)` instead of `(1, -24)`.
+- `TritArray.__eq__` and `__lt__` raised `TypeError` on any non-
+  `TritArray` operand instead of returning `NotImplemented`, so
+  `array == 5`, `array == None` and `array in [1, 2]` all blew up.
+- `TritArray.__eq__` also raised `ValueError` when the widths differed,
+  which propagated through every implicit comparison Python performs:
+  `Tryte(1) in [Word(1)]`, `[Tryte(1)] == [Word(1)]`, `list.index`,
+  `!=`, and — via `@total_ordering` — `<=`, `>` and `>=`. Mismatched
+  widths now compare unequal (`False`), matching `TFloat`. `__lt__`
+  returns `NotImplemented`, so ordering across widths raises the
+  standard `TypeError` instead.
+- `Trybble`, `Tryte` and `Word` declared no `__slots__`, so every
+  instance carried a `__dict__` despite `TritArray` defining slots.
+  They now declare `__slots__ = ()`; declaring the inherited names
+  again would allocate a second, shadowing slot per attribute (a
+  `Tryte` measured 64 bytes against 48 for a `TritArray`).
+- `TritArray.set` accepted any object as the replacement trit. The
+  invalid instance was built silently and only failed later, in
+  `__str__`, as a confusing `KeyError`. It now rejects non-`Trit`
+  values on the spot.
+- `cons` and `acons` accepted operands of a different width and
+  silently truncated through `zip`, unlike every other binary
+  operation. They now raise `TypeError`.
+- `rotate_left` and `rotate_right` were wrong for `n > width`:
+  `Tryte(42).rotate_left(10)` did not equal `rotate_left(1)`. The
+  count is now taken modulo the width.
+- `__lshift__` and `__rshift__` accepted negative counts and did
+  something arbitrary rather than failing: `n = -1` made the slice
+  count from the end, moving the most significant trit into the least
+  significant position and zeroing the rest, while `[Z] * -1` silently
+  produced an empty list. Below `-width` the value came back
+  unchanged. Both now raise `ValueError`, as Python's own integers do.
+- `Trit(True)` was accepted and stored `True` as the trit value, since
+  `bool` is a subclass of `int`.
+- `TFloat.__neg__` mapped the all-P pattern to the all-N one, turning
+  ∞ into NaR and NaR into ∞. Since `__sub__` is `self + (-other)`,
+  `x - ∞` returned NaR and `x - NaR` returned ∞. Both special values
+  are now fixed points under negation, which also matches the
+  constructor, where `TFloat(float("-inf"), w)` already encodes ∞.
+- All errors now have a meaningful message.
+
+### Changed
+
+- `tfloat.py`, `logic/base.py`, `logic/bochvar.py` and `logic/plural.py`
+  imported names from the `tritlib` package itself rather than from the
+  defining modules. That only worked because `__init__.py` happened to
+  import `trit`, `trits` and `tritarray` before `word` (which pulls in
+  `tfloat`): reordering two lines of `__init__.py` broke the package
+  with `ImportError: cannot import name 'TritArray'`. All four now
+  import the concrete modules, and the package no longer depends on the
+  order of its own imports.
+- `TFloat.__add__`: `∞ + ∞` is now NaR rather than ∞. Tekum has a
+  single unsigned ∞, so `-∞ = ∞` and `∞ + ∞` is the same expression as
+  `∞ - ∞` — it cannot resolve to ∞. The IEEE rule `+∞ + +∞ = +∞`
+  depends on the sign being carried by the value. `∞ × ∞` is
+  unaffected and stays ∞.
+
+### Documentation
+
+- The division docstrings described the opposite of what the code did
+  (« no magnitude comparison is needed ») and claimed the remainder
+  carried the sign of the dividend; it is balanced, so it takes
+  whichever sign minimises `|r|` — `divmod(Trits(-200), Trits(-57))`
+  is `(4, 28)`.
+- Corrected the worked examples: `Trits(42)` is `"+---0"`, and
+  `"+-0+"` is 19, not 8 (both in `Trits` and `TritArray`).
+- README: B3 is the internal (weak) Bochvar system, where Z is
+  absorbing — `Z ∧ Z = Z`, not `N`; the requirement is Python ≥ 3.11,
+  matching `pyproject.toml`; the `divmod` example showed a result that
+  no version of the code ever produced.
+- `TFloat.__neg__` and `__add__` document the single unsigned ∞ and
+  why `∞ + ∞` cannot be ∞.
+- `TFloat.__lt__` states the Tekum ordering explicitly: NaR sorts below
+  every finite value and ∞ above them, so the special values take part
+  in comparisons rather than poisoning them the way IEEE NaN does.
+- The docstrings of `set`, `cons`, `acons`, the shifts and the
+  rotations describe the guards added above.
+
+## [2.0.0] — 2026-05-18
+
+### Breaking
+
+- `Tryte` is now a fixed-width 9-trit type (T9), aligned with Setnex ISA v0.8.
+  Its constructor no longer accepts a `width` argument. Code that did
+  `Tryte(value, w)` for `w ≠ 9` must migrate to `TritArray(value, w)`.
+- The arbitrary-width balanced ternary word type historically named `Tryte`
+  is renamed `TritArray`. All public methods (`add_with_carry`,
+  `add_saturating`, `to_width`, `set`, `__divmod__`, shifts, rotations,
+  consensus, etc.) live on `TritArray` and are inherited by the three
+  width-locked subclasses.
+
+### Added
+
+- `TritArray(value, width)` — arbitrary-width balanced ternary word (the
+  generic base type).
+- `Trybble(value)` — 3-trit field (T3), the smallest addressable grouping
+  per the ISA.
+- `Word(value)` — 27-trit word (T27), the basic memory and register unit
+  per the ISA.
+- Subclasses share `TritArray`'s implementation and preserve their concrete
+  type through arithmetic via `type(self)._from_trits(...)` dispatch.
+- `tests/test_tritarray.py` — generic-width regression suite migrated from
+  the former `test_tryte.py`; `test_tryte.py` now exercises the 9-trit
+  semantics (overflow at ±9841, fixed `len() == 9`, etc.).
+
+### Changed
+
+- All internal `TFloat` arithmetic (mantissa, regime, exponent, work-scale
+  bounds, double-width products, division work widths) routes through
+  `TritArray`. `TFloat._raw` is a `TritArray` of even width ≥ 8; the
+  constructor accepts `float | int | TritArray` (any subclass instance
+  whose width meets Tekum's even-and-≥-8 rule).
+- `to_width(w)` on any subclass returns a `TritArray` (changing width
+  exits the width-locked contract).
+- `__init__.py` exports `TritArray`, `Trybble`, `Word` alongside `Tryte`.
+
+## [1.3.0] — 2026-04-29
+
+### Added
+
+- Native trit-level division on `TFloat` (Tekum arithmetic)
+  - Mantissa division at a working scale `p_work = max(p_self, p_other) + 2`
+  - Numerator pre-shifted by `3^p_work` to recover the fractional quotient as an integer
+  - Wheel-algebra special-value handling: `x/0 = ∞`, `0/0 = NaR`, `x/∞ = 0`, `∞/x = ∞`, `∞/∞ = NaR`
+  - Result re-encoded by `_finalize`; no longer routes through Python `float`
+
+### Fixed
+
+- `Trits.__divmod__` and `Tryte.__divmod__` exponential drift on certain operand magnitudes.
+  Initial `partial_rest = s[:len(d)-1]` could already exceed `|d|/2` when `|d|` sat at the
+  lower end of its trit-length range, breaking the single-trit quotient invariant; the
+  resulting remainder grew geometrically and the correction loop ran for billions of
+  iterations. Both implementations now start with `partial_rest = []` and `pr = 0`,
+  consuming every trit of the dividend and maintaining `|pr| ≤ |d|/2` at every step.
+- `Tryte.__divmod__` silent overflow at width boundaries: the quotient-digit decision
+  `V + V > abs_other` truncated when `2|V|` exceeded the Tryte range (e.g. width 26 with
+  values near `3²⁶/2`). The decision now uses an `int` comparison, immune to truncation.
+
+### Changed
+
+- `TFloat._from_float` (renamed from `from_float`): privatized; bounded fraction
+  quantification with `_find_regime` recomputed in-loop, plus a final clamp
+- `_finalize` factored out of `__add__`, `__mul__`, and `__truediv__` for shared
+  normalization and re-encoding
+- `Trits.__divmod__` and `Tryte.__divmod__` now raise `TypeError` (not return
+  `NotImplemented`) when the divisor is of the wrong type, matching `divmod` protocol
+- `TFloat.__eq__` returns `NotImplemented` for cross-width comparisons rather than
+  silently coercing
+- `Tryte.to_tryte` (TFloat method): correct slicing for the `e == 0` and `e < 0`
+  edge cases, plus explicit overflow guard when `e ≥ width`
+
+## [1.2.3] — 2026-04-22
+
+- added TFloat conversion from and into int/Tryte/Trits
+- renamed to_tryte into to_raw
+
+## [1.2.2] — 2026-04-05
+
+- Updated README.md and pyproject.toml
+
+## [1.2.1] — 2026-04-05
+
+- Symmetric Euclidean `__divmod__` implementation
+
+## [1.2.0] — 2026-04-05
+
+### Added
+
+- Native trit-level multiplication on `TFloat` (Tekum arithmetic)
+  - Double-width Tryte arithmetic for the product
+  - Exponent addition, scale reduction via ternary shift
+  - Normalization into Tekum's [0.5, 1.5) range
+
+## [1.1.0] — 2026-04-05
+
+### Added
+
+- Native trit-level addition on `TFloat` (Tekum arithmetic)
+  - Direct manipulation of extended mantissas via `Tryte` operations
+  - Exponent alignment via ternary shift
+  - Normalization with Tekum's truncation-equals-rounding property
+  - No longer relies on Python float for addition
+- `_find_regime` and `_assemble_raw` internal helpers factored out of `from_float`
+
+## [1.0.0] — 2026-04-04
+
+### Changed
+
+- API declared stable
+- Version bumped to 1.0.0 — no breaking changes from 0.7.0
+
+### Added
+
+- `py.typed` marker for mypy support
+- CHANGELOG.md
+- 99% test coverage
+
+## [0.7.0] — 2026-04-04
+
+### Added
+
+- `TFloat` — Tekum tapered precision floating-point type (arXiv:2512.10964)
+  - Decode from `Tryte` and encode from Python `float`
+  - Arithmetic via float conversion (`+`, `-`, `*`, `/`)
+  - Negation, comparison, hashing
+  - Special values: zero, infinity, NaR
+  - Configurable width (even, ≥ 8)
+- `pluralize` function and `PluralResult` dataclass for logical pluralism
+- `logic_mode` context manager for runtime logic system selection
+- Logic aliases: `K3`, `L3`, `HT`, `BI3`, `RM3`
+- `Trit.imply` method dispatched via context manager
+- `context.py` module with `ContextVar`-based logic dispatch
+- Docstrings on all public classes and methods
+- This CHANGELOG
+
+### Changed
+
+- `Trit.__and__`, `__or__`, `__invert__` now dispatch via active logic system (Kleene by default, fast path when no context manager is active)
+
+## [0.2.0] — 2026-04-03
+
+### Added
+
+- `Tryte` — fixed-width ternary word type
+  - Three addition modes: truncating, with carry, saturating
+  - Shifts (`<<`, `>>`) and rotations (`rotate_left`, `rotate_right`)
+  - Per-trit access (`__getitem__`) and immutable modification (`set`)
+  - Sign extraction, absolute value
+  - Consensus and anti-consensus (`cons`, `acons`)
+  - Resize across widths (`to_width`)
+  - Division (`__floordiv__`, `__mod__`, `__divmod__`)
+- Five ternary logic systems with `TernaryLogic` abstract base class
+  - Kleene (K3), Łukasiewicz (L3), Heyting (HT), Bochvar (BI3), R-mingle (RM3)
+  - Each implements NOT, AND, OR, IMPLY, XOR, EQUIV
+- `Trits` division via double trial quotient method
+- Kleene logic operators on `Trit` (`&`, `|`, `~`)
+- `Trit.cons` and `Trit.acons` operators
+
+### Changed
+
+- `Trits` internal storage changed to tuple (immutable)
+- `Trits._from_trits` centralizes normalization and construction
+
+## [0.1.0] — 2026-04-02
+
+### Added
+
+- `Trit` — immutable single balanced ternary digit
+  - Construction from int with validation
+  - Negation, multiplication
+  - Half-adder and full-adder with ternary carry
+  - Equality, hashing, comparison
+  - Immutability via `__setattr__` guard
+- `Trits` — arbitrary-precision balanced ternary integer
+  - Construction from `int` or balanced ternary string
+  - Addition, subtraction, multiplication
+  - Conversion to/from Python `int`
+  - Comparison operators
+- Constants `P`, `Z`, `N`
+- `pyproject.toml` with hatchling build system
+- MIT license
+- Initial README
+
+[0.7.0]: https://codeberg.org/newick_2/tritlib/compare/v0.2.0...v0.7.0
+[0.2.0]: https://codeberg.org/newick_2/tritlib/compare/v0.1.0...v0.2.0
+[0.1.0]: https://codeberg.org/newick_2/tritlib/releases/tag/v0.1.0

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: tritlib
-Version: 1.2.3
+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 — v1.2
+# tritlib — v2.1
 
 A pure Python library for balanced ternary arithmetic, multi-valued logic, and floating-point representation.
 
@@ -34,20 +34,21 @@ Balanced ternary is a base-3 numeral system using digits from {−1, 0, +1}. It
 
 - **`Trit`** — Immutable single trit. Arithmetic (negation, multiplication, half/full addition with ternary carry), Kleene K3 logic (`&`, `|`, `~`), consensus and anti-consensus operators. Hashable and comparable.
 - **`Trits`** — Arbitrary-precision balanced ternary integer. Full arithmetic: addition, subtraction, multiplication, floor division and modulo via the double trial quotient method. Constructed from `int` or balanced ternary string (`"+-0+"`).
-- **`Tryte`** — Fixed-width ternary word, analogous to a hardware register. Three addition modes: truncating (wrap around), with carry, and saturating. Shifts, rotations, trit-level access and modification, sign extraction, absolute value, consensus/anti-consensus. Resizable across widths.
-- **`TFloat`** — Balanced ternary floating-point number using the Tekum tapered precision format (Hunhold, arXiv:2512.10964). No sign trit, truncation equals rounding, three special values (zero, infinity, NaR). Configurable width (even, ≥ 8). Addition and multiplication use native trit-level arithmetic; division converts via Python `float`.
+- **`TritArray`** — Fixed-width ternary word at arbitrary width, analogous to a hardware register. Three addition modes: truncating (wrap around), with carry, and saturating. Shifts, rotations, trit-level access and modification, sign extraction, absolute value, consensus/anti-consensus. Resizable across widths via `to_width`.
+- **`Trybble`** / **`Tryte`** / **`Word`** — Width-locked subclasses of `TritArray` matching the Setnex ISA unit hierarchy: 3 trits (T3, register address / sub-opcode), 9 trits (T9, byte-analogue), and 27 trits (T27, memory and register word). All inherit `TritArray`'s arithmetic and preserve their concrete type through operations.
+- **`TFloat`** — Balanced ternary floating-point number using the Tekum tapered precision format (Hunhold, arXiv:2512.10964). No sign trit, truncation equals rounding, three special values (zero, infinity, NaR). Configurable width (even, ≥ 8). Addition, multiplication and division all use native trit-level arithmetic with wheel-algebra semantics for the special values.
 
 ### Multi-valued logic
 
 Five ternary logic systems, selectable at runtime via a common abstract interface:
 
-| System | Third value semantics | Key difference |
-|---|---|---|
-| **Kleene (K3)** | Unknown (epistemic) | Default. AND = min, OR = max |
-| **Łukasiewicz (L3)** | Indeterminate (ontological) | Z → Z yields P (tautological self-implication) |
-| **Heyting (HT)** | Non-proved (constructivist) | ~Z = N (unproved is false) |
-| **B3 (Bochvar)** | Both true and false (paraconsistent) | Z ∧ Z = N (contradiction resolves downward) |
-| **RM3 (R-mingle)** | Relevant entailment | Restricted implication |
+| System               | Third value semantics                | Key difference                                 |
+| -------------------- | ------------------------------------ | ---------------------------------------------- |
+| **Kleene (K3)**      | Unknown (epistemic)                  | Default. AND = min, OR = max                   |
+| **Łukasiewicz (L3)** | Indeterminate (ontological)          | Z → Z yields P (tautological self-implication) |
+| **Heyting (HT)**     | Non-proved (constructivist)          | ~Z = N (unproved is false)                     |
+| **B3 (Bochvar)**     | Meaningless (infectious)             | Z is absorbing: Z ∧ Z = Z ∨ Z = Z → Z = Z      |
+| **RM3 (R-mingle)**   | Relevant entailment                  | Restricted implication                         |
 
 Each system implements NOT, AND, OR, IMPLY, XOR, and EQUIV. Custom systems can be added by subclassing `TernaryLogic`. The `logic_mode` context manager switches the active logic system for operators on `Trit`. The `pluralize` function evaluates an expression across all five systems and reports convergence or divergence.
 
@@ -61,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
@@ -70,7 +71,7 @@ tritlib provides the building blocks for balanced ternary processor simulation:
 pip install tritlib
 ```
 
-Requires Python ≥ 3.10. No external dependencies.
+Requires Python ≥ 3.11. No external dependencies.
 
 ## Usage
 
@@ -104,42 +105,49 @@ print(int(a * b))        # 798
 q, r = divmod(Trits(13), Trits(4))
 assert int(q) * 4 + int(r) == 13
 
-# Division can have negative remainder
-q, r = divmod(Trits(20), Trits(6))
-assert int(q) * 6 + int(r) == 20
-print(int(q))  # 4
-print(int(r))  # -4
+# The remainder is balanced: |r| <= |divisor| / 2, so it takes
+# whichever sign minimises its magnitude — not the dividend's.
+q, r = divmod(Trits(40), Trits(6))
+assert int(q) * 6 + int(r) == 40
+print(int(q))  # 7
+print(int(r))  # -2
 ```
 
 ### Fixed-width words
 
 ```python
-from tritlib import Tryte
+from tritlib import TritArray, Trybble, Tryte, Word
 
-w = Tryte(42, width=6)
+# ISA-aligned width-locked types
+print(len(Trybble(1)))        # 3
+print(len(Tryte(42)))         # 9
+print(len(Word(0)))           # 27
+
+# Arbitrary width via TritArray
+w = TritArray(42, width=6)
 print(len(w))                 # 6
 print(w[0])                   # least significant trit
 
-# Saturating addition
-result = Tryte(300, 6).add_saturating(Tryte(300, 6))
+# Saturating addition (any TritArray subclass)
+result = TritArray(300, 6).add_saturating(TritArray(300, 6))
 print(int(result))            # 364 (clamped to max)
 
 # Carry detection
-result, carry = Tryte(300, 6).add_with_carry(Tryte(65, 6))
+result, carry = TritArray(300, 6).add_with_carry(TritArray(65, 6))
 print(carry)                  # P (positive overflow)
 ```
 
 ### Floating-point (Tekum format)
 
 ```python
-from tritlib import TFloat, Tryte
+from tritlib import TFloat, TritArray
 
 # Encode from Python float
 tf = TFloat(3.14, width=20)
 print(float(tf))              # ≈ 3.14
 
-# Decode from a register word
-register = Tryte(1640, 8)
+# Decode from a register word (even width ≥ 8)
+register = TritArray(1640, 8)
 tf = TFloat(register)
 print(float(tf))              # 1.0
 
@@ -148,6 +156,7 @@ a = TFloat(2.5, width=20)
 b = TFloat(1.3, width=20)
 print(float(a + b))           # ≈ 3.8
 print(float(a * b))           # ≈ 3.25
+print(float(a / b))           # ≈ 1.923
 
 # Special values
 print(TFloat(0.0, width=8))             # 0
@@ -193,7 +202,7 @@ from tritlib.logic.plural import pluralize
 # Evaluate Z → Z across all five logic systems
 result = pluralize(lambda a, b: a.imply(b), Z, Z)
 print(result.divergent)   # True — logics disagree
-print(result.groups)      # {Z: ['K3', 'BI3', 'RM3'], P: ['L3', 'HT']}
+print(result.groups)      # {Trit(0): ['BI3', 'K3', 'RM3'], Trit(1): ['HT', 'L3']}
 print(result.consensus)   # None — no unanimous agreement
 ```
 
@@ -204,7 +213,10 @@ src/tritlib/
 ├── __init__.py
 ├── trit.py            # Trit type
 ├── trits.py           # Trits arbitrary-precision type
-├── tryte.py           # Tryte fixed-width type
+├── tritarray.py       # TritArray generic fixed-width type
+├── trybble.py         # Trybble (T3, 3-trit subclass)
+├── tryte.py           # Tryte (T9, 9-trit subclass)
+├── word.py            # Word (T27, 27-trit subclass)
 ├── tfloat.py          # TFloat Tekum floating-point type
 ├── context.py         # Logic mode context manager
 └── logic/
@@ -239,8 +251,7 @@ python -m pytest
 - [x] Logic context manager (`with logic_mode(L3()): result = a & b`)
 - [x] Logical pluralism: evaluate across all systems, report convergence/divergence
 - [x] Tekum balanced ternary floating-point (encode, decode, arithmetic via float)
-- [x] Native trit-level `__add__` and `__mul__` (Tekum truncation = rounding)
-- [ ] Native trit-level `__truediv__` (currently converts via Python `float`)
+- [x] Native trit-level `__add__`, `__mul__` and `__truediv__` (Tekum truncation = rounding)
 - [ ] Educational step-by-step computation output (carry propagation, partial products)
 
 ## License
@@ -249,7 +260,7 @@ MIT — see LICENSE file for details.
 
 ## Links
 
-- Repository: https://codeberg.org/setnex-org/tritlib
-- PyPI: https://pypi.org/project/tritlib/
-- Tekum paper: https://arxiv.org/abs/2512.10964
-- Setnex balanced ternary ISA: https://setnex.org
+- Repository: <https://codeberg.org/setnex-org/tritlib>
+- PyPI: <https://pypi.org/project/tritlib/>
+- Tekum paper: <https://arxiv.org/abs/2512.10964>
+- Setnex balanced ternary ISA: <https://setnex.org>