use g_math::fixed_point::imperative::FixedVector;
use crate::FixedPoint;
use crate::core::manifold::geodesic_distance;
use crate::{ToponError, GeometricHash, ManifoldType};
pub struct EvalResult {
pub approach_name: String,
pub min_pairwise_distance: FixedPoint,
pub mean_pairwise_distance: FixedPoint,
pub min_avalanche_distance: FixedPoint,
pub mean_avalanche_distance: FixedPoint,
pub component_variances: Vec<FixedPoint>,
pub mean_variance: FixedPoint,
pub variance_of_variances: FixedPoint,
pub max_abs_correlation: FixedPoint,
pub effective_dimensionality: FixedPoint,
pub determinism_verified: bool,
}
pub fn evaluate_hasher(
hasher: &dyn GeometricHash,
test_domains: &[&str],
) -> Result<EvalResult, ToponError> {
let n = test_domains.len();
let manifold = hasher.manifold_type();
let hashes: Vec<FixedVector<FixedPoint>> = test_domains
.iter()
.map(|d| hasher.hash(d.as_bytes()))
.collect::<Result<_, _>>()?;
let output_dim = hasher.output_dimension();
let n_fp = FixedPoint::from_int(n as i32);
let mut determinism_verified = true;
for d in test_domains {
let h1 = hasher.hash(d.as_bytes())?;
let h2 = hasher.hash(d.as_bytes())?;
if !vectors_equal(&h1, &h2) {
determinism_verified = false;
break;
}
}
let (min_dist, mean_dist) = pairwise_distances(&hashes, manifold)?;
let (min_avalanche, mean_avalanche) = avalanche_distances(hasher, test_domains, manifold)?;
let (means, variances) = component_statistics(&hashes, output_dim, n_fp);
let mean_var = mean_of(&variances);
let var_of_var = variance_of(&variances, mean_var);
let max_corr = max_abs_correlation(&hashes, &means, &variances, output_dim);
let eff_dim = participation_ratio(&variances);
Ok(EvalResult {
approach_name: hasher.name().to_string(),
min_pairwise_distance: min_dist,
mean_pairwise_distance: mean_dist,
min_avalanche_distance: min_avalanche,
mean_avalanche_distance: mean_avalanche,
component_variances: variances,
mean_variance: mean_var,
variance_of_variances: var_of_var,
max_abs_correlation: max_corr,
effective_dimensionality: eff_dim,
determinism_verified,
})
}
fn vectors_equal(a: &FixedVector<FixedPoint>, b: &FixedVector<FixedPoint>) -> bool {
if a.len() != b.len() {
return false;
}
for i in 0..a.len() {
if a[i] != b[i] {
return false;
}
}
true
}
fn pairwise_distances(
hashes: &[FixedVector<FixedPoint>],
manifold: ManifoldType,
) -> Result<(FixedPoint, FixedPoint), ToponError> {
let n = hashes.len();
let mut min_dist: Option<FixedPoint> = None;
let mut sum_dist = FixedPoint::ZERO;
let mut count = 0i32;
for i in 0..n {
for j in (i + 1)..n {
let d = geodesic_distance(&hashes[i], &hashes[j], manifold)?;
if min_dist.is_none_or(|m| d < m) {
min_dist = Some(d);
}
sum_dist += d;
count += 1;
}
}
let mean_dist = if count > 0 {
sum_dist / FixedPoint::from_int(count)
} else {
FixedPoint::ZERO
};
Ok((min_dist.unwrap_or(FixedPoint::ZERO), mean_dist))
}
fn avalanche_distances(
hasher: &dyn GeometricHash,
test_domains: &[&str],
manifold: ManifoldType,
) -> Result<(FixedPoint, FixedPoint), ToponError> {
let mut min_dist: Option<FixedPoint> = None;
let mut sum_dist = FixedPoint::ZERO;
let mut count = 0i32;
for domain in test_domains {
let bytes = domain.as_bytes();
if bytes.is_empty() {
continue;
}
let original = hasher.hash(bytes)?;
let mut positions = vec![0, bytes.len() / 2, bytes.len() - 1];
positions.dedup();
for pos in positions {
let mut mutated = bytes.to_vec();
mutated[pos] ^= 0x01; let perturbed = hasher.hash(&mutated)?;
let d = geodesic_distance(&original, &perturbed, manifold)?;
if min_dist.is_none_or(|m| d < m) {
min_dist = Some(d);
}
sum_dist += d;
count += 1;
}
}
let mean_dist = if count > 0 {
sum_dist / FixedPoint::from_int(count)
} else {
FixedPoint::ZERO
};
Ok((min_dist.unwrap_or(FixedPoint::ZERO), mean_dist))
}
fn component_statistics(
hashes: &[FixedVector<FixedPoint>],
output_dim: usize,
n_fp: FixedPoint,
) -> (Vec<FixedPoint>, Vec<FixedPoint>) {
let mut means = vec![FixedPoint::ZERO; output_dim];
let mut variances = vec![FixedPoint::ZERO; output_dim];
for d in 0..output_dim {
let mut sum = FixedPoint::ZERO;
for h in hashes {
sum += h[d];
}
means[d] = sum / n_fp;
}
for d in 0..output_dim {
let mut sum_sq = FixedPoint::ZERO;
for h in hashes {
let diff = h[d] - means[d];
sum_sq += diff * diff;
}
variances[d] = sum_sq / n_fp;
}
(means, variances)
}
fn mean_of(values: &[FixedPoint]) -> FixedPoint {
if values.is_empty() {
return FixedPoint::ZERO;
}
let mut sum = FixedPoint::ZERO;
for v in values {
sum += *v;
}
sum / FixedPoint::from_int(values.len() as i32)
}
fn variance_of(values: &[FixedPoint], mean: FixedPoint) -> FixedPoint {
if values.is_empty() {
return FixedPoint::ZERO;
}
let mut sum_sq = FixedPoint::ZERO;
for v in values {
let diff = *v - mean;
sum_sq += diff * diff;
}
sum_sq / FixedPoint::from_int(values.len() as i32)
}
fn max_abs_correlation(
hashes: &[FixedVector<FixedPoint>],
means: &[FixedPoint],
variances: &[FixedPoint],
output_dim: usize,
) -> FixedPoint {
let n_fp = FixedPoint::from_int(hashes.len() as i32);
let mut max_corr = FixedPoint::ZERO;
let max_pairs = 200usize;
let mut pairs_checked = 0usize;
for d1 in 0..output_dim {
if pairs_checked >= max_pairs {
break;
}
let std_d1 = variances[d1].sqrt();
if std_d1.is_zero() {
continue;
}
for d2 in (d1 + 1)..output_dim {
if pairs_checked >= max_pairs {
break;
}
let std_d2 = variances[d2].sqrt();
if std_d2.is_zero() {
continue;
}
let mut cov = FixedPoint::ZERO;
for h in hashes {
cov += (h[d1] - means[d1]) * (h[d2] - means[d2]);
}
cov /= n_fp;
let corr = cov / (std_d1 * std_d2);
let abs_corr = corr.abs();
if abs_corr > max_corr {
max_corr = abs_corr;
}
pairs_checked += 1;
}
}
max_corr
}
fn participation_ratio(variances: &[FixedPoint]) -> FixedPoint {
let mut sum_lambda = FixedPoint::ZERO;
let mut sum_lambda_sq = FixedPoint::ZERO;
for &v in variances {
sum_lambda += v;
sum_lambda_sq += v * v;
}
if sum_lambda_sq.is_zero() {
return FixedPoint::ZERO;
}
(sum_lambda * sum_lambda) / sum_lambda_sq
}
fn frac_bits() -> u32 {
if cfg!(table_format = "q16_16") { 16 }
else if cfg!(table_format = "q32_32") { 32 }
else if cfg!(table_format = "q64_64") { 64 }
else if cfg!(table_format = "q128_128") { 128 }
else if cfg!(table_format = "q256_256") { 256 }
else { 64 } }
fn profile_name() -> &'static str {
if cfg!(table_format = "q16_16") { "Q16.16 (realtime)" }
else if cfg!(table_format = "q32_32") { "Q32.32 (compact)" }
else if cfg!(table_format = "q64_64") { "Q64.64 (embedded)" }
else if cfg!(table_format = "q128_128") { "Q128.128 (balanced)" }
else if cfg!(table_format = "q256_256") { "Q256.256 (scientific)" }
else { "unknown" }
}
pub struct CollisionAnalysis {
pub frac_bits: u32,
pub intrinsic_dim: u32,
pub log2_positions: f64,
pub log2_birthday_bound: f64,
pub max_input_bytes: u32,
pub log2_possible_inputs: f64,
pub population_probs: Vec<(u64, f64)>,
}
pub fn collision_analysis(
intrinsic_dim: u32,
_manifold: crate::ManifoldType,
max_input_bytes: u32,
) -> CollisionAnalysis {
let k = frac_bits();
let log2_positions = (k as f64) * (intrinsic_dim as f64);
let log2_birthday = log2_positions / 2.0 + 0.3257;
let log2_inputs_practical = (max_input_bytes as f64) * (38.0_f64).log2();
let populations: Vec<u64> = vec![
1_000, 1_000_000, 1_000_000_000, 350_000_000_000, ];
let population_probs: Vec<(u64, f64)> = populations
.iter()
.map(|&m| {
let log2_m = (m as f64).log2();
let log2_exponent = 2.0 * log2_m - 1.0 - log2_positions;
let prob = if log2_exponent > 0.0 {
1.0
} else if log2_exponent < -53.0 {
0.0
} else {
let exponent = 2.0_f64.powf(log2_exponent);
1.0 - (-exponent).exp()
};
(m, prob)
})
.collect();
CollisionAnalysis {
frac_bits: k,
intrinsic_dim,
log2_positions,
log2_birthday_bound: log2_birthday,
max_input_bytes,
log2_possible_inputs: log2_inputs_practical,
population_probs,
}
}
pub fn print_collision_analysis(
dim: u32,
manifold: crate::ManifoldType,
max_input_bytes: u32,
) {
let ca = collision_analysis(dim, manifold, max_input_bytes);
let manifold_name = match manifold {
crate::ManifoldType::Sphere => format!("S^{}", dim),
crate::ManifoldType::Euclidean => format!("R^{}", dim),
crate::ManifoldType::Hyperbolic => format!("H^{}", dim),
};
println!("Collision Probability Analysis");
println!("==============================");
println!();
println!(" Profile: {}", profile_name());
println!(" Fractional bits: {} bits per component", ca.frac_bits);
println!(" Manifold: {}", manifold_name);
println!(" Intrinsic dim: {}", ca.intrinsic_dim);
println!(" Max input: {} bytes (DNS limit: 253)", ca.max_input_bytes);
println!();
println!(" Distinguishable positions: 2^{:.0}", ca.log2_positions);
println!(" Birthday bound (50%): 2^{:.1} ({:.1e} domains)",
ca.log2_birthday_bound,
2.0_f64.powf(ca.log2_birthday_bound.min(1023.0)), );
println!(" Possible inputs (practical): 2^{:.0} (alphabet ~38)", ca.log2_possible_inputs);
println!();
println!(" Population | P(collision) | Safety margin (bits)");
println!(" ------------------+--------------------+---------------------");
for &(m, prob) in &ca.population_probs {
let log2_m = (m as f64).log2();
let margin = ca.log2_birthday_bound - log2_m;
let prob_str = if prob == 0.0 {
let log2_prob = 2.0 * log2_m - 1.0 - ca.log2_positions;
format!("< 2^{:.0} (≈0)", log2_prob)
} else if prob >= 0.999 {
"≈ 1.0 (certain)".to_string()
} else {
format!("{:.2e}", prob)
};
println!(" {:>16} | {:<18} | {:.0}",
format_population(m), prob_str, margin);
}
println!();
if ca.log2_positions > ca.log2_possible_inputs {
println!(" --> Output space (2^{:.0}) EXCEEDS input space (2^{:.0}).",
ca.log2_positions, ca.log2_possible_inputs);
println!(" Collisions are limited by hash quality, not space size.");
} else {
println!(" --> Input space (2^{:.0}) exceeds output space (2^{:.0}).",
ca.log2_possible_inputs, ca.log2_positions);
println!(" Pigeonhole: collisions guaranteed for >2^{:.0} inputs.",
ca.log2_positions);
}
println!();
println!(" Dimension scaling (birthday bound for 50% collision):");
println!(" -------------------------------------------------------");
for &d in &[8, 16, 32, 64, 128, 256, 512] {
let log2_pos = (ca.frac_bits as f64) * (d as f64);
let log2_bb = log2_pos / 2.0 + 0.3257;
let feasible = format!("2^{:.0}", log2_pos);
let birthday = format!("2^{:.0}", log2_bb);
println!(" dim {:>4}: positions = {:<12} birthday bound = {}", d, feasible, birthday);
}
println!();
}
fn format_population(m: u64) -> String {
if m >= 1_000_000_000_000 {
format!("{:.0}T", m as f64 / 1e12)
} else if m >= 1_000_000_000 {
format!("{:.0}B", m as f64 / 1e9)
} else if m >= 1_000_000 {
format!("{:.0}M", m as f64 / 1e6)
} else if m >= 1_000 {
format!("{:.0}K", m as f64 / 1e3)
} else {
format!("{}", m)
}
}
pub fn print_comparison(results: &[EvalResult]) {
println!("╔══════════════════════════════════╦══════════════╦══════════════╦══════════════╦══════════════╦══════════════╦══════════════╦══════════════╦═══════╗");
println!("║ Approach ║ Min Dist ║ Mean Dist ║ Aval Min ║ Aval Mean ║ Mean Var ║ Max |Corr| ║ Eff Dim ║ Det? ║");
println!("╠══════════════════════════════════╬══════════════╬══════════════╬══════════════╬══════════════╬══════════════╬══════════════╬══════════════╬═══════╣");
for r in results {
println!(
"║ {:<32} ║ {:>12} ║ {:>12} ║ {:>12} ║ {:>12} ║ {:>12} ║ {:>12} ║ {:>12} ║ {:<5} ║",
r.approach_name,
format_fp(r.min_pairwise_distance),
format_fp(r.mean_pairwise_distance),
format_fp(r.min_avalanche_distance),
format_fp(r.mean_avalanche_distance),
format_fp(r.mean_variance),
format_fp(r.max_abs_correlation),
format_fp(r.effective_dimensionality),
if r.determinism_verified { "yes" } else { "NO" },
);
}
println!("╚══════════════════════════════════╩══════════════╩══════════════╩══════════════╩══════════════╩══════════════╩══════════════╩══════════════╩═══════╝");
println!();
println!("Legend (all distances geodesic on the output manifold):");
println!(" Min Dist — minimum pairwise distance (higher = better collision resistance)");
println!(" Mean Dist — mean pairwise distance");
println!(" Aval Min — minimum distance under a single-bit input flip");
println!(" (should be the same order as Mean Dist; ~0 = broken diffusion)");
println!(" Aval Mean — mean distance under single-bit input flips");
println!(" Mean Var — mean per-component variance (higher = better spread)");
println!(" Max |Corr|— worst inter-dimension Pearson correlation (lower = more independent)");
println!(" Eff Dim — participation ratio (closer to output_dim = better)");
println!(" Det? — determinism check passed");
}
fn format_fp(v: FixedPoint) -> String {
format!("{:.6}", v.to_f64())
}