Что такое вектор

Вы научитесь

Что такое тест-вектор и почему ответ должен лежать рядом со входом, в файле.

Попробуйте

Посчитайте в переписи виджета векторные файлы, которые ни один раннер не исполняет; затем запишите один вектор, с ответом, в файл, который инструмент сможет разобрать.

specs/numeric/formats_catalog.t27

// SPDX-License-Identifier: Apache-2.0
// t27/specs/numeric/formats_catalog.t27
//
// Universal Numeric Format Catalog (SSOT)
//
// Single source of truth for every numeric format relevant to ML,
// scientific computing, historical hardware, and the GoldenFloat (GF)
// family. Codegen targets (Markdown / JSON / Python / Rust / C / TS) MUST be
// derived from this file via tools/gen_formats_catalog.py (bootstrap
// codegen, Python stop-gap until t27c is self-hosting). Do not hand-edit
// emitted files in gen/numeric/.
//
// Bootstrap grammar note: this file deliberately uses ONLY constructs that
// bootstrap/t27c.py can parse today (const + fn). Struct literals
// (Format { ... }) are NOT yet supported by t27c parse, so per-format
// records live as fn getters that the codegen reads from the AST. When
// t27c gains struct literals this file can be re-expressed as a const
// array of Format records without changing the codegen contract.
//
// Status labels (mandatory; see skills/user/goldenfloat-ladder +
// igla-phi-architecture):
//   Verified        - exact-by-construction or directly measured.
//   EmpiricalFit    - matches data but a parameter is chosen post-hoc.
//   Open            - plausible conjecture; carries a falsification path.
//   Risk            - weak venue, look-elsewhere, or already-matching control.
//   Retracted       - withdrawn; recorded, never used as evidence.
//   Experimental    - design exists on paper; not implemented or measured.
//   Historical      - shipped hardware, no longer current standard.
//
// Phi-distance metric:
//   phi_distance(E, M) = abs(E / M - 1/phi)   where 1/phi = 0.61803398874989
//   Lower is more phi-aligned. Only defined for radix-2 floats with
//   separate E and M. Sentinel -1.0 means undefined.
//
// Anti-hype guardrails (inherited; CI-enforced):
//   - English-only, ASCII-only.
//   - No banned words: breakthrough / nobel / revolution / proves /
//     first-ever / world-first / industry-leading / prize.
//   - GFTernary 0.000 and GF64 0.003 are Verified arithmetic; the moat
//     (per-rung quality beating posit / takum / OCP-MX / LNS) stays Open
//     conjecture and lives ONLY in the FL-002 ledger with Fpath F1/F2/F3.
//   - takum (arXiv:2404.18603), posit, OCP-MX, LNS are ALLIES and
//     falsification targets, never "competitors to dismiss" and never
//     "the only" formats.

module FormatsCatalog {

  // ----------------------------------------------------------------------
  // Anchor constants.
  // ----------------------------------------------------------------------

  // Trinity identity (Lucas L2, 1878 -- Binet corollary). Verified.
  const TRINITY: f64 = 3.0;

  // ----------------------------------------------------------------------
  // Per-format records. Codegen parses these fn bodies for field values.
  // Field order is fixed: bits, s, e, m, bias, phi_distance, storage,
  // cluster, status, standard, use_case, gf_relation, source.
  //
  // CATALOG line in the trailing comment is the canonical machine-readable
  // record: the bootstrap codegen reads it. When t27c gains struct
  // literals this drops out and the codegen reads the AST directly.
  // ----------------------------------------------------------------------

  // ============================================================
  // 12.2.1 IEEE 754 binary (radix-2)
  // ============================================================

  // CATALOG: id=binary16 name="binary16 (fp16, half)" bits=16 s=1 e=5 m=10 bias=15 phi_distance=0.118 storage=u16 cluster=Ieee754Binary status=Verified standard="IEEE 754-2008" use_case="GPU activations, inference" gf_relation=competitor source="IEEE 754-2008"
  fn binary16() -> str { return "binary16"; }

  // CATALOG: id=binary32 name="binary32 (fp32, single)" bits=32 s=1 e=8 m=23 bias=127 phi_distance=0.270 storage=u32 cluster=Ieee754Binary status=Verified standard="IEEE 754-1985" use_case="industry default" gf_relation=competitor source="IEEE 754-1985"
  fn binary32() -> str { return "binary32"; }

  // CATALOG: id=binary64 name="binary64 (fp64, double)" bits=64 s=1 e=11 m=52 bias=1023 phi_distance=0.406 storage=u64 cluster=Ieee754Binary status=Verified standard="IEEE 754-1985" use_case="scientific computing" gf_relation=competitor source="IEEE 754-1985"
  fn binary64() -> str { return "binary64"; }

  // CATALOG: id=binary128 name="binary128 (fp128, quad)" bits=128 s=1 e=15 m=112 bias=16383 phi_distance=0.484 storage=u128 cluster=Ieee754Binary status=Verified standard="IEEE 754-2008" use_case="high-precision simulations" gf_relation=competitor source="IEEE 754-2008"
  fn binary128() -> str { return "binary128"; }

  // CATALOG: id=binary256 name="binary256 (octuple)" bits=256 s=1 e=19 m=236 bias=262143 phi_distance=0.538 storage=u256_software cluster=Ieee754Binary status=Verified standard="IEEE 754-2008" use_case="astronomy, cryptography" gf_relation=competitor source="IEEE 754-2008"
  fn binary256() -> str { return "binary256"; }

  // ============================================================
  // 12.2.2 IEEE 754 decimal (radix-10) -- phi_distance undefined
  // ============================================================

  // CATALOG: id=decimal32 name="decimal32" bits=32 s=1 e=11 m=20 bias=101 phi_distance=-1.0 storage=u32 cluster=Ieee754Decimal status=Verified standard="IEEE 754-2008 (DPD/BID)" use_case="banking, GAAP" gf_relation=orthogonal source="IEEE 754-2008"
  fn decimal32() -> str { return "decimal32"; }

  // CATALOG: id=decimal64 name="decimal64" bits=64 s=1 e=13 m=50 bias=398 phi_distance=-1.0 storage=u64 cluster=Ieee754Decimal status=Verified standard="IEEE 754-2008" use_case="financial databases" gf_relation=orthogonal source="IEEE 754-2008"
  fn decimal64() -> str { return "decimal64"; }

  // CATALOG: id=decimal128 name="decimal128" bits=128 s=1 e=17 m=110 bias=6176 phi_distance=-1.0 storage=u128 cluster=Ieee754Decimal status=Verified standard="IEEE 754-2008" use_case="audit ledgers" gf_relation=orthogonal source="IEEE 754-2008"
  fn decimal128() -> str { return "decimal128"; }

