Partition Detection

type PartitionState int

const (
    // NoPartition detected
    NoPartition PartitionState = iota
    // SuspectedPartition based on evidence
    SuspectedPartition
    // ConfirmedPartition with split realities
    ConfirmedPartition
)

type WitnessGroup struct {
    Witnesses []types.NodeID
    // What this group believes about targets
    Beliefs map[types.NodeID]types.Belief
}

type SplitReality struct {
    Groups       []WitnessGroup
    Disagreement float64
    Ambiguous    []types.NodeID // nodes with conflicting status
}

const disagreementThreshold = 0.4

func (d *Detector) Analyze(
    reports []witness.WitnessReport,
    target types.NodeID,
) (PartitionState, *SplitReality) {
    if len(reports) < 2 {
        return NoPartition, nil
    }

    // Check for disagreement patterns
    aliveVotes := 0
    deadVotes := 0
    unknownVotes := 0

    for _, r := range reports {
        switch r.Belief.Dominant() {
        case types.StateAlive:
            aliveVotes++
        case types.StateDead:
            deadVotes++
        case types.StateUnknown:
            unknownVotes++
        }
    }

    total := len(reports)

    // If witnesses strongly disagree, suspect partition
    if aliveVotes > 0 && deadVotes > 0 {
        disagreement := float64(min(aliveVotes, deadVotes)) / float64(total)

        if disagreement > d.disagreementThreshold {
            // Confirmed split - some see alive, some see dead
            return ConfirmedPartition, createSplitReality(reports, target)
        }

        // Some disagreement but not extreme
        return SuspectedPartition, nil
    }

    // High unknown votes also suggest partition
    if float64(unknownVotes)/float64(total) > 0.5 {
        return SuspectedPartition, nil
    }

    return NoPartition, nil
}

split := &SplitReality{
    Disagreement: disagreement,
    Ambiguous:    []types.NodeID{target},
}

// Create groups
aliveGroup := WitnessGroup{
    Witnesses: make([]types.NodeID, 0),
    Beliefs:   make(map[types.NodeID]types.Belief),
}
deadGroup := WitnessGroup{
    Witnesses: make([]types.NodeID, 0),
    Beliefs:   make(map[types.NodeID]types.Belief),
}

for _, r := range reports {
    if r.Belief.Dominant() == types.StateAlive {
        aliveGroup.Witnesses = append(aliveGroup.Witnesses, r.Witness)
        aliveGroup.Beliefs[target] = r.Belief
    } else if r.Belief.Dominant() == types.StateDead {
        deadGroup.Witnesses = append(deadGroup.Witnesses, r.Witness)
        deadGroup.Beliefs[target] = r.Belief
    }
}

split.Groups = []WitnessGroup{aliveGroup, deadGroup}

// Check partition state
pState, split := o.partition.Analyze(reports, target)
result.PartitionState = pState

if pState == partition.ConfirmedPartition {
    result.Refused = true
    result.RefusalReason = "network partition detected - witnesses disagree"
    result.Belief = types.UnknownBelief()
    if split != nil {
        result.Disagreement = split.Disagreement
    }
    result.Evidence = append(result.Evidence, "partition: witnesses split into groups")
    return result
}

// ShouldRefuseAnswer returns true if partition makes answering dishonest
// STYX refuses to guess during partitions
func (d *Detector) ShouldRefuseAnswer() bool {
    d.mu.RLock()
    defer d.mu.RUnlock()
    return d.state == ConfirmedPartition
}

// Check disagreement isn't too high
disagreement := calculateDisagreement(witnessReports)
if disagreement > MaxDisagreement {  // 0.2 (20%)
    return ErrInsufficientEvidence
}