t27.aiРусский

GF-T32: twelve trits

You will learn

How GF-T32 spends 12 exponent trits and 19 mantissa bits.

GF-T32 has 1 sign, 12 exponent trits and 19 mantissa bits. Twelve trits give 3^12 = 531441 exponent values; offset 265720 balances them and offset 531440 is not finite. The split in thousandths is 12000 / 19 = 631. The 19 mantissa bits match GF32 in the family table.

Try it

Run the two tests of gft32.t27 and check 3^12 by hand. Then compare its mantissa with the GF32 row of the family spec.

Open the interactive lesson →

GoldenFloat 26: GF-T32, twelve trits
GoldenFloat 26: GF-T32, twelve trits ↗

GF-T32 as the spec lays it out, read from gft32.t27. Lesson 26 of the GoldenFloat course.

specs/numeric/gft32.t27

// SPDX-License-Identifier: Apache-2.0
// gft32.t27 -- GF-T32: the golden-ratio ternary ladder, 32-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) = 12,   M = N - 1 - E_t = 19
//
// Every rung lands exactly: 1 + 12 + 19 = 32, no position unspent. The ratio
// E_t/M = 0.6316 against 1/phi = 0.6180, a phi-distance of 0.0135
// which falls toward zero up the ladder, by construction, exactly as in GF.
//
// What this buys and what it costs, measured against TNF32 on the reference
// oracle: GF-T's exponent spans 265720 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 = 12 balanced-ternary trits | M = 19 binary bits ]
//   value = (-1)^sign * (1 + M/2^19) * 2^e,   e in [-265720,+265720]

module triformat_gft32 {
    use base::types;

    const SIGN_BITS: u32 = 1;
    const EXP_TRITS: u32 = 12;     // round((N-1)/phi^2)
    const MANT_BITS: u32 = 19;      // the remaining positions, all of them
    const EXP_OFFSET: u32 = 265720;
    const OFFSET_MAX: u32 = 531440;

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

    // ---- 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 == 32, "1 + E_t + M = N, every position spent");
        assert(EXP_TRITS * 1000 / MANT_BITS == 631, "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