  // ============================================================
  // 12.2.3 Extended / non-standard float
  // ============================================================

  // CATALOG: id=x87_fp80 name="x87 FP80" bits=80 s=1 e=15 m=64 bias=16383 phi_distance=-1.0 storage=u80_padded cluster=ExtendedFloat status=Historical standard="Intel x87 (explicit integer bit)" use_case="legacy long double on x86" gf_relation=orthogonal source="Intel SDM"
  fn x87_fp80() -> str { return "x87_fp80"; }

  // CATALOG: id=double_double name="double-double" bits=128 s=2 e=22 m=104 bias=0 phi_distance=-1.0 storage=two_u64 cluster=ExtendedFloat status=Verified standard="Bailey/Hida (software)" use_case="software extended precision" gf_relation=orthogonal source="Bailey-Hida 2001"
  fn double_double() -> str { return "double_double"; }

  // CATALOG: id=quad_double name="quad-double" bits=256 s=4 e=44 m=208 bias=0 phi_distance=-1.0 storage=four_u64 cluster=ExtendedFloat status=Verified standard="Bailey/Hida (software)" use_case="astrophysics, quad-precision sims" gf_relation=orthogonal source="Bailey-Hida 2001"
  fn quad_double() -> str { return "quad_double"; }

  // ============================================================
  // 12.2.4 ML low-precision (E:M variants)
  // ============================================================

  // CATALOG: id=bfloat16 name="bfloat16 (BF16)" bits=16 s=1 e=8 m=7 bias=127 phi_distance=0.525 storage=u16 cluster=MlLowPrecision status=Verified standard="Google Brain" use_case="training (range > precision)" gf_relation=competitor source="Wang-Kanwar 2019"
  fn bfloat16() -> str { return "bfloat16"; }

  // CATALOG: id=tf32 name="TensorFloat-32 (TF32)" bits=19 s=1 e=8 m=10 bias=127 phi_distance=0.270 storage=u32_padded cluster=MlLowPrecision status=Verified standard="NVIDIA Ampere" use_case="A100/H100 mixed precision" gf_relation=competitor source="NVIDIA Ampere whitepaper"
  fn tf32() -> str { return "tf32"; }

  // CATALOG: id=fp8_e4m3 name="FP8 E4M3" bits=8 s=1 e=4 m=3 bias=7 phi_distance=0.715 storage=u8 cluster=MlLowPrecision status=Verified standard="OCP / NVIDIA / Arm / Intel" use_case="inference, gradient ranges" gf_relation=competitor source="Micikevicius 2022 (arXiv:2209.05433)"
  fn fp8_e4m3() -> str { return "fp8_e4m3"; }

  // CATALOG: id=fp8_e5m2 name="FP8 E5M2" bits=8 s=1 e=5 m=2 bias=15 phi_distance=1.882 storage=u8 cluster=MlLowPrecision status=Verified standard="OCP / NVIDIA" use_case="activations, wide range" gf_relation=competitor source="Micikevicius 2022"
  fn fp8_e5m2() -> str { return "fp8_e5m2"; }

  // CATALOG: id=fp6_e3m2 name="FP6 E3M2" bits=6 s=1 e=3 m=2 bias=3 phi_distance=0.882 storage=u8_packed cluster=MlLowPrecision status=Verified standard="OCP MX" use_case="aggressive quant inference" gf_relation=competitor source="OCP MX v1.0 (2023)"
  fn fp6_e3m2() -> str { return "fp6_e3m2"; }

  // CATALOG: id=fp6_e2m3 name="FP6 E2M3" bits=6 s=1 e=2 m=3 bias=1 phi_distance=0.049 storage=u8_packed cluster=MlLowPrecision status=Verified standard="OCP MX" use_case="mantissa-heavy quant" gf_relation=ally source="OCP MX v1.0 (2023)"
  fn fp6_e2m3() -> str { return "fp6_e2m3"; }

  // CATALOG: id=fp4_e2m1 name="FP4 E2M1" bits=4 s=1 e=2 m=1 bias=1 phi_distance=1.382 storage=u8_packed cluster=MlLowPrecision status=Verified standard="OCP MX" use_case="extreme quant inference" gf_relation=competitor source="OCP MX v1.0 (2023)"
  fn fp4_e2m1() -> str { return "fp4_e2m1"; }

  // ============================================================
  // 12.2.5 Microscaling (OCP MX) -- block-shared exponent
  // ============================================================

  // CATALOG: id=mxfp8 name="MXFP8" bits=8 s=1 e=4 m=3 bias=7 phi_distance=0.715 storage=u8_plus_shared_e8m0 cluster=Microscaling status=Verified standard="OCP MX v1.0" use_case="LLM inference" gf_relation=ally source="Rouhani 2023 (arXiv:2310.10537)"
  fn mxfp8() -> str { return "mxfp8"; }

  // CATALOG: id=mxfp6 name="MXFP6" bits=6 s=1 e=3 m=2 bias=3 phi_distance=0.882 storage=u8_packed_plus_e8m0 cluster=Microscaling status=Verified standard="OCP MX v1.0" use_case="aggressive inference" gf_relation=ally source="Rouhani 2023"
  fn mxfp6() -> str { return "mxfp6"; }

  // CATALOG: id=mxfp4 name="MXFP4" bits=4 s=1 e=2 m=1 bias=1 phi_distance=1.382 storage=u8_packed_plus_e8m0 cluster=Microscaling status=Verified standard="OCP MX v1.0" use_case="extreme quant" gf_relation=ally source="Rouhani 2023"
  fn mxfp4() -> str { return "mxfp4"; }

  // ============================================================
  // 12.2.6 Quantization-tuned non-uniform formats
  // ============================================================

  // CATALOG: id=nf4 name="NF4 (NormalFloat 4-bit)" bits=4 s=0 e=0 m=4 bias=0 phi_distance=-1.0 storage=u8_packed cluster=QuantTuned status=Verified standard="Dettmers 2023 (QLoRA)" use_case="LLM weight quantization (quantile-based on N(0,1))" gf_relation=orthogonal source="Dettmers 2023 (arXiv:2305.14314)"
  fn nf4() -> str { return "nf4"; }

  // CATALOG: id=afp name="AFP (Adaptive Floating-Point)" bits=16 s=1 e=8 m=7 bias=127 phi_distance=-1.0 storage=u16_plus_tensor_shift cluster=QuantTuned status=Verified standard="Tambe 2020" use_case="efficient training" gf_relation=orthogonal source="Tambe 2020 (DAC)"
  fn afp() -> str { return "afp"; }

