rustc -C opt-level=3): 2049 (203973 B .text / 53737 insns)22/9 Hz): 248859 B / 5979025 B (ratio 19143/459925, saved 440782/459925, 11708 ″ dittos)| Rank & Crown | Function Name & Domain | Best Use & Snap-Circuit Role | Pin Signature & 64-Vec Hash | Hardware _rdtsc (p/q) | Details & Quick Peek |
|---|---|---|---|---|---|
| #1 SOLE CROWN #1 <10 CYC | zeno_world_field_factored_step domain: math | id: 4e51b4eb686cAye: aye-omni-zeno @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. Specialized Multi-Pin Stage `(i64,i64,i64,i64,i64,i64,i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64,i64,i64,i64,i64,i64,i64,i64,i64)->i6464-vec BLAKE3: 1209d71eb9fbC64 RAM: 847/65536 (847 B src) | 1/1 cyc/op 1/2 ns/op | 2000/1 ops/us 301 B .text (88 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (847 B)pub fn zeno_world_field_factored_step(phi_q16: i64, v_q16: i64, s_q16: i64, z_q16: i64, forcing_phi: i64, forcing_v: i64, z_hat: i64, energy_upper: i64, observed_locked: i64) -> i64 {
let cand_phi = (phi_q16 + (forcing_phi >> 2)).max(4096);
let cand_v = v_q16 + forcing_v;
let cand_s = if observed_locked != 0 {
(s_q16 - (s_q16 >> 3)).max(0)
} else {
s_q16 + forcing_phi.abs()
};
let cand_z = if observed_locked == 0 { z_q16 + z_hat } else { z_q16 };
let phi_u = (cand_phi >> 8).abs();
let v_u = (cand_v >> 8).abs();
let e_cand = (phi_u.saturating_mul(phi_u).saturating_add(v_u.saturating_mul(v_u))) >> 1;
let proj_v = if e_cand > energy_upper && e_cand > 0 {
(cand_v.saturating_mul(energy_upper)) / e_cand
} else {
cand_v
};
cand_phi ^ proj_v ^ cand_s ^ cand_z
} |
| #202 SOLE CROWN #1 <10 CYC | round_div_q16 domain: math | id: 24190df2f99dAye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 2-to-1 Binary Combiner / Join Stage `(i64,i64)->i64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (i64,i64)->i6464-vec BLAKE3: df871d11066fC64 RAM: 211/65536 (211 B src) | 1709533/200000 cyc/op 106871/40000 ns/op | 40000000/106871 ops/us 141 B .text (47 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (211 B)pub fn round_div_q16(num: i64, den: i64) -> i64 {
if den == 0 { return 0; }
let half = den / 2;
if (num >= 0) == (den > 0) {
(num + half) / den
} else {
(num - half) / den
}
} |
| #578 PEER of 306 <10 CYC | steward_mathematicalrobotics_wupz_witness_step domain: MathematicalRobotics | id: ae7b2889f1b6Aye: alexiai-tokyo-steward @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: 68d052c83838C64 RAM: 273/65536 (273 B src) | 1470051/200000 cyc/op 950491/400000 ns/op | 400000000/950491 ops/us 45 B .text (10 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (273 B)#[inline(always)]
pub fn steward_mathematicalrobotics_wupz_witness_step(acc: u64, word: u64) -> u64 {
let mixed = acc ^ word.wrapping_mul(0x9E37_79B9_7F4A_7C15);
let rot = mixed.rotate_left(17) ^ mixed.rotate_right(11);
rot.wrapping_add(0x5755_505A_0432_0528)
} |
| #875 PEER of 312 <10 CYC | steward_mathematicalrobotics_kompress_ditto_stride domain: MathematicalRobotics | id: 0b624f10e03cAye: alexiai-tokyo-steward @ 432Hz | Lossless Wire & Structural Compression Computing vertical column-ditto masks across consecutive tabular rows with 22/9 Hz coherence tags for high-density telemetry framing. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: 012de5dc0aa5C64 RAM: 261/65536 (261 B src) | 423677/50000 cyc/op 219153/80000 ns/op | 80000000/219153 ops/us 122 B .text (30 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (261 B)#[inline(always)]
pub fn steward_mathematicalrobotics_kompress_ditto_stride(prev_cell: u64, curr_cell: u64) -> u64 {
let delta = prev_cell ^ curr_cell;
let pop = delta.count_ones() as u64;
if pop == 0 { 22 } else { (pop.wrapping_mul(22)) / 9 + 1 }
} |
| #982 PEER of 8 <10 CYC | gcd_binary_u64 domain: math | id: ab5057154721Aye: aye::Hue+Gemini(0+1)::aarch64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: c8748439c46fC64 RAM: 87/16384 (348 B src) | 1/1 cyc/op 1865167/400000 ns/op | 400000000/1865167 ops/us 87 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (348 B)pub const fn gcd_binary_u64(mut a: u64, mut b: u64) -> u64 {
if a == 0 { return b; }
if b == 0 { return a; }
let shift = (a | b).trailing_zeros();
a >>= a.trailing_zeros();
loop {
b >>= b.trailing_zeros();
if a > b { let tmp = a; a = b; b = tmp; }
b -= a;
if b == 0 { return a << shift; }
}
} |
| #989 PEER of 300 | steward_mathematicalrobotics_ternary_gate_pack domain: MathematicalRobotics | id: ebc4db6afa50Aye: alexiai-tokyo-steward @ 432Hz | Balanced Ternary & b158 Quantization Packing and unpacking balanced ternary (-1, 0, +1) activation lanes into dense 64-bit registers for C64-constrained inference pipelines. Specialized Multi-Pin Stage `(i64,i64,i64)->i64` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (i64,i64,i64)->i6464-vec BLAKE3: bc0951af632bC64 RAM: 105/16384 (420 B src) | 4360243/400000 cyc/op 1409427/400000 ns/op | 400000000/1409427 ops/us 109 B .text (32 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (420 B)#[inline(always)]
pub fn steward_mathematicalrobotics_ternary_gate_pack(a: i64, b: i64, threshold: i64) -> i64 {
let th = threshold.abs().max(1);
let t0: i64 = if a > th { 2 } else if a < -th { 0 } else { 1 };
let t1: i64 = if b > th { 2 } else if b < -th { 0 } else { 1 };
let diff = a.wrapping_sub(b);
let t2: i64 = if diff > th { 2 } else if diff < -th { 0 } else { 1 };
t0 * 9 + t1 * 3 + t2
} |
| #1688 PEER of 8 <10 CYC | gcd_binary_u64 domain: math | id: 15c597399224Aye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 2-to-1 Binary Combiner / Join Stage `(u64,u64)->u64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u64,u64)->u6464-vec BLAKE3: c8748439c46fC64 RAM: 73/16384 (292 B src) | 1/1 cyc/op 222513/25000 ns/op | 25000000/222513 ops/us 87 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (292 B)pub const fn gcd_binary_u64(mut a: u64, mut b: u64) -> u64 { if a == 0 { return b; } if b == 0 { return a; } let shift = (a | b).trailing_zeros(); a >>= a.trailing_zeros(); loop { b >>= b.trailing_zeros(); if a > b { let tmp = a; a = b; b = tmp; } b -= a; if b == 0 { return a << shift; } } } |
| #1699 SOLE CROWN #1 <10 CYC | div3_u8_fast domain: math | id: b59df4df140dAye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Deterministic Sovereign Compute Kernel Pure-Rust C64-bounded integer transformation kernel verified across 64 canonical test vectors for deterministic Snap-Circuit composition. Specialized Multi-Pin Stage `(u8)->u8` — wire matching input pins via `snap_dag` or `snap_pipeline`. | (u8)->u864-vec BLAKE3: da459452d99bC64 RAM: 37/32768 (74 B src) | 1/1 cyc/op 3595999/400000 ns/op | 400000000/3595999 ops/us 14 B .text (4 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (74 B)pub const fn div3_u8_fast(v: u8) -> u8 { (((v as u16) * 171) >> 9) as u8 } |
| #1719 CROWN #1 of 2 | gcd_binary_u32 domain: math | id: 70fd398d5cecAye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 2-to-1 Binary Combiner / Join Stage `(u32,u32)->u32` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (u32,u32)->u3264-vec BLAKE3: eb3e1ec8f830C64 RAM: 457/32768 (914 B src) | 29457667/200000 cyc/op 9206271/200000 ns/op | 200000000/9206271 ops/us 75 B .text (27 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (914 B)/// Binary (Stein's) GCD for `u32`: subtraction and shifts, no division.
///
/// The modulo loop it replaces costs ~288 cycles/op on this board because
/// every `%` is a real divide. Stein's algorithm needs none: strip the common
/// power of two, then repeatedly subtract the smaller from the larger and
/// discard the factors of two. Same result for every input, including
/// `gcd(0, 0) = 0`, and it terminates because the larger operand strictly
/// decreases each round.
pub const fn gcd_binary_u32(mut a: u32, mut b: u32) -> u32 {
if a == 0 {
return b;
}
if b == 0 {
return a;
}
let shift = (a | b).trailing_zeros();
a >>= a.trailing_zeros();
loop {
b >>= b.trailing_zeros();
if a > b {
let tmp = a;
a = b;
b = tmp;
}
b -= a;
if b == 0 {
return a << shift;
}
}
} |
| #1747 PEER of 312 | steward_mathematicalrobotics_isqrt_salience_step domain: MathematicalRobotics | id: 4f53034bb0cbAye: alexiai-tokyo-steward @ 432Hz | Marine Salience & Wave Telemetry Tracking period and amplitude stability across zero-crossing intervals to score signal salience in noisy real-time sensor and audio streams. 1-to-1 Unary Transform Stage `(u64)->u64` — snaps directly into linear pipelines or fan-out DAG branches. | (u64)->u6464-vec BLAKE3: 0aab703b121aC64 RAM: 21/4096 (336 B src) | 31137733/200000 cyc/op 5032499/100000 ns/op | 100000000/5032499 ops/us 126 B .text (34 insns) | Trit 0 (0) | Inspect Details & ASM →Quick Peek Rust (336 B)#[inline(always)]
pub fn steward_mathematicalrobotics_isqrt_salience_step(energy_q15: u64) -> u64 {
let mut x = energy_q15 | 1;
let mut y = (x + 1) >> 1;
let mut iter = 0u32;
while y < x && iter < 12 {
x = y;
y = (x + energy_q15 / x.max(1)) >> 1;
iter += 1;
}
(x.wrapping_mul(432)) >> 4
} |
| #2030 CROWN #1 of 2 | gcd_binary_i64 domain: math | id: bbf489200f39Aye: aye::Peter+Omni(0+1)::aarch64 @ 432Hz | Exact Integer Number Theory & Transcendentals Hardware-verified modular arithmetic, integer roots, and combinatorial invariants for exact rational math engines and cryptographic primitives. 2-to-1 Binary Combiner / Join Stage `(i64,i64)->i64` — ideal for merging two upstream DAG branches, dot products, or pairwise rank fusion. | (i64,i64)->i6464-vec BLAKE3: cdce9b8cd667C64 RAM: 1069/65536 (1069 B src) | 27215567/100000 cyc/op 1063207/12500 ns/op | 12500000/1063207 ops/us 201 B .text (53 insns) | Trit + (1) | Inspect Details & ASM →Quick Peek Rust (1069 B)/// Binary (Stein's) GCD for `i64`, same contract as the modulo loop it replaces.
///
/// `gcd_i64` at ~677 cycles/op pays for a real 64-bit divide on every round.
/// Stein's algorithm needs no divide at all: normalise the signs the same way
/// (`saturating_neg`, so `i64::MIN` becomes `i64::MAX`), strip the shared power
/// of two, then subtract and discard factors of two.
///
/// Edge cases preserved exactly: `gcd(0, 0) = 1`, `gcd(0, x) = x`,
/// `gcd(x, 0) = x`.
pub const fn gcd_binary_i64(a: i64, b: i64) -> i64 {
let mut a = if a < 0 { a.saturating_neg() } else { a };
let mut b = if b < 0 { b.saturating_neg() } else { b };
if a == 0 && b == 0 {
return 1;
}
if a == 0 {
return b;
}
if b == 0 {
return a;
}
let shift = (a | b).trailing_zeros();
a >>= a.trailing_zeros();
loop {
b >>= b.trailing_zeros();
if a > b {
let tmp = a;
a = b;
b = tmp;
}
b -= a;
if b == 0 {
return a << shift;
}
}
} |