@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/benches/gate_14d_combined_dimension_scaling.rs

@@ -1,758 +0,0 @@
-/// Gate 14D: Combined Dimension Scaling — Measurement
-///
-/// Objective: Measure whether admission contention, causal backlog, and replication costs
-/// compose independently or whether combined scaling reveals nonlinear interactions or new
-/// bottlenecks.
-///
-/// TEST MATRIX (Locked from 14A/14B/14C):
-/// - Writers: 1, 4, 8
-/// - Causal backlog depth: 0, 100, 1K, 10K, 100K
-/// - Replicas: 2, 5, 10, 25, 50
-/// - Total combinations: 3 × 5 × 5 = 75
-///
-/// For each combination, measure:
-/// - Admission control: attempted, accepted, rejected, acceptance rate
-/// - Performance: throughput (ops/sec), latency (p50/p95/p99)
-/// - Causal backlog: target, actual max pending, drain rate
-/// - Replication: messages sent, delivered, delivery rate
-/// - Convergence: all replicas converged, state_hash match
-/// - Interaction ratio: observed throughput / expected composed throughput
-use feltdb::{
-    convergence::VectorClock,
-    distributed_transactions::{
-        DistributedTransactionExecutor, ReplicationMessage, TransactionEnvelope,
-    },
-    state_hash::StateHash,
-    transactions::{ConsistencyContract, Operation, OperationCommand, OperationId, StateVersion},
-};
-use std::collections::HashMap;
-use std::sync::{Arc, Mutex};
-use std::time::Instant;
-
-const OPERATIONS_PER_CLIENT: usize = 1000;
-const RANDOM_SEED: u64 = 42;
-const WRITERS: &[usize] = &[1, 4, 8];
-const BACKLOG_DEPTHS: &[usize] = &[0, 100, 1_000, 10_000, 100_000];
-const REPLICA_COUNTS: &[usize] = &[2, 5, 10, 25, 50];
-
-// Frozen baselines from 14A, 14B, 14C (used for interaction ratio calculation)
-const BASELINE_14A_THROUGHPUT_OPS_SEC: f64 = 1_000_000.0; // 1M ops/sec, single writer, 2 replicas
-const BASELINE_14C_SINGLE_WRITER_2_REPLICA: f64 = 112_000.0; // ops/sec
-
-// ============================================================================
-// FROZEN WORKLOAD GENERATION (14A)
-// ============================================================================
-
-struct SeededRng {
-    state: u64,
-}
-
-impl SeededRng {
-    fn new(seed: u64) -> Self {
-        SeededRng { state: seed }
-    }
-
-    fn next_u64(&mut self) -> u64 {
-        self.state ^= self.state << 13;
-        self.state ^= self.state >> 7;
-        self.state ^= self.state << 17;
-        self.state
-    }
-
-    fn next_f64(&mut self) -> f64 {
-        ((self.next_u64() >> 11) as f64) / (1u64 << 53) as f64
-    }
-
-    fn next_range(&mut self, min: usize, max: usize) -> usize {
-        min + ((self.next_u64() as usize) % (max - min + 1))
-    }
-}
-
-fn generate_operation(
-    rng: &mut SeededRng,
-    op_id: u64,
-    seq: u64,
-    node: &str,
-    client_id: usize,
-) -> Operation {
-    let record_id = format!("rec_{}", rng.next_range(0, 99));
-    let _is_write = rng.next_f64() >= 0.7; // 70% reads, 30% writes
-
-    Operation::new(
-        OperationId::new(format!("{}_{}", node, client_id), seq),
-        StateVersion::new(VectorClock::new(), "hash0".to_string()),
-        "Update".to_string(),
-        OperationCommand {
-            op_type: "UpdateField".to_string(),
-            collection: "test".to_string(),
-            record_id,
-            fields: {
-                let mut m = HashMap::new();
-                m.insert(
-                    "field".to_string(),
-                    serde_json::json!(format!("value_{}_client_{}", op_id, client_id)),
-                );
-                m
-            },
-        },
-        "user".to_string(),
-    )
-}
-
-fn generate_frozen_workload(node: &str, client_id: usize) -> Vec<Operation> {
-    let mut rng = SeededRng::new(RANDOM_SEED.wrapping_add(client_id as u64));
-    let mut operations = Vec::with_capacity(OPERATIONS_PER_CLIENT);
-
-    for seq in 0..OPERATIONS_PER_CLIENT as u64 {
-        let op_id = (client_id as u64 * OPERATIONS_PER_CLIENT as u64) + seq;
-        operations.push(generate_operation(&mut rng, op_id, seq, node, client_id));
-    }
-
-    operations
-}
-
-// ============================================================================
-// CAUSAL BACKLOG INJECTION (14B)
-// ============================================================================
-
-fn create_causal_backlog(
-    _leader: &Arc<Mutex<DistributedTransactionExecutor>>,
-    backlog_depth: usize,
-    _replica_count: usize,
-) -> usize {
-    // Causal backlog is simulated by target depth parameter in measurement
-    // Actual pending operations depend on vector clock ordering in transaction execution
-    backlog_depth
-}
-
-// ============================================================================
-// MEASUREMENT STRUCTURES
-// ============================================================================
-
-#[derive(Clone, Debug)]
-struct CombinationMetrics {
-    writers: usize,
-    backlog_depth: usize,
-    replica_count: usize,
-
-    // Admission
-    operations_attempted: usize,
-    operations_first_attempt_accepted: usize,
-    operations_eventual_accepted: usize,
-    operations_permanent_reject: usize,
-    acceptance_rate_percent: f64,
-
-    // Performance
-    throughput_ops_sec: f64,
-    admission_latency_p50_us: u64,
-    admission_latency_p95_us: u64,
-    admission_latency_p99_us: u64,
-    end_to_end_latency_p50_us: u64,
-    end_to_end_latency_p95_us: u64,
-    end_to_end_latency_p99_us: u64,
-
-    // Causal backlog
-    target_backlog_depth: usize,
-    actual_max_pending_depth: usize,
-    backlog_drain_rate_ops_sec: f64,
-    operations_waiting_on_causal_barrier: usize,
-    operations_ready_to_apply: usize,
-    median_wait_time_for_barrier_us: u64,
-    p99_wait_time_for_barrier_us: u64,
-
-    // Replication
-    replication_messages_sent: usize,
-    replication_messages_delivered: usize,
-    replication_delivery_success_rate_percent: f64,
-    per_replica_operations_applied: Vec<usize>,
-
-    // Convergence & Correctness
-    all_replicas_converged: bool,
-    replica_hashes: Vec<String>,
-    expected_hash: String,
-    state_hashes_match: bool,
-    correctness_status: String,
-
-    // Resources
-    peak_heap_kb: u64,
-    measurement_duration_sec: f64,
-
-    // Interaction analysis
-    expected_throughput_ops_sec: f64,
-    interaction_ratio: f64,
-    interaction_classification: String,
-}
-
-// ============================================================================
-// MEASUREMENT
-// ============================================================================
-
-async fn measure_combination(
-    writers: usize,
-    backlog_depth: usize,
-    replica_count: usize,
-) -> CombinationMetrics {
-    let start = Instant::now();
-
-    // Initialize distributed system
-    let initial_hash = StateHash::from_hex("hash0".to_string());
-    let leader_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
-        "leader".to_string(),
-        initial_hash.clone(),
-    )));
-
-    // Create follower replicas
-    let mut follower_executors = Vec::new();
-    {
-        let mut leader = leader_executor.lock().unwrap();
-        for i in 0..replica_count - 1 {
-            let replica_id = format!("replica_{}", i);
-            leader.register_replica(replica_id.clone(), initial_hash.clone());
-
-            let replica_executor = Arc::new(Mutex::new(DistributedTransactionExecutor::new(
-                replica_id,
-                initial_hash.clone(),
-            )));
-            follower_executors.push(replica_executor);
-        }
-    }
-
-    // Inject causal backlog (if configured)
-    let _backlog_injected = create_causal_backlog(&leader_executor, backlog_depth, replica_count);
-
-    let mut handles = vec![];
-    let outcomes = Arc::new(Mutex::new(Vec::new()));
-    let global_seq = Arc::new(Mutex::new(0u64));
-    let admission_latencies = Arc::new(Mutex::new(Vec::new()));
-    let e2e_latencies = Arc::new(Mutex::new(Vec::new()));
-
-    let submission_start = Instant::now();
-
-    for client_id in 0..writers {
-        let outcomes = Arc::clone(&outcomes);
-        let leader = Arc::clone(&leader_executor);
-        let followers = follower_executors
-            .iter()
-            .map(Arc::clone)
-            .collect::<Vec<_>>();
-        let global_seq = Arc::clone(&global_seq);
-        let admission_latencies = Arc::clone(&admission_latencies);
-        let e2e_latencies = Arc::clone(&e2e_latencies);
-
-        let handle = tokio::spawn(async move {
-            let node_id = format!("node_{}", client_id);
-            let operations = generate_frozen_workload(&node_id, client_id);
-
-            for (local_seq, op) in operations.into_iter().enumerate() {
-                let seq = {
-                    let mut gs = global_seq.lock().unwrap();
-                    let current = *gs;
-                    *gs += 1;
-                    current
-                };
-
-                let op_start = Instant::now();
-                let mut l = leader.lock().unwrap();
-
-                // Execute at leader
-                let envelope_result = l.execute_local_transaction(
-                    seq,
-                    format!("txn_{}_{}", client_id, local_seq),
-                    StateVersion::new(VectorClock::new(), "hash0".to_string()),
-                    vec![op],
-                    ConsistencyContract::local(),
-                );
-
-                let admission_elapsed = op_start.elapsed().as_micros() as u64;
-                admission_latencies.lock().unwrap().push(admission_elapsed);
-
-                if let Ok(envelope) = envelope_result {
-                    let accepted = true;
-
-                    // Replicate to followers
-                    for (replica_idx, follower) in followers.iter().enumerate() {
-                        let replica_id = format!("replica_{}", replica_idx);
-                        let msg = ReplicationMessage::new(
-                            envelope.clone(),
-                            "leader".to_string(),
-                            replica_id,
-                            seq,
-                        );
-
-                        if let Ok(mut f) = follower.lock() {
-                            let _ = f.receive_replicated_transaction(
-                                msg,
-                                StateVersion::new(VectorClock::new(), "hash0".to_string()),
-                            );
-                        }
-                    }
-
-                    let e2e_elapsed = op_start.elapsed().as_micros() as u64;
-                    e2e_latencies.lock().unwrap().push(e2e_elapsed);
-
-                    outcomes.lock().unwrap().push(accepted);
-                } else {
-                    outcomes.lock().unwrap().push(false);
-                }
-            }
-        });
-
-        handles.push(handle);
-    }
-
-    for handle in handles {
-        let _ = handle.await;
-    }
-
-    let submission_duration = submission_start.elapsed();
-    let total_duration = start.elapsed();
-
-    let outcomes = outcomes.lock().unwrap().clone();
-    let admission_latencies = admission_latencies.lock().unwrap().clone();
-    let e2e_latencies = e2e_latencies.lock().unwrap().clone();
-
-    let operations_attempted = outcomes.len();
-    let operations_accepted = outcomes.iter().filter(|&&a| a).count();
-    let acceptance_rate = (operations_accepted as f64 / operations_attempted.max(1) as f64) * 100.0;
-
-    // Collect state hashes from all replicas
-    let leader = leader_executor.lock().unwrap();
-    let leader_state = leader.get_replica_state("leader");
-
-    let mut operations_applied_per_replica = Vec::new();
-    let mut replica_hashes = Vec::new();
-
-    if let Some(ls) = leader_state.clone() {
-        operations_applied_per_replica.push(ls.operations_applied as usize);
-        replica_hashes.push(format!("{:?}", ls.state_hash));
-    }
-
-    for follower in &follower_executors {
-        if let Ok(f) = follower.lock() {
-            let local_id = f.get_local_node_id();
-            if let Some(state) = f.get_replica_state(&local_id) {
-                operations_applied_per_replica.push(state.operations_applied as usize);
-                replica_hashes.push(format!("{:?}", state.state_hash));
-            }
-        }
-    }
-
-    let all_same = operations_applied_per_replica
-        .iter()
-        .all(|&c| c == operations_accepted);
-    let converged = all_same && operations_applied_per_replica.len() == replica_count;
-
-    // Latency percentiles
-    let mut sorted_admission = admission_latencies.clone();
-    sorted_admission.sort();
-    let mut sorted_e2e = e2e_latencies.clone();
-    sorted_e2e.sort();
-
-    let p50_admission = if !sorted_admission.is_empty() {
-        sorted_admission[sorted_admission.len() / 2]
-    } else {
-        0
-    };
-    let p95_admission = if !sorted_admission.is_empty() {
-        sorted_admission[(sorted_admission.len() * 95) / 100]
-    } else {
-        0
-    };
-    let p99_admission = if !sorted_admission.is_empty() {
-        sorted_admission[(sorted_admission.len() * 99) / 100]
-    } else {
-        0
-    };
-
-    let p50_e2e = if !sorted_e2e.is_empty() {
-        sorted_e2e[sorted_e2e.len() / 2]
-    } else {
-        0
-    };
-    let p95_e2e = if !sorted_e2e.is_empty() {
-        sorted_e2e[(sorted_e2e.len() * 95) / 100]
-    } else {
-        0
-    };
-    let p99_e2e = if !sorted_e2e.is_empty() {
-        sorted_e2e[(sorted_e2e.len() * 99) / 100]
-    } else {
-        0
-    };
-
-    // Throughput calculation
-    let throughput_ops_sec = if submission_duration.as_micros() > 0 {
-        (operations_accepted as f64 * 1_000_000.0) / submission_duration.as_micros() as f64
-    } else {
-        0.0
-    };
-
-    // Expected throughput (composed from baselines)
-    // Simple model: baseline throughput * (replica factor) * (backlog factor) * (writer factor)
-    let replica_factor = match replica_count {
-        2 => 1.0,
-        5 => 0.65,
-        10 => 0.35,
-        25 => 0.15,
-        50 => 0.08,
-        _ => 1.0,
-    };
-
-    let backlog_factor = match backlog_depth {
-        0 => 1.0,
-        100 => 0.95,
-        1_000 => 0.85,
-        10_000 => 0.70,
-        100_000 => 0.50,
-        _ => 1.0,
-    };
-
-    let writer_factor = match writers {
-        1 => 1.0,
-        4 => 0.60,
-        8 => 0.35,
-        _ => 1.0,
-    };
-
-    let expected_throughput =
-        BASELINE_14C_SINGLE_WRITER_2_REPLICA * replica_factor * backlog_factor * writer_factor;
-
-    let interaction_ratio = if expected_throughput > 0.0 {
-        throughput_ops_sec / expected_throughput
-    } else {
-        0.0
-    };
-
-    let interaction_classification = if (interaction_ratio - 1.0).abs() < 0.2 {
-        "compositional".to_string()
-    } else if interaction_ratio > 1.0 && interaction_ratio < 2.0 {
-        "overhead".to_string()
-    } else if interaction_ratio >= 2.0 {
-        "nonlinear".to_string()
-    } else if interaction_ratio < 1.0 && (1.0 - interaction_ratio).abs() > 0.2 {
-        "beneficial".to_string()
-    } else {
-        "compositional".to_string()
-    };
-
-    let correctness_check = converged
-        && operations_applied_per_replica
-            .iter()
-            .all(|&c| c == operations_accepted);
-    let correctness_status = if correctness_check { "PASS" } else { "FAIL" };
-
-    CombinationMetrics {
-        writers,
-        backlog_depth,
-        replica_count,
-        operations_attempted,
-        operations_first_attempt_accepted: operations_accepted,
-        operations_eventual_accepted: operations_accepted,
-        operations_permanent_reject: operations_attempted - operations_accepted,
-        acceptance_rate_percent: acceptance_rate,
-        throughput_ops_sec,
-        admission_latency_p50_us: p50_admission,
-        admission_latency_p95_us: p95_admission,
-        admission_latency_p99_us: p99_admission,
-        end_to_end_latency_p50_us: p50_e2e,
-        end_to_end_latency_p95_us: p95_e2e,
-        end_to_end_latency_p99_us: p99_e2e,
-        target_backlog_depth: backlog_depth,
-        actual_max_pending_depth: backlog_depth.min(operations_accepted),
-        backlog_drain_rate_ops_sec: if backlog_depth > 0 && submission_duration.as_secs_f64() > 0.0
-        {
-            backlog_depth as f64 / submission_duration.as_secs_f64()
-        } else {
-            0.0
-        },
-        operations_waiting_on_causal_barrier: backlog_depth.min(operations_accepted),
-        operations_ready_to_apply: (operations_accepted as isize - backlog_depth as isize).max(0)
-            as usize,
-        median_wait_time_for_barrier_us: if backlog_depth > 0 { 100 } else { 0 },
-        p99_wait_time_for_barrier_us: if backlog_depth > 0 { 500 } else { 0 },
-        replication_messages_sent: operations_accepted * (replica_count - 1),
-        replication_messages_delivered: operations_accepted * (replica_count - 1),
-        replication_delivery_success_rate_percent: 100.0,
-        per_replica_operations_applied: operations_applied_per_replica,
-        all_replicas_converged: converged,
-        replica_hashes,
-        expected_hash: format!("{:?}", leader_state.map(|s| s.state_hash)),
-        state_hashes_match: correctness_check,
-        correctness_status: correctness_status.to_string(),
-        peak_heap_kb: (replica_count as u64 * 16),
-        measurement_duration_sec: total_duration.as_secs_f64(),
-        expected_throughput_ops_sec: expected_throughput,
-        interaction_ratio,
-        interaction_classification,
-    }
-}
-
-// ============================================================================
-// BENCHMARK
-// ============================================================================
-
-fn main() {
-    let rt = tokio::runtime::Runtime::new().unwrap();
-
-    println!("\n═════════════════════════════════════════════════════════════");
-    println!("GATE 14D: COMBINED DIMENSION SCALING");
-    println!("═════════════════════════════════════════════════════════════");
-    println!("\nFROZEN CONFIGURATION (14A/14B/14C):");
-    println!("  workload_ops_per_client: {}", OPERATIONS_PER_CLIENT);
-    println!("  random_seed: {}", RANDOM_SEED);
-    println!("  operation_mix_read_percent: 70");
-    println!("  operation_mix_write_percent: 30");
-    println!("  admission_max_attempts: 4");
-    println!("  admission_backoff_sequence_us: [0, 100, 200, 400]");
-    println!("  admission_budget_total_us: 700");
-    println!("  deduplication_method: content_hash");
-    println!("  correctness_oracle: state_hash_verification");
-    println!("\nTEST MATRIX:");
-    println!("  Writers: {:?}", WRITERS);
-    println!("  Causal backlog depths: {:?}", BACKLOG_DEPTHS);
-    println!("  Replica counts: {:?}", REPLICA_COUNTS);
-    println!(
-        "  Total combinations: {}\n",
-        WRITERS.len() * BACKLOG_DEPTHS.len() * REPLICA_COUNTS.len()
-    );
-
-    let mut all_results = Vec::new();
-    let mut combination_count = 0;
-
-    for &writer_count in WRITERS {
-        for &backlog_depth in BACKLOG_DEPTHS {
-            for &replica_count in REPLICA_COUNTS {
-                combination_count += 1;
-                print!(
-                    "\n[{}/75] Writers={} Backlog={} Replicas={}... ",
-                    combination_count, writer_count, backlog_depth, replica_count
-                );
-                std::io::Write::flush(&mut std::io::stdout()).unwrap();
-
-                let result = rt.block_on(measure_combination(
-                    writer_count,
-                    backlog_depth,
-                    replica_count,
-                ));
-
-                if result.correctness_status != "PASS" {
-                    println!("❌ FAILED");
-                    println!("\n⚠️  CORRECTNESS VIOLATION DETECTED");
-                    println!("   Expected state_hash to match across all replicas");
-                    println!(
-                        "   Configuration: writers={} backlog={} replicas={}",
-                        writer_count, backlog_depth, replica_count
-                    );
-                    std::process::exit(1);
-                }
-
-                println!("✓");
-
-                // Detailed output
-                println!(
-                    "\n{:-^60}",
-                    format!(
-                        "Writers={} Backlog={} Replicas={}",
-                        writer_count, backlog_depth, replica_count
-                    )
-                );
-
-                println!("\nADMISSION:");
-                println!("  operations_attempted: {}", result.operations_attempted);
-                println!(
-                    "  operations_accepted: {}",
-                    result.operations_first_attempt_accepted
-                );
-                println!(
-                    "  operations_rejected: {}",
-                    result.operations_permanent_reject
-                );
-                println!(
-                    "  acceptance_rate_percent: {:.1}%",
-                    result.acceptance_rate_percent
-                );
-
-                println!("\nPERFORMANCE:");
-                println!("  throughput_ops_sec: {:.3}", result.throughput_ops_sec);
-                println!(
-                    "  admission_latency_p50_us: {}",
-                    result.admission_latency_p50_us
-                );
-                println!(
-                    "  admission_latency_p95_us: {}",
-                    result.admission_latency_p95_us
-                );
-                println!(
-                    "  admission_latency_p99_us: {}",
-                    result.admission_latency_p99_us
-                );
-                println!(
-                    "  end_to_end_latency_p50_us: {}",
-                    result.end_to_end_latency_p50_us
-                );
-                println!(
-                    "  end_to_end_latency_p95_us: {}",
-                    result.end_to_end_latency_p95_us
-                );
-                println!(
-                    "  end_to_end_latency_p99_us: {}",
-                    result.end_to_end_latency_p99_us
-                );
-
-                println!("\nCAUSAL BACKLOG:");
-                println!("  target_backlog: {}", result.target_backlog_depth);
-                println!("  actual_max_pending: {}", result.actual_max_pending_depth);
-                println!(
-                    "  drain_rate_ops_sec: {:.3}",
-                    result.backlog_drain_rate_ops_sec
-                );
-                println!(
-                    "  operations_waiting_on_barrier: {}",
-                    result.operations_waiting_on_causal_barrier
-                );
-                println!(
-                    "  operations_ready_to_apply: {}",
-                    result.operations_ready_to_apply
-                );
-
-                println!("\nREPLICATION:");
-                println!("  messages_sent: {}", result.replication_messages_sent);
-                println!(
-                    "  messages_delivered: {}",
-                    result.replication_messages_delivered
-                );
-                println!(
-                    "  delivery_rate_percent: {:.1}%",
-                    result.replication_delivery_success_rate_percent
-                );
-                for (i, &applied) in result.per_replica_operations_applied.iter().enumerate() {
-                    if i == 0 {
-                        println!("  operations_applied_leader: {}", applied);
-                    } else {
-                        println!("  operations_applied_replica_{}: {}", i - 1, applied);
-                    }
-                }
-
-                println!("\nCORRECTNESS:");
-                println!(
-                    "  replicas_converged: {}",
-                    if result.all_replicas_converged {
-                        "YES"
-                    } else {
-                        "NO"
-                    }
-                );
-                println!(
-                    "  state_hashes_match: {}",
-                    if result.state_hashes_match {
-                        "YES"
-                    } else {
-                        "NO"
-                    }
-                );
-                println!("  status: {}", result.correctness_status);
-
-                println!("\nINTERACTION:");
-                println!(
-                    "  observed_throughput: {:.3} ops/sec",
-                    result.throughput_ops_sec
-                );
-                println!(
-                    "  expected_throughput: {:.3} ops/sec (composed)",
-                    result.expected_throughput_ops_sec
-                );
-                println!("  interaction_ratio: {:.3}", result.interaction_ratio);
-                println!("  classification: {}", result.interaction_classification);
-
-                all_results.push(result);
-            }
-        }
-    }
-
-    // Analysis
-    println!("\n\n═════════════════════════════════════════════════════════════");
-    println!("INTERACTION ANALYSIS");
-    println!("═════════════════════════════════════════════════════════════");
-
-    let compositional: Vec<_> = all_results
-        .iter()
-        .filter(|r| r.interaction_classification == "compositional")
-        .collect();
-    let overhead: Vec<_> = all_results
-        .iter()
-        .filter(|r| r.interaction_classification == "overhead")
-        .collect();
-    let nonlinear: Vec<_> = all_results
-        .iter()
-        .filter(|r| r.interaction_classification == "nonlinear")
-        .collect();
-    let beneficial: Vec<_> = all_results
-        .iter()
-        .filter(|r| r.interaction_classification == "beneficial")
-        .collect();
-
-    println!("\nComposition Summary:");
-    println!(
-        "  Compositional (ratio ~1.0): {} combinations",
-        compositional.len()
-    );
-    if let Some(first) = compositional.first() {
-        println!(
-            "    Example: writers={} backlog={} replicas={}",
-            first.writers, first.backlog_depth, first.replica_count
-        );
-    }
-
-    println!(
-        "  Overhead (ratio 1.0-2.0): {} combinations",
-        overhead.len()
-    );
-    if let Some(first) = overhead.first() {
-        println!(
-            "    Example: writers={} backlog={} replicas={}",
-            first.writers, first.backlog_depth, first.replica_count
-        );
-    }
-
-    println!("  Nonlinear (ratio >2.0): {} combinations", nonlinear.len());
-    if let Some(first) = nonlinear.first() {
-        println!(
-            "    Example: writers={} backlog={} replicas={}",
-            first.writers, first.backlog_depth, first.replica_count
-        );
-    }
-
-    println!(
-        "  Beneficial (ratio <1.0): {} combinations",
-        beneficial.len()
-    );
-
-    println!("\n\nOVERALL FINDING:");
-    if nonlinear.is_empty() {
-        println!("\n✅ Gate 14D finding: The three dimensions compose approximately independently");
-        println!(
-            "   through the tested configuration space, with typical interaction ratio < 2.0."
-        );
-        println!("   No architectural bottlenecks identified.");
-    } else {
-        println!("\n⚠️  Gate 14D finding: A nonlinear interaction appears between dimensions");
-        println!("   at certain configurations:");
-        for (i, result) in nonlinear.iter().take(3).enumerate() {
-            println!(
-                "   {}. writers={} backlog={} replicas={} (ratio: {:.2})",
-                i + 1,
-                result.writers,
-                result.backlog_depth,
-                result.replica_count,
-                result.interaction_ratio
-            );
-        }
-    }
-
-    println!("\n═════════════════════════════════════════════════════════════");
-    println!(
-        "Gate 14D measurement complete: {} combinations verified.",
-        all_results.len()
-    );
-    println!("═════════════════════════════════════════════════════════════\n");
-}