  // ============================================================
  // 12.2.7 Posit / unum III. es-schedule per ratified-2022 standard
  //                          (es=2 for all widths).
  // ============================================================

  // CATALOG: id=posit8 name="Posit8" bits=8 s=1 e=2 m=0 bias=0 phi_distance=-1.0 storage=u8 cluster=PositUnumIII status=Verified standard="Posit Standard 2022 (es=2)" use_case="inference" gf_relation=ally source="Posit Standard 2022 (posithub.org)"
  fn posit8() -> str { return "posit8"; }

  // CATALOG: id=posit16 name="Posit16" bits=16 s=1 e=2 m=0 bias=0 phi_distance=-1.0 storage=u16 cluster=PositUnumIII status=Verified standard="Posit Standard 2022 (es=2)" use_case="mixed-precision training" gf_relation=ally source="Posit Standard 2022"
  fn posit16() -> str { return "posit16"; }

  // CATALOG: id=posit32 name="Posit32" bits=32 s=1 e=2 m=0 bias=0 phi_distance=-1.0 storage=u32 cluster=PositUnumIII status=Verified standard="Posit Standard 2022 (es=2)" use_case="f32 replacement" gf_relation=ally source="Posit Standard 2022"
  fn posit32() -> str { return "posit32"; }

  // CATALOG: id=posit64 name="Posit64" bits=64 s=1 e=2 m=0 bias=0 phi_distance=-1.0 storage=u64 cluster=PositUnumIII status=Verified standard="Posit Standard 2022 (es=2)" use_case="f64 replacement" gf_relation=ally source="Posit Standard 2022"
  fn posit64() -> str { return "posit64"; }

  // takum -- the strongest live counterexample to GF breadth-as-moat.

  // CATALOG: id=takum8 name="takum8" bits=8 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=u8 cluster=PositUnumIII status=Verified standard="Hunhold 2024 (tapered-precision)" use_case="IEEE-754 backward-compatible tapered" gf_relation=ally source="Hunhold 2024 (arXiv:2404.18603)"
  fn takum8() -> str { return "takum8"; }

  // CATALOG: id=takum16 name="takum16" bits=16 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=u16 cluster=PositUnumIII status=Verified standard="Hunhold 2024" use_case="single-rule ladder counterexample" gf_relation=ally source="Hunhold 2024 (arXiv:2404.18603)"
  fn takum16() -> str { return "takum16"; }

  // CATALOG: id=takum32 name="takum32" bits=32 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=u32 cluster=PositUnumIII status=Verified standard="Hunhold 2024" use_case="tapered fp32-class" gf_relation=ally source="Hunhold 2024"
  fn takum32() -> str { return "takum32"; }

  // CATALOG: id=takum64 name="takum64" bits=64 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=u64 cluster=PositUnumIII status=Verified standard="Hunhold 2024" use_case="tapered fp64-class" gf_relation=ally source="Hunhold 2024"
  fn takum64() -> str { return "takum64"; }

  // ============================================================
  // 12.2.8 LNS -- Logarithmic Number System
  // ============================================================

  // CATALOG: id=lns8 name="LNS-8" bits=8 s=1 e=7 m=0 bias=0 phi_distance=-1.0 storage=u8 cluster=Lns status=Verified standard="Arnold 1990; LNS-Madam (2021)" use_case="DSP, signal processing" gf_relation=orthogonal source="Alam 2021 (arXiv:2106.13914)"
  fn lns8() -> str { return "lns8"; }

  // CATALOG: id=lns16 name="LNS-16" bits=16 s=1 e=15 m=0 bias=0 phi_distance=-1.0 storage=u16 cluster=Lns status=Verified standard="LNS-Madam (2021)" use_case="log-domain training (mul -> add)" gf_relation=orthogonal source="Alam 2021"
  fn lns16() -> str { return "lns16"; }

  // CATALOG: id=lns32 name="LNS-32" bits=32 s=1 e=31 m=0 bias=0 phi_distance=-1.0 storage=u32 cluster=Lns status=Verified standard="LNS-Madam (2021)" use_case="log-domain DSP" gf_relation=orthogonal source="Alam 2021"
  fn lns32() -> str { return "lns32"; }

  // CATALOG: id=lns64 name="LNS-64" bits=64 s=1 e=63 m=0 bias=0 phi_distance=-1.0 storage=u64 cluster=Lns status=Verified standard="LNS-Madam (2021)" use_case="scientific log-domain" gf_relation=orthogonal source="Alam 2021"
  fn lns64() -> str { return "lns64"; }

  // ============================================================
  // 12.2.9 GoldenFloat family (this work)
  //
  // Rule: e = round((N-1) / phi^2). 9/9 verified across the realised
  // ladder. Anchor: phi^2 + phi^-2 = 3 (Lucas L2, 1878). Verified.
  // Moat (per-rung accuracy + toolchain coherence beating posit / takum
  // / OCP-MX / LNS): Open conjecture, lives only in FL-002 with Fpath.
  // ============================================================

  // Realised rungs.

  // CATALOG: id=gfternary name="GFTernary" bits=2 s=1 e=0 m=2 bias=0 phi_distance=0.000 storage=u2 cluster=GoldenFloat status=Verified standard="this work; {-phi, 0, +phi}" use_case="bulk layers (hybrid)" gf_relation=self source="BENCH-007"
  fn gfternary() -> str { return "gfternary"; }

  // CATALOG: id=gf4 name="GF4" bits=4 s=1 e=1 m=2 bias=0 phi_distance=0.118 storage=u8 cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; F0 minimal" use_case="proof-of-concept" gf_relation=self source="specs/numeric/gf4.t27"
  fn gf4() -> str { return "gf4"; }

  // CATALOG: id=gf8 name="GF8" bits=8 s=1 e=3 m=4 bias=3 phi_distance=0.132 storage=u8 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; L1 Lucas" use_case="edge / sensors" gf_relation=self source="BENCH-007 (specs/numeric/gf8.t27)"
  fn gf8() -> str { return "gf8"; }

  // CATALOG: id=gf12 name="GF12" bits=12 s=1 e=4 m=7 bias=7 phi_distance=0.047 storage=u16 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; L0/F3" use_case="mid-range / audio" gf_relation=self source="BENCH-007 (specs/numeric/gf12.t27)"
  fn gf12() -> str { return "gf12"; }

