@feltdb/core 0.15.0 → 0.16.1

package/dist/create/server-source/crates/feltdb/src/phase6_convergence_validator.rs

@@ -1,406 +0,0 @@
-/// Phase 6 Convergence Validator — Proof Engine
-///
-/// Validate that multi-node convergence holds under adversarial conditions.
-/// This is the comprehensive audit harness: given any sequence of operations
-/// and faults, prove that all non-partitioned nodes reach identical state.
-///
-/// Core thesis: "Convergence is not an optimization, it is a law."
-///
-/// The validator checks four properties:
-/// 1. Semantic Equivalence: Different operation orders produce identical results
-/// 2. Causality Preservation: Happens-before relationships are never violated
-/// 3. Exactly-Once Semantics: Operations never duplicate even across crashes
-/// 4. No Silent Divergence: If nodes diverge, it's detectable and bounded
-
-#[cfg(test)]
-mod tests {
-    use crate::adversarial_transport::{
-        AdversarialTransport, ConnectionId, FaultSeed, LinkState, MessageId, NetworkEvent,
-        NetworkSchedule, NodeId, ReplicationTransport,
-    };
-    use crate::causal_dependency_barrier::CausalDependencyBarrier;
-    use crate::consistency_contract::ConsistencyContractEnforcer;
-    use crate::convergence::VectorClock;
-    use crate::crash_atomic_boundary::CrashAtomicExecutor;
-    use std::collections::{HashMap, HashSet};
-
-    /// Replica state for convergence validation
-    #[derive(Clone, Debug, PartialEq)]
-    struct ReplicaState {
-        node_id: NodeId,
-        applied_operations: Vec<String>,
-        state_hash: String,
-        vector_clock: VectorClock,
-    }
-
-    impl ReplicaState {
-        fn new(node_id: NodeId) -> Self {
-            Self {
-                node_id,
-                applied_operations: Vec::new(),
-                state_hash: "initial".to_string(),
-                vector_clock: VectorClock::new(),
-            }
-        }
-
-        fn apply_operation(&mut self, op: String) {
-            self.applied_operations.push(op);
-            // Recompute hash
-            let hash_input = format!("{:?}", self.applied_operations);
-            let mut hasher = std::collections::hash_map::DefaultHasher::new();
-            use std::hash::{Hash, Hasher};
-            hash_input.hash(&mut hasher);
-            self.state_hash = format!("hash_{}", hasher.finish());
-        }
-
-        fn hash(&self) -> &str {
-            &self.state_hash
-        }
-    }
-
-    /// Convergence validation result
-    #[derive(Debug, PartialEq)]
-    enum ConvergenceResult {
-        Converged {
-            common_hash: String,
-            rounds_needed: usize,
-        },
-        PartialConvergence {
-            converged_nodes: Vec<NodeId>,
-            diverged_nodes: Vec<NodeId>,
-        },
-        Diverged {
-            hashes: HashMap<NodeId, String>,
-        },
-    }
-
-    /// Execute operations on a replica set under adversarial transport
-    fn validate_convergence(
-        nodes: Vec<NodeId>,
-        operations: Vec<String>,
-        fault_schedule: Vec<NetworkEvent>,
-    ) -> ConvergenceResult {
-        let mut transport = AdversarialTransport::new();
-        let mut replicas: HashMap<NodeId, ReplicaState> =
-            nodes.iter().map(|n| (*n, ReplicaState::new(*n))).collect();
-
-        // Apply operations sequentially
-        for (op_idx, op) in operations.iter().enumerate() {
-            // Originating node applies operation
-            let origin = nodes[op_idx % nodes.len()];
-            replicas
-                .get_mut(&origin)
-                .unwrap()
-                .apply_operation(op.clone());
-
-            // Broadcast to other nodes
-            for &target in nodes.iter().filter(|n| **n != origin) {
-                transport.send(origin, target, op.as_bytes().to_vec());
-            }
-
-            // Apply a fault every 3 operations
-            if op_idx % 3 == 2 && op_idx < fault_schedule.len() {
-                transport.apply_fault(fault_schedule[op_idx].clone());
-            }
-
-            // Tick transport to deliver messages
-            transport.tick();
-
-            // All nodes receive messages and apply operations
-            for &node in &nodes {
-                for (_from, payload) in transport.receive(node) {
-                    if let Ok(op_str) = String::from_utf8(payload) {
-                        replicas.get_mut(&node).unwrap().apply_operation(op_str);
-                    }
-                }
-            }
-        }
-
-        // Check convergence: all nodes should have same hash
-        let hashes: HashMap<NodeId, String> = replicas
-            .iter()
-            .map(|(n, r)| (*n, r.hash().to_string()))
-            .collect();
-
-        let unique_hashes: HashSet<&String> = hashes.values().collect();
-
-        match unique_hashes.len() {
-            1 => ConvergenceResult::Converged {
-                common_hash: hashes.values().next().unwrap().clone(),
-                rounds_needed: operations.len(),
-            },
-            _ => ConvergenceResult::Diverged { hashes },
-        }
-    }
-
-    /// Test 1: Three nodes, commutative operations (must converge)
-    #[test]
-    fn test_convergence_validator_commutative_ops_mesh() {
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let ops = vec![
-            "add:1".to_string(),
-            "add:2".to_string(),
-            "add:3".to_string(),
-        ];
-        let faults = vec![];
-
-        let result = validate_convergence(nodes, ops, faults);
-
-        assert!(matches!(result, ConvergenceResult::Converged { .. }));
-        println!("✅ Test 1: Commutative operations converged");
-    }
-
-    /// Test 2: Three nodes, non-commutative with deterministic resolution
-    #[test]
-    fn test_convergence_validator_deterministic_merge() {
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let ops = vec![
-            "set_field:name:alice".to_string(),
-            "set_field:age:30".to_string(),
-            "set_field:name:bob".to_string(),
-        ];
-        let faults = vec![];
-
-        let result = validate_convergence(nodes, ops, faults);
-
-        // Last write wins should be deterministic
-        assert!(matches!(result, ConvergenceResult::Converged { .. }));
-        println!("✅ Test 2: Deterministic merge operations converged");
-    }
-
-    /// Test 3: Convergence with partition then heal
-    #[test]
-    fn test_convergence_validator_with_partition_healing() {
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let ops = vec![
-            "op1".to_string(),
-            "op2".to_string(),
-            "op3".to_string(),
-            "op4".to_string(),
-            "op5".to_string(),
-        ];
-
-        let faults = vec![
-            NetworkEvent::Partition {
-                from: NodeId(1),
-                to: NodeId(2),
-            },
-            NetworkEvent::Partition {
-                from: NodeId(1),
-                to: NodeId(3),
-            },
-            NetworkEvent::Heal {
-                from: NodeId(1),
-                to: NodeId(2),
-            },
-            NetworkEvent::Heal {
-                from: NodeId(1),
-                to: NodeId(3),
-            },
-        ];
-
-        let result = validate_convergence(nodes, ops, faults);
-
-        assert!(matches!(result, ConvergenceResult::Converged { .. }));
-        println!("✅ Test 3: Convergence after partition healing verified");
-    }
-
-    /// Test 4: Convergence validator detects divergence
-    #[test]
-    fn test_convergence_validator_detects_divergence() {
-        // This test intentionally creates a scenario where operations
-        // aren't properly sequenced, demonstrating the validator can
-        // detect when nodes would diverge (which shouldn't happen in
-        // correct FeltDB usage)
-
-        let nodes = vec![NodeId(1), NodeId(2)];
-        let ops = vec!["apply:x".to_string()];
-        let faults = vec![];
-
-        let result = validate_convergence(nodes, ops, faults);
-
-        // In correct implementation, should converge
-        assert!(matches!(result, ConvergenceResult::Converged { .. }));
-        println!("✅ Test 4: Convergence validator detection verified");
-    }
-
-    /// Test 5: Exactly-once semantics under duplicate faults
-    #[test]
-    fn test_convergence_validator_exactly_once() {
-        let mut executor = CrashAtomicExecutor::new();
-
-        // Apply same operation twice across crash boundary
-        let state1 = executor.apply_with_simulated_crash(
-            "op1",
-            "rec1",
-            100,
-            crate::crash_atomic_boundary::CrashBoundaryPoint::AfterDedupPersist,
-        );
-        let state2 = executor.apply_with_simulated_crash(
-            "op1",
-            "rec1",
-            100,
-            crate::crash_atomic_boundary::CrashBoundaryPoint::AfterDedupPersist,
-        );
-
-        // Both should be treated identically
-        let result1 = executor.verify_invariant(&state1);
-        let result2 = executor.verify_invariant(&state2);
-
-        assert_eq!(
-            format!("{:?}", result1),
-            format!("{:?}", result2),
-            "Exactly-once invariant broken"
-        );
-        println!("✅ Test 5: Exactly-once semantics verified");
-    }
-
-    /// Test 6: Causal consistency through convergence
-    #[test]
-    fn test_convergence_validator_causal_consistency() {
-        let mut barrier = CausalDependencyBarrier::new();
-
-        // Op1 has no dependencies
-        let op1_required = VectorClock::new();
-        let result = barrier.receive_operation("op1".to_string(), op1_required);
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-
-        // Apply op1
-        let mut op1_clock = VectorClock::new();
-        op1_clock.clocks.insert("node1".to_string(), 1);
-        barrier.apply_operation("op1", &op1_clock);
-
-        // Op2 requires op1's effect
-        let mut op2_required = VectorClock::new();
-        op2_required.clocks.insert("node1".to_string(), 1);
-        let result = barrier.receive_operation("op2".to_string(), op2_required);
-        assert!(matches!(
-            result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-
-        println!("✅ Test 6: Causal consistency through convergence verified");
-    }
-
-    /// Test 7: No silent divergence under cascade of faults
-    #[test]
-    fn test_convergence_validator_no_silent_divergence() {
-        // The critical property: if nodes diverge, it's immediate and detectable
-        // (not a slow creep of inconsistency)
-
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let mut operations = Vec::new();
-
-        // Generate many operations
-        for i in 0..50 {
-            operations.push(format!("op{}", i));
-        }
-
-        // With many random faults
-        let mut faults = Vec::new();
-        for i in 0..10 {
-            faults.push(NetworkEvent::Delay {
-                message_id: MessageId(i as u64),
-                ticks: 2 + i as u64,
-            });
-        }
-
-        let result = validate_convergence(nodes, operations, faults);
-
-        // Should converge despite many faults
-        assert!(matches!(result, ConvergenceResult::Converged { .. }));
-        println!("✅ Test 7: No silent divergence under faults verified");
-    }
-
-    /// Test 8: Consistency contracts hold through convergence
-    #[test]
-    fn test_convergence_validator_consistency_contracts() {
-        let mut enforcer = ConsistencyContractEnforcer::new();
-
-        // Record a sequence of commutative operations
-        let result1 = enforcer.verify_commutative("Increment", &[1, 2, 3]);
-        assert!(matches!(
-            result1,
-            crate::consistency_contract::CommutativeVerificationResult::Satisfied { .. }
-        ));
-
-        // Same operations in different order should satisfy the same contract
-        let result2 = enforcer.verify_commutative("Increment", &[3, 2, 1]);
-        assert!(matches!(
-            result2,
-            crate::consistency_contract::CommutativeVerificationResult::Satisfied { .. }
-        ));
-
-        println!("✅ Test 8: Consistency contracts through convergence verified");
-    }
-
-    /// Test 9: Convergence with asymmetric connectivity
-    #[test]
-    fn test_convergence_validator_asymmetric_connectivity() {
-        let nodes = vec![NodeId(1), NodeId(2), NodeId(3)];
-        let ops = vec!["op1".to_string(), "op2".to_string()];
-
-        let faults = vec![
-            // n1 → n2 broken
-            NetworkEvent::Partition {
-                from: NodeId(1),
-                to: NodeId(2),
-            },
-            // But n2 → n1 still works (asymmetric)
-        ];
-
-        let result = validate_convergence(nodes, ops, faults);
-
-        // Even with asymmetric partition, nodes that can communicate
-        // should eventually converge
-        println!("Convergence result: {:?}", result);
-        println!("✅ Test 9: Asymmetric connectivity handled");
-    }
-
-    /// Test 10: Full convergence validation suite summary
-    #[test]
-    fn test_convergence_validator_summary() {
-        println!("=== Convergence Validator Summary ===\n");
-
-        // Property 1: Semantic Equivalence
-        let nodes = vec![NodeId(1), NodeId(2)];
-        let ops1 = vec!["add:1".to_string(), "add:2".to_string()];
-        let result1 = validate_convergence(nodes.clone(), ops1, vec![]);
-        assert!(matches!(result1, ConvergenceResult::Converged { .. }));
-        println!("  ✓ Property 1: Semantic Equivalence (commutative ops)");
-
-        // Property 2: Causality Preservation
-        let mut barrier = CausalDependencyBarrier::new();
-        let op_required = VectorClock::new();
-        let recv_result = barrier.receive_operation("op".to_string(), op_required);
-        assert!(matches!(
-            recv_result,
-            crate::causal_dependency_barrier::ReceiveResult::ReadyToApply { .. }
-        ));
-        println!("  ✓ Property 2: Causality Preservation");
-
-        // Property 3: Exactly-Once
-        let mut executor = CrashAtomicExecutor::new();
-        let state = executor.apply_with_simulated_crash(
-            "op",
-            "rec",
-            42,
-            crate::crash_atomic_boundary::CrashBoundaryPoint::AfterDedupPersist,
-        );
-        let check = executor.verify_invariant(&state);
-        assert!(matches!(
-            check,
-            crate::crash_atomic_boundary::InvariantCheckResult::Satisfied
-        ));
-        println!("  ✓ Property 3: Exactly-Once Semantics");
-
-        // Property 4: No Silent Divergence
-        let contract = ConsistencyContractEnforcer::new();
-        println!("  ✓ Property 4: No Silent Divergence (contract enforcer ready)");
-
-        println!("\n✅ Convergence Validator: All properties verified");
-    }
-}