Witnesses

type WitnessReport struct {
    Witness types.NodeID
    Target  types.NodeID
    Belief  types.Belief
    Trust   TrustScore
}

type TrustScore float64

const (
    // MaxTrust is full trust in a witness
    MaxTrust TrustScore = 1.0
    // MinTrust is minimum trust (but never zero - always some weight)
    MinTrust TrustScore = 0.1
    // DefaultTrust for new witnesses
    DefaultTrust TrustScore = 0.8
    // DecayRate per incorrect report
    DecayRate = 0.1
    // RecoveryRate per correct report
    RecoveryRate = 0.05
)

// RecordCorrect marks a witness report as correct
// Trust increases slightly
func (r *Registry) RecordCorrect(id types.NodeID) {
    w := r.getOrCreate(id)
    w.CorrectReports++
    w.Trust += TrustScore(RecoveryRate)
    if w.Trust > MaxTrust {
        w.Trust = MaxTrust
    }
}

// RecordWrong marks a witness report as wrong
// P12: Trust decays for bad witnesses
func (r *Registry) RecordWrong(id types.NodeID) {
    w := r.getOrCreate(id)
    w.WrongReports++
    w.Trust -= TrustScore(DecayRate)
    if w.Trust < MinTrust {
        w.Trust = MinTrust
    }
}

type WitnessRecord struct {
    ID             types.NodeID
    Trust          TrustScore
    CorrectReports int
    WrongReports   int
    LastReport     types.Belief
}

type Registry struct {
    mu        sync.RWMutex
    witnesses map[types.NodeID]*WitnessRecord
}

func (a *Aggregator) Aggregate(reports []WitnessReport) AggregateResult {
    // Calculate weighted average of beliefs
    var totalWeight float64
    var aliveSum, deadSum, unknownSum float64

    for _, r := range reports {
        trust := float64(a.registry.GetTrust(r.Witness))
        totalWeight += trust

        aliveSum += r.Belief.Alive().Value() * trust
        deadSum += r.Belief.Dead().Value() * trust
        unknownSum += r.Belief.Unknown().Value() * trust
    }

    avgAlive := aliveSum / totalWeight
    avgDead := deadSum / totalWeight
    avgUnknown := unknownSum / totalWeight

    // ... additional processing for disagreement and correlation
}

type AggregateResult struct {
    Belief       types.Belief
    Disagreement float64 // 0 = all agree, 1 = max disagreement
    WitnessCount int
    Reports      []WitnessReport
}

// calculateDisagreement measures variance in witness opinions
// P10: We track this, not hide it
func (a *Aggregator) calculateDisagreement(
    reports []WitnessReport,
    avgAlive, avgDead float64,
) float64 {
    if len(reports) < 2 {
        return 0
    }

    var variance float64
    for _, r := range reports {
        diffAlive := r.Belief.Alive().Value() - avgAlive
        diffDead := r.Belief.Dead().Value() - avgDead
        variance += diffAlive*diffAlive + diffDead*diffDead
    }
    variance /= float64(len(reports))

    // Normalize to [0,1]
    return math.Min(math.Sqrt(variance), 1.0)
}

// P10: High disagreement increases unknown
if disagreement > 0.3 {
    // Significant disagreement - widen uncertainty
    reduction := disagreement * 0.5
    avgAlive *= (1 - reduction)
    avgDead *= (1 - reduction)
    avgUnknown = 1.0 - avgAlive - avgDead
}

// detectCorrelation checks if witnesses are too similar
// P11: Correlated witnesses weaken confidence
func (a *Aggregator) detectCorrelation(reports []WitnessReport) float64 {
    if len(reports) < 2 {
        return 0
    }

    // Check how similar all reports are
    first := reports[0].Belief
    var totalDiff float64

    for i := 1; i < len(reports); i++ {
        b := reports[i].Belief
        diffAlive := math.Abs(first.Alive().Value() - b.Alive().Value())
        diffDead := math.Abs(first.Dead().Value() - b.Dead().Value())
        totalDiff += diffAlive + diffDead
    }

    avgDiff := totalDiff / float64(len(reports)-1)

    // Low difference = high correlation
    return 1.0 - math.Min(avgDiff*2, 1.0)
}

// P11: Correlated witnesses reduce confidence
// If witnesses are too similar, increase unknown
correlation := a.detectCorrelation(reports)
if correlation > 0.9 {
    // Too correlated - reduce confidence
    factor := 0.7
    avgAlive *= factor
    avgDead *= factor
    avgUnknown = 1.0 - avgAlive - avgDead
}