  // CATALOG: id=gf16 name="GF16" bits=16 s=1 e=6 m=9 bias=31 phi_distance=0.049 storage=u16 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; PHI_BIAS=60; FPGA 35/35 on Artix-7 (no frequency claimed; 323 MHz withdrawn, see RESEARCH_CLAIMS.md)" use_case="training and inference (production)" gf_relation=self source="specs/numeric/gf16.t27; zenodo 10.5281/zenodo.19227877 (HW archive)"
  fn gf16() -> str { return "gf16"; }

  // CATALOG: id=gf20 name="GF20" bits=20 s=1 e=7 m=12 bias=63 phi_distance=0.035 storage=u32 cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; 17-squared empirical PHI_BIAS=289" use_case="high-precision edge" gf_relation=self source="specs/numeric/gf20.t27 (spec only)"
  fn gf20() -> str { return "gf20"; }

  // CATALOG: id=gf24 name="GF24" bits=24 s=1 e=9 m=14 bias=255 phi_distance=0.025 storage=u32 cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; rule e=round(23/phi^2)=9; normative bias=2^(e-1)-1=255; empirical PHI_BIAS=1364 (=L15) OPEN" use_case="server inference" gf_relation=self source="specs/numeric/gf24.t27 (spec only)"
  fn gf24() -> str { return "gf24"; }

  // CATALOG: id=gf32 name="GF32" bits=32 s=1 e=12 m=19 bias=2047 phi_distance=0.014 storage=u32 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; F0 resolved" use_case="fp32 drop-in" gf_relation=self source="BENCH-012 (specs/numeric/gf32.t27)"
  fn gf32() -> str { return "gf32"; }

  // CATALOG: id=gf64 name="GF64" bits=64 s=1 e=24 m=39 bias=8388607 phi_distance=0.003 storage=u64 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; EXP_MAX - BIAS" use_case="scientific / double" gf_relation=self source="BENCH-007b (specs/numeric/gf64.t27)"
  fn gf64() -> str { return "gf64"; }

  // Predicted / spec-only GF rungs (rule-derived under FORMAT-SPEC-001 v1.2).
  // Closed-form normative rule: e = round((N-1)/phi^2); m = N-1-e;
  //                              bias = 2^(e-1)-1; exp_max = 2^e - 1.

  // CATALOG: id=gf6 name="GF6 (rule-derived)" bits=6 s=1 e=2 m=3 bias=1 phi_distance=0.049 storage=u8_packed cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(5/phi^2)=2; FP6 E2M3 bridge" use_case="OPEN R&D: bridge GF4-GF8; FP6 E2M3 hint" gf_relation=experimental source="specs/numeric/gf6.t27"
  fn gf6() -> str { return "gf6"; }

  // CATALOG: id=gf10 name="GF10 (rule-derived)" bits=10 s=1 e=3 m=6 bias=3 phi_distance=0.118 storage=u16 cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(9/phi^2)=3; bridge GF8-GF12" use_case="OPEN R&D: tight-precision activations" gf_relation=experimental source="specs/numeric/gf10.t27"
  fn gf10() -> str { return "gf10"; }

  // CATALOG: id=gf14 name="GF14 (rule-derived)" bits=14 s=1 e=5 m=8 bias=15 phi_distance=0.007 storage=u16 cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(13/phi^2)=5; bridge GF12-GF16; lowest phi-dist below GF48" use_case="OPEN R&D: drop-in for fp16 with tighter phi alignment" gf_relation=experimental source="specs/numeric/gf14.t27"
  fn gf14() -> str { return "gf14"; }

  // CATALOG: id=gf48 name="GF48 (rule-derived)" bits=48 s=1 e=18 m=29 bias=131071 phi_distance=0.003 storage=u64_padded cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(47/phi^2)=18" use_case="OPEN R&D: between GF32 and GF64; tightest phi-dist of the wide rungs" gf_relation=experimental source="specs/numeric/gf48.t27"
  fn gf48() -> str { return "gf48"; }

  // CATALOG: id=gf96 name="GF96 (rule-derived)" bits=96 s=1 e=36 m=59 bias=34359738367 phi_distance=0.008 storage=u128_padded cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(95/phi^2)=36" use_case="OPEN R&D: between GF64 and GF128 (phi-aligned extended)" gf_relation=experimental source="specs/numeric/gf96.t27"
  fn gf96() -> str { return "gf96"; }

  // CATALOG: id=gf128 name="GF128 (rule-derived)" bits=128 s=1 e=49 m=78 bias=281474976710655 phi_distance=0.010 storage=u128 cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(127/phi^2)=49 (corrects v1.1 typo e=48)" use_case="OPEN R&D: phi-aligned binary128 alternative" gf_relation=experimental source="specs/numeric/gf128.t27"
  fn gf128() -> str { return "gf128"; }

  // CATALOG: id=gf256 name="GF256 (rule-derived)" bits=256 s=1 e=97 m=158 bias=79228162514264337593543950335 phi_distance=0.004 storage=u256_software cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(255/phi^2)=97; normative bias=2^96-1" use_case="OPEN R&D: phi-aligned binary256 alternative" gf_relation=experimental source="specs/numeric/gf256.t27"
  fn gf256() -> str { return "gf256"; }

  // CATALOG: id=gf512 name="GF512 (rule-derived)" bits=512 s=1 e=195 m=316 bias=2^194-1 phi_distance=0.0009 storage=u512_software cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(511/phi^2)=195" use_case="OPEN R&D: ultra-wide phi-aligned (extrapolation, no RTL)" gf_relation=experimental source="specs/numeric/gf512.t27"
  fn gf512() -> str { return "gf512"; }

  // CATALOG: id=gf1024 name="GF1024 (rule-derived)" bits=1024 s=1 e=391 m=632 bias=2^390-1 phi_distance=0.0006 storage=u1024_software cluster=GoldenFloat rule=phi-ratio status=Open standard="this work; rule e=round(1023/phi^2)=391; lowest phi-distance in the ladder" use_case="OPEN R&D: limit-of-ladder phi alignment (extrapolation, no RTL)" gf_relation=experimental source="specs/numeric/gf1024.t27"



