Enum InvariantViolation 

pub enum InvariantViolation {
    Convergence {
        agent_a: usize,
        agent_b: usize,
        only_in_a: Vec<u64>,
        only_in_b: Vec<u64>,
    },
    Commutativity {
        permutation_index: usize,
        missing_events: Vec<u64>,
        extra_events: Vec<u64>,
    },
    Idempotence {
        event_id: u64,
        events_before: Vec<u64>,
        events_after_dup: Vec<u64>,
    },
    CausalConsistency {
        observer_agent: usize,
        source_agent: usize,
        missing_seq: u64,
        present_higher_seq: u64,
    },
    TriageStability {
        agent_a: usize,
        agent_b: usize,
        score_a: f64,
        score_b: f64,
        diff: f64,
        epsilon: f64,
    },
}

Diagnostic information for a single failed invariant check.

Variants

Convergence

Two agents have different known_events after full delivery.

Emitted by check_convergence.

Fields

agent_a: usize

First diverging agent ID.

agent_b: usize

Second diverging agent ID.

only_in_a: Vec<u64>

Events present in agent_a but absent in agent_b.

only_in_b: Vec<u64>

Events present in agent_b but absent in agent_a.

Commutativity

Re-ordering event delivery produced a different final state.

Emitted by check_commutativity.

Fields

permutation_index: usize

Zero-based index of the shuffled permutation that diverged.

missing_events: Vec<u64>

Events present in the canonical state but missing from the shuffled result.

extra_events: Vec<u64>

Events present in the shuffled result but absent from the canonical state.

Idempotence

Re-applying an already-applied event mutated the state.

Emitted by check_idempotence.

Fields

event_id: u64

The event that was re-applied.

events_before: Vec<u64>

Known events before the duplicate application.

events_after_dup: Vec<u64>

Known events after the duplicate application (should equal events_before).

CausalConsistency

An agent knows event (source, seq=N) but is missing (source, seq=M) where M < N.

Emitted by check_causality.

Fields

observer_agent: usize

Agent that is missing the earlier event.

source_agent: usize

Agent that emitted both events.

missing_seq: u64

Sequence number that is absent but required by causality.

present_higher_seq: u64

A higher sequence number that is present, proving the gap.

TriageStability

Triage scores diverge beyond the allowed epsilon across replicas.

Emitted by check_triage_stability.

Fields

agent_a: usize

First agent involved in the comparison.

agent_b: usize

Second agent involved in the comparison.

score_a: f64

Score computed for agent_a.

score_b: f64

Score computed for agent_b.

diff: f64

Absolute difference |score_a - score_b|.

epsilon: f64

Maximum permitted difference.

Trait Implementations

impl Clone for InvariantViolation

fn clone(&self) -> InvariantViolation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InvariantViolation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for InvariantViolation

fn eq(&self, other: &InvariantViolation) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for InvariantViolation