t27.aiРусский

GF-T16: six trits

You will learn

How GF-T16 spends 6 exponent trits and 9 mantissa bits, and how many exponent values that gives.

GF-T16 has 1 sign, 6 exponent trits and 9 mantissa bits. Six trits give 3^6 = 729 exponent values; offset 364 balances them and offset 728 is not finite. The split in thousandths is 6000 / 9 = 666. Its mantissa has the same 9 bits as GF16, so the two differ only in how they store the exponent.

Try it

Run the two tests of gft16.t27. Then compare MANT_BITS with GF16 and work out the range 729 exponent values cover around zero.

Open the interactive lesson →

GoldenFloat 25: GF-T16, six trits
GoldenFloat 25: GF-T16, six trits ↗

GF-T16 as the spec lays it out, read from gft16.t27. Lesson 25 of the GoldenFloat course.

specs/numeric/gft16.t27

// SPDX-License-Identifier: Apache-2.0
// gft16.t27 -- GF-T16: the golden-ratio ternary ladder, 16-bit class.
//
// TWO AXES, FOUR FAMILIES. GF and GF-T are derived from the golden ratio; BNF and
// TNF are derived from the theorems, as the optimisation result for ternary
// networks. They are not renamings of each other and they answer different
// questions.
//
// GF-T applies GF's rule to POSITIONS, and a trit is a position -- the golden
// section divides the payload the way it divides a segment:
//
//     E_t = round((N-1)/phi^2) = 6,   M = N - 1 - E_t = 9
//
// Every rung lands exactly: 1 + 6 + 9 = 16, no position unspent. The ratio
// E_t/M = 0.6667 against 1/phi = 0.6180, a phi-distance of 0.0486
// which falls toward zero up the ladder, by construction, exactly as in GF.
//
// What this buys and what it costs, measured against TNF16 on the reference
// oracle: GF-T's exponent spans 364 binades either side where TNF sizes its own
// for the range a workload actually visits. GF-T pays for that in mantissa. At 64
// bits GF-T takes 1.3e8 times the range for 1.2e5 times the error -- neither
// dominates, and the corollary on the pair (M_eff, binades) forbids ranking them
// without naming a workload.
//
// Supersedes the ad-hoc parameters this rung carried before 2026-08-09, where the
// exponent was sized at roughly log2(N) trits with no documented rule and left
// positions unspent.
//
//   layout: [ sign(1) | E = 6 balanced-ternary trits | M = 9 binary bits ]
//   value = (-1)^sign * (1 + M/2^9) * 2^e,   e in [-364,+364]

module triformat_gft16 {
    use base::types;

    const SIGN_BITS: u32 = 1;
    const EXP_TRITS: u32 = 6;     // round((N-1)/phi^2)
    const MANT_BITS: u32 = 9;      // the remaining positions, all of them
    const EXP_OFFSET: u32 = 364;
    const OFFSET_MAX: u32 = 728;

    fn is_finite(offset: u32) -> bool { return offset != OFFSET_MAX; }
    fn exp_values() -> u32 { return 729; }

    // ---- Tests / invariants ----

    // The golden section is the rule; this asserts it rather than remembering it.
    test golden_section {
        assert(SIGN_BITS + EXP_TRITS + MANT_BITS == 16, "1 + E_t + M = N, every position spent");
        assert(EXP_TRITS * 1000 / MANT_BITS == 666, "E_t/M holds the golden section");
    }

    test balanced_offsets {
        assert(EXP_OFFSET * 2 == OFFSET_MAX, "balanced: offset_max = 2 * exp_offset");
    }
}

Open the lesson's spec in the player ↗

All lessons