  // ---------------------------------------------------------------------
  // GF-T -- the phi-lineage ternary ladder. NOT an old name for TNF.
  //
  // Four families, two axes: phi-derived vs theorem-derived, binary vs ternary.
  //   GF   phi, binary      e = round((N-1)/phi^2)
  //   GF-T phi, ternary     mantissa from the phi lineage, exponent in trits
  //   BNF  theorem, binary  1 + E + M = N, exponent sized for range
  //   TNF  theorem, ternary 1 + E_t + M = N, exponent sized for range
  //
  // 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),
  // M takes the rest. Every rung lands exactly and E_t/M converges on 1/phi.
  //
  // What it buys is range and what it costs is mantissa. At 64 bits GF-T spans
  // 1.3e8 times TNF's range for 1.2e5 times the error -- neither dominates, and the
  // corollary on the pair (M_eff, binades) forbids ranking them without a workload.
  //
  // This supersedes ad-hoc parameters the family carried until 2026-08-09, where
  // exponents were sized at roughly log2(N) trits with no rule and positions were
  // left unspent.
  // ---------------------------------------------------------------------
  // CATALOG: id=gft4 name="GF-T4" bits=4 s=1 e=1 m=2 bias=1 phi_distance=0.1180 storage=u4 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.5000 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft4.t27"
  // CATALOG: id=gft8 name="GF-T8" bits=8 s=1 e=3 m=4 bias=13 phi_distance=0.1320 storage=u8 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.7500 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft8.t27"
  // CATALOG: id=gft16 name="GF-T16" bits=16 s=1 e=6 m=9 bias=364 phi_distance=0.0486 storage=u16 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6667 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft16.t27"
  // CATALOG: id=gft32 name="GF-T32" bits=32 s=1 e=12 m=19 bias=265720 phi_distance=0.0135 storage=u32 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6316 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft32.t27"
  // CATALOG: id=gft64 name="GF-T64" bits=64 s=1 e=24 m=39 bias=141214768240 phi_distance=0.0026 storage=u64 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6154 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft64.t27"
  // CATALOG: id=gft128 name="GF-T128" bits=128 s=1 e=49 m=78 bias=119649664615308764795041 phi_distance=0.0102 storage=u128 cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6282 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft128.t27"
  // CATALOG: id=gft256 name="GF-T256" bits=256 s=1 e=97 m=158 bias=9544028161703913537712243143807801346335324481 phi_distance=0.0041 storage=u256_software cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6139 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft256.t27"
  // CATALOG: id=gft512 name="GF-T512" bits=512 s=1 e=195 m=316 bias=546530841308384299050990374559217339154801342908219127519701567364387841360704080235359463053 phi_distance=0.0009 storage=u512_software cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6171 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft512.t27"
  // CATALOG: id=gft1024 name="GF-T1024" bits=1024 s=1 e=391 m=632 bias=1792175763007502050309004510896072657026569872803620275437464390826146561794008386845991427359831686179824019072939996745082807322862992600064651843076138216429413334444960452990989263173 phi_distance=0.0006 storage=u1024_software cluster=GoldenFloat rule=phi-ratio status=Verified standard="this work; GOLDEN RATIO axis: E_t = round((N-1)/phi^2), a trit is a position; every position spent; E_t/M = 0.6187 against 1/phi = 0.6180" use_case="phi-derived ternary ladder; huge range at the cost of mantissa" gf_relation=self source="specs/numeric/gft1024.t27"

  // ---------------------------------------------------------------------
  // BNF -- Binary Network Float. The CONTROL for TNF.
  //
  // BNF and TNF are derived from the same theorem and differ in exactly one
  // thing: the radix the exponent FIELD is encoded in. Everything else is
  // identical -- the width rule 1 + E + M = N, the binary radix of the SCALE,
  // the uniform mantissa. The pair therefore measures what the ternary encoding
  // is worth instead of asserting it.
  //
  // Measured: on a binary fabric the two are identical at every width, exactly
  // as the no-free-range theorem requires. On a ternary fabric TNF's exponent
  // costs one position fewer, which goes to the mantissa and is worth exactly 2x
  // in error by the precision law. Not more, not less, and the same at every rung.
  //
  // NOT the golden-ratio family. GF sizes its exponent by e = round((N-1)/phi^2)
  // and GF-T inherits that mantissa into trits, leaving positions unspent. BNF
  // and TNF size the exponent for the range the workload needs and then spend
  // every position that remains. Four formats, two axes: phi vs theorem-derived,
  // binary vs ternary.
  // ---------------------------------------------------------------------
  // CATALOG: id=bnf8 name="BNF8" bits=8 s=1 e=5 m=2 bias=15 phi_distance=1.882 storage=u8 cluster=GoldenFloat status=Open standard="this work; control for TNF8; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf8.t27"
  // CATALOG: id=bnf16 name="BNF16" bits=16 s=1 e=7 m=8 bias=63 phi_distance=0.257 storage=u16 cluster=GoldenFloat status=Open standard="this work; control for TNF16; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf16.t27"
  // CATALOG: id=bnf32 name="BNF32" bits=32 s=1 e=10 m=21 bias=511 phi_distance=0.142 storage=u32 cluster=GoldenFloat status=Open standard="this work; control for TNF32; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf32.t27"
  // CATALOG: id=bnf64 name="BNF64" bits=64 s=1 e=12 m=51 bias=2047 phi_distance=0.383 storage=u64 cluster=GoldenFloat status=Open standard="this work; control for TNF64; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf64.t27"
  // CATALOG: id=bnf128 name="BNF128" bits=128 s=1 e=13 m=114 bias=4095 phi_distance=0.504 storage=u128 cluster=GoldenFloat status=Open standard="this work; control for TNF128; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf128.t27"
  // CATALOG: id=bnf256 name="BNF256" bits=256 s=1 e=15 m=240 bias=16383 phi_distance=0.556 storage=u256_software cluster=GoldenFloat status=Open standard="this work; control for TNF256; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf256.t27"
  // CATALOG: id=bnf512 name="BNF512" bits=512 s=1 e=16 m=495 bias=32767 phi_distance=0.586 storage=u512_software cluster=GoldenFloat status=Open standard="this work; control for TNF512; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf512.t27"
  // CATALOG: id=bnf1024 name="BNF1024" bits=1024 s=1 e=18 m=1005 bias=131071 phi_distance=0.600 storage=u1024_software cluster=GoldenFloat status=Open standard="this work; control for TNF1024; width rule 1+E+M=N; exponent sized for range not phi" use_case="control isolating the ternary encoding's contribution" gf_relation=self source="specs/numeric/bnf1024.t27"

