t27.aiEnglish

GF-T32: двенадцать тритов

Вы узнаете

Как GF-T32 тратит 12 тритов порядка и 19 битов мантиссы.

В GF-T32 1 знак, 12 тритов порядка и 19 битов мантиссы. Двенадцать тритов дают 3^12 = 531441 значение порядка; смещение 265720 балансирует их, а смещение 531440 не конечно. Деление в тысячных: 12000 / 19 = 631. 19 битов мантиссы совпадают с GF32 в таблице семейства.

Попробуйте

Запустите два теста gft32.t27 и проверьте 3^12 вручную. Затем сравните его мантиссу со строкой GF32 в спеке семейства.

Открыть интерактивный урок →

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");
    }
}

Открыть спеку урока в плеере ↗

Все уроки