  // ---------------------------------------------------------------------
  // TNF -- Ternary Network Float. Built as a reference for TERNARY NETWORKS,
  // where the weight is in {-1,0,+1} and the multiply disappears. The exponent
  // FIELD is balanced ternary; the
  // RADIX is binary. A genuine ternary-radix float (scaling by 3^e, as Ternary27
  // does) measures 0.331 positions per number worse at equal width, so the name
  // deliberately claims the encoding and not the radix.
  //
  // Distinct from GFTernary (a 2-bit {-phi, 0, +phi} alphabet, not a float at
  // all) and from the binary GF ladder above. A glob of gft* matches gfternary;
  // it has already cost this repository a deleted spec and a dropped pack index
  // entry. Match tef[0-9]+ or gft[0-9]+, never a bare prefix.
  //
  // FORMER NAMES: GF-T (2026 and earlier), then TEF for one day on 2026-08-09, renamed 2026-08-09, carried in
  // former_name= on every row. The ladder has NEVER been published under either
  // name -- arXiv:2606.05017 is the binary GF family and contains no occurrence
  // of "GF-T", and arXiv:2606.09686 is this catalog, which had zero GF-T rows
  // until they were added on 2026-08-09. The rename therefore retracts nothing
  // and breaks no citation. former_name= is for internal continuity only:
  // research notes, prior branches and the author's CV and profile carry the old
  // label, and this campaign's measurements against takum/tekum/posit were
  // recorded under it.
  //
  // Two fields below need reading with care:
  //   e=   is a count of balanced-ternary TRITS, not bits. The bit-equivalent
  //        is Et*log2(3) and is given in the standard= string of each row.
  //   phi_distance= is computed by the catalog's own |e/m - 1/phi| on that
  //        bit-equivalent. It rises toward 1/phi = 0.618 as N grows, and that
  //        is structural rather than a defect: GF sizes its exponent by
  //        e = round((N-1)/phi^2), which puts e/m at 1/phi by construction,
  //        while TNF sizes its exponent for RANGE and takes M = N-1-Et.
  //        The two ladders optimise different axes; the field makes it visible.
  // ---------------------------------------------------------------------
  // CATALOG: id=tnf4 name="TNF4" former_name="GF-T4" bits=4 s=1 e=2 m=1 bias=4 phi_distance=2.552 storage=u4 cluster=GoldenFloat status=Verified standard="this work; e is 2 balanced-ternary TRITS not bits (3.17 bits equivalent); width rule 1+Et+M=N; post-route XC7A200T 12 LUT 161.1 MHz, no DSP, 1 cycle" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf4.t27"
  // CATALOG: id=tnf8 name="TNF8" former_name="GF-T8" bits=8 s=1 e=3 m=4 bias=13 phi_distance=0.571 storage=u8 cluster=GoldenFloat status=Verified standard="this work; e is 3 balanced-ternary TRITS not bits (4.75 bits equivalent); width rule 1+Et+M=N; post-route XC7A200T 50 LUT 153.2 MHz, no DSP, 1 cycle" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf8.t27"
  // CATALOG: id=tnf16 name="TNF16" former_name="GF-T16" bits=16 s=1 e=4 m=11 bias=40 phi_distance=0.0417 storage=u16 cluster=GoldenFloat status=Verified standard="this work; e is 4 balanced-ternary TRITS not bits (6.34 bits equivalent); width rule 1+Et+M=N; post-route XC7A200T 212 LUT 131.7 MHz, no DSP, 1 cycle" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf16.t27"
  // CATALOG: id=tnf32 name="TNF32" former_name="GF-T32" bits=32 s=1 e=6 m=25 bias=364 phi_distance=0.238 storage=u32 cluster=GoldenFloat status=Verified standard="this work; e is 6 balanced-ternary TRITS not bits (9.51 bits equivalent); width rule 1+Et+M=N; post-route XC7A200T 1477 LUT 83.3 MHz, no DSP, 1 cycle" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf32.t27"
  // CATALOG: id=tnf64 name="TNF64" former_name="GF-T64" bits=64 s=1 e=7 m=56 bias=1093 phi_distance=0.420 storage=u64 cluster=GoldenFloat status=Verified standard="this work; e is 7 balanced-ternary TRITS not bits (11.09 bits equivalent); width rule 1+Et+M=N; post-route XC7A200T 7479 LUT 48.2 MHz, no DSP, 1 cycle" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf64.t27"
  // CATALOG: id=tnf128 name="TNF128" former_name="GF-T128" bits=128 s=1 e=8 m=119 bias=3280 phi_distance=0.511 storage=u128 cluster=GoldenFloat status=Open standard="this work; e is 8 balanced-ternary TRITS not bits (12.68 bits equivalent); width rule 1+Et+M=N; derived from the width rule; not synthesised" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf128.t27"
  // CATALOG: id=tnf256 name="TNF256" former_name="GF-T256" bits=256 s=1 e=9 m=246 bias=9841 phi_distance=0.560 storage=u256_software cluster=GoldenFloat status=Open standard="this work; e is 9 balanced-ternary TRITS not bits (14.26 bits equivalent); width rule 1+Et+M=N; derived from the width rule; not synthesised" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf256.t27"
  // CATALOG: id=tnf512 name="TNF512" former_name="GF-T512" bits=512 s=1 e=10 m=501 bias=29524 phi_distance=0.586 storage=u512_software cluster=GoldenFloat status=Open standard="this work; e is 10 balanced-ternary TRITS not bits (15.85 bits equivalent); width rule 1+Et+M=N; derived from the width rule; not synthesised" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf512.t27"
  // CATALOG: id=tnf1024 name="TNF1024" former_name="GF-T1024" bits=1024 s=1 e=11 m=1012 bias=88573 phi_distance=0.601 storage=u1024_software cluster=GoldenFloat status=Open standard="this work; e is 11 balanced-ternary TRITS not bits (17.43 bits equivalent); width rule 1+Et+M=N; derived from the width rule; not synthesised" use_case="fixed-field ternary-exponent ladder; no regime codec" gf_relation=self source="specs/numeric/tnf1024.t27"
  fn gf1024() -> str { return "gf1024"; }

  // GF hybrids / experimental compositions (Section 12.5).

  // CATALOG: id=gf8_bfp name="GF8-BFP (block FP atop GF8)" bits=8 s=1 e=3 m=4 bias=3 phi_distance=0.132 storage=u8_plus_shared_exp cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; per-tile shared exponent" use_case="OPEN R&D: LLM-quantization-friendly GF8" gf_relation=experimental source="section12.5"
  fn gf8_bfp() -> str { return "gf8_bfp"; }

  // CATALOG: id=gf_lns_hybrid name="GF + LNS hybrid (dual-space)" bits=16 s=1 e=6 m=9 bias=31 phi_distance=0.049 storage=u16_plus_lns_path cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; mul in log-space, accumulate Lucas-closed" use_case="OPEN R&D: dual-space arithmetic" gf_relation=experimental source="section12.5"
  fn gf_lns_hybrid() -> str { return "gf_lns_hybrid"; }

  // CATALOG: id=mxgf6 name="MXGF6 (microscaling GF6)" bits=6 s=1 e=2 m=3 bias=1 phi_distance=0.05 storage=u8_packed_plus_e8m0 cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; OCP MX block + GF6" use_case="OPEN R&D: phi-aligned MX-6 candidate" gf_relation=experimental source="section12.5"
  fn mxgf6() -> str { return "mxgf6"; }

  // CATALOG: id=mxgf4 name="MXGF4 (microscaling GF4)" bits=4 s=1 e=1 m=2 bias=0 phi_distance=0.118 storage=u8_packed_plus_e8m0 cluster=GoldenFloat rule=phi-ratio status=Experimental standard="this work; OCP MX block + GF4" use_case="OPEN R&D: phi-aligned MX-4 candidate" gf_relation=experimental source="section12.5"
  fn mxgf4() -> str { return "mxgf4"; }

  // ============================================================
  // 12.2.10 Integer / fixed-point
  // ============================================================

  // CATALOG: id=int4 name="INT4 / UINT4" bits=4 s=1 e=0 m=3 bias=0 phi_distance=-1.0 storage=u8_packed cluster=IntegerFixed status=Verified standard="two complement" use_case="aggressive quantization" gf_relation=competitor source="ISO/IEC 9899"
  fn int4() -> str { return "int4"; }

  // CATALOG: id=int8 name="INT8 / UINT8" bits=8 s=1 e=0 m=7 bias=0 phi_distance=-1.0 storage=u8 cluster=IntegerFixed status=Verified standard="two complement" use_case="INT8 inference, per-channel scale" gf_relation=competitor source="ISO/IEC 9899"
  fn int8() -> str { return "int8"; }

  // CATALOG: id=int16 name="INT16 / UINT16" bits=16 s=1 e=0 m=15 bias=0 phi_distance=-1.0 storage=u16 cluster=IntegerFixed status=Verified standard="two complement" use_case="DSP, embedded ML" gf_relation=competitor source="ISO/IEC 9899"
  fn int16() -> str { return "int16"; }

  // CATALOG: id=int32 name="INT32 / UINT32" bits=32 s=1 e=0 m=31 bias=0 phi_distance=-1.0 storage=u32 cluster=IntegerFixed status=Verified standard="two complement" use_case="general CPU integer" gf_relation=competitor source="ISO/IEC 9899"
  fn int32() -> str { return "int32"; }

  // CATALOG: id=int64 name="INT64 / UINT64" bits=64 s=1 e=0 m=63 bias=0 phi_distance=-1.0 storage=u64 cluster=IntegerFixed status=Verified standard="two complement" use_case="databases, timestamps" gf_relation=competitor source="ISO/IEC 9899"
  fn int64() -> str { return "int64"; }

  // CATALOG: id=int128 name="INT128 / UINT128" bits=128 s=1 e=0 m=127 bias=0 phi_distance=-1.0 storage=u128 cluster=IntegerFixed status=Verified standard="two complement" use_case="crypto, big-int" gf_relation=competitor source="Rust/Clang u128"
  fn int128() -> str { return "int128"; }

  // CATALOG: id=q_format name="Q-format (Qm.n)" bits=0 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=IntegerFixed status=Verified standard="TI fixed-point" use_case="audio DSP, fixed-point ML" gf_relation=orthogonal source="TI SPRA704"
  fn q_format() -> str { return "q_format"; }

  // CATALOG: id=bcd name="BCD (binary-coded decimal)" bits=0 s=0 e=0 m=0 bias=0 phi_distance=-1.0 storage=u4_per_digit cluster=IntegerFixed status=Historical standard="IBM 1959" use_case="calculators, GAAP" gf_relation=orthogonal source="ISO/IEC 8859"
  fn bcd() -> str { return "bcd"; }

  // ============================================================
  // 12.2.11 Historical / vendor
  // ============================================================

  // CATALOG: id=ibm_hfp32 name="IBM HFP (single)" bits=32 s=1 e=7 m=24 bias=64 phi_distance=-1.0 storage=u32 cluster=HistoricalVendor status=Historical standard="IBM System/360 (1964); base-16 exponent" use_case="legacy mainframe" gf_relation=orthogonal source="IBM POO"
  fn ibm_hfp32() -> str { return "ibm_hfp32"; }

  // CATALOG: id=ibm_hfp64 name="IBM HFP (double)" bits=64 s=1 e=7 m=56 bias=64 phi_distance=-1.0 storage=u64 cluster=HistoricalVendor status=Historical standard="IBM System/360 (1964)" use_case="legacy mainframe" gf_relation=orthogonal source="IBM POO"
  fn ibm_hfp64() -> str { return "ibm_hfp64"; }

  // CATALOG: id=ibm_hfp128 name="IBM HFP (extended)" bits=128 s=1 e=7 m=120 bias=64 phi_distance=-1.0 storage=u128 cluster=HistoricalVendor status=Historical standard="IBM z/Architecture" use_case="legacy mainframe" gf_relation=orthogonal source="IBM POO"
  fn ibm_hfp128() -> str { return "ibm_hfp128"; }

  // CATALOG: id=ms_mbf32 name="Microsoft MBF (single)" bits=32 s=1 e=8 m=23 bias=129 phi_distance=-1.0 storage=u32 cluster=HistoricalVendor status=Historical standard="MS BASIC / MS-DOS (pre-IEEE)" use_case="MS BASIC legacy" gf_relation=orthogonal source="MS-DOS docs"
  fn ms_mbf32() -> str { return "ms_mbf32"; }

  // CATALOG: id=ms_mbf64 name="Microsoft MBF (double)" bits=64 s=1 e=8 m=55 bias=129 phi_distance=-1.0 storage=u64 cluster=HistoricalVendor status=Historical standard="MS BASIC" use_case="MS BASIC legacy" gf_relation=orthogonal source="MS-DOS docs"
  fn ms_mbf64() -> str { return "ms_mbf64"; }

  // CATALOG: id=vax_f name="VAX F-float" bits=32 s=1 e=8 m=23 bias=128 phi_distance=-1.0 storage=u32 cluster=HistoricalVendor status=Historical standard="DEC VAX" use_case="DEC legacy" gf_relation=orthogonal source="VAX Architecture Reference"
  fn vax_f() -> str { return "vax_f"; }

  // CATALOG: id=vax_d name="VAX D-float" bits=64 s=1 e=8 m=55 bias=128 phi_distance=-1.0 storage=u64 cluster=HistoricalVendor status=Historical standard="DEC VAX" use_case="DEC legacy double" gf_relation=orthogonal source="VAX Architecture Reference"
  fn vax_d() -> str { return "vax_d"; }

  // CATALOG: id=vax_g name="VAX G-float" bits=64 s=1 e=11 m=52 bias=1024 phi_distance=-1.0 storage=u64 cluster=HistoricalVendor status=Historical standard="DEC VAX (IEEE-like)" use_case="DEC legacy" gf_relation=orthogonal source="VAX Architecture Reference"
  fn vax_g() -> str { return "vax_g"; }

  // CATALOG: id=vax_h name="VAX H-float" bits=128 s=1 e=15 m=112 bias=16384 phi_distance=-1.0 storage=u128 cluster=HistoricalVendor status=Historical standard="DEC VAX" use_case="DEC quad" gf_relation=orthogonal source="VAX Architecture Reference"
  fn vax_h() -> str { return "vax_h"; }

  // CATALOG: id=cray_float name="Cray float" bits=64 s=1 e=15 m=48 bias=16384 phi_distance=-1.0 storage=u64 cluster=HistoricalVendor status=Historical standard="Cray-1 (1976); no NaN/Inf, unrounded mul" use_case="Cray legacy" gf_relation=orthogonal source="Cray-1 Hardware Reference"
  fn cray_float() -> str { return "cray_float"; }

  // ============================================================
  // 12.2.12 Theoretical / parametric frameworks
  // ============================================================

  // CATALOG: id=minifloat name="minifloat (arbitrary E:M, <=16 bits)" bits=0 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=Theoretical status=Experimental standard="parametric framework" use_case="design space of GF4/GF8/GF12/GF16" gf_relation=ally source="Higham 1996"
  fn minifloat() -> str { return "minifloat"; }

  // CATALOG: id=unum_i name="Unum I (tapered + ubound)" bits=0 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=Theoretical status=Experimental standard="Gustafson 2015 (predecessor to posit)" use_case="interval arithmetic" gf_relation=ally source="Gustafson 2015 (The End of Error)"
  fn unum_i() -> str { return "unum_i"; }

  // CATALOG: id=unum_ii name="Unum II (SORN projective)" bits=0 s=0 e=0 m=0 bias=0 phi_distance=-1.0 storage=lookup_table cluster=Theoretical status=Experimental standard="Gustafson 2016" use_case="lookup-table real arithmetic; not GF-comparable" gf_relation=orthogonal source="Gustafson 2016"
  fn unum_ii() -> str { return "unum_ii"; }

  // CATALOG: id=tapered_fp name="tapered floating point" bits=0 s=1 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=Theoretical status=Experimental standard="Morris 1971; posit ancestor" use_case="variable mantissa via regime bits" gf_relation=ally source="Morris 1971 (IEEE TC)"
  fn tapered_fp() -> str { return "tapered_fp"; }

  // ============================================================
  // 12.2.13 Compression / quantization tricks (apply atop a base format)
  // ============================================================

  // CATALOG: id=block_fp name="block floating point (BFP)" bits=0 s=0 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=CompressionTrick status=Verified standard="Wilkinson 1965; modern revivals" use_case="per-tile shared exponent" gf_relation=ally source="Darvish-Rouhani 2020"
  fn block_fp() -> str { return "block_fp"; }

  // CATALOG: id=shared_exp name="shared-exponent formats" bits=0 s=0 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=CompressionTrick status=Verified standard="generalised BFP" use_case="LLM quantization" gf_relation=ally source="Darvish-Rouhani 2020"
  fn shared_exp() -> str { return "shared_exp"; }

  // CATALOG: id=per_channel_scale name="INT8 with per-channel scale" bits=8 s=1 e=0 m=7 bias=0 phi_distance=-1.0 storage=u8_plus_fp32_scale cluster=CompressionTrick status=Verified standard="Jacob 2018 (TFLite)" use_case="standard quant inference" gf_relation=competitor source="Jacob 2018 (CVPR)"
  fn per_channel_scale() -> str { return "per_channel_scale"; }

  // CATALOG: id=stochastic_rounding name="stochastic rounding (technique)" bits=0 s=0 e=0 m=0 bias=0 phi_distance=-1.0 storage=varies cluster=CompressionTrick status=Verified standard="Gupta 2015" use_case="training small networks at low precision" gf_relation=ally source="Gupta 2015 (ICML)"
  fn stochastic_rounding() -> str { return "stochastic_rounding"; }

}

// EOF formats_catalog.t27

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

Все уроки

• Модуль 1 · Зачем проверять

  Дизайны, которые компилируются и ошибаются; модель, которая выносит вердикт; план, записанный до кода.

  1. 01 Баги, которые компилируются
  2. 02 Золотая модель
  3. 03 Сначала план

• Модуль 2 · Тестбенчи

  Стимулы, проверки и вердикт, записанные как один spec рядом с дизайном, который они судят.

  1. 04 Анатомия тестбенча
  2. 05 Самопроверка вместо всматривания
  3. 06 Направленные против случайных

• Модуль 3 · Временные диаграммы

  Трасса каждого сигнала, прочитанная так, как её читает инженер по железу, и два прогона, сравнённые между собой.

  1. 07 Формат VCD
  2. 08 Отладка по волнам
  3. 09 Сравнение двух трасс

• Модуль 4 · Векторы соответствия

  Случаи с ответом, записанным рядом, там, откуда их достанет компилятор.

  1. 10 Что такое вектор
  2. 11 Векторы как эталонная линейка
  3. 12 Сквозные сценарии

• Модуль 5 · Косимуляция

  Spec, симулятор и плата сходятся в одном ответе на стенде Artix-7 XC7A200T, и что делать, когда не сходятся.

  1. 13 Тройное согласие
  2. 14 Внутри симулятора
  3. 15 Когда они не сходятся

• Модуль 6 · Покрытие

  Чего коснулись тесты: строки, переключения, состояния — и что прячет это число.

  1. 16 Строки и переключения
  2. 17 Покрытие автоматов
  3. 18 Покрытие лжёт

• Модуль 7 · Формальные методы

  Ассерты, верные каждый такт; ограниченный поиск контрпримера; и почему доказательству нужна индукция.

  1. 19 Ассерты
  2. 20 Ограниченная проверка моделей
  3. 21 Индукция

• Модуль 8 · Мутации

  Ломайте дизайн нарочно и считайте, что заметили тесты.

  1. 22 Убить мутанта
  2. 23 Выжившие мутанты
  3. 24 Сила тестов

• Модуль 9 · Приёмка

  Одна команда, все квитанции, чистый вердикт, который можно показать.

  1. 25 Сборка и проверка
  2. 26 Стенд проверяет себя
  3. 27 Капстоун: проверить модуль целиком