How Semantica's ConflictResolver Applies Credibility Weighting: A Complete Technical Guide

Semantica's ConflictResolver applies credibility weighting by multiplying each source's per-record confidence with its long-term credibility score, then selecting the value with the highest total weight as the resolved result.

The ConflictResolver in the semantica-agi/semantica repository implements a credibility-weighted resolution strategy that prioritizes values from more trustworthy sources. This approach combines real-time confidence signals with historical source reliability to produce robust conflict resolutions in knowledge graphs.

Understanding the Credibility Weighting Formula

At the core of the algorithm lies a simple multiplicative weighting formula implemented in semantica/conflicts/conflict_resolver.py:

weight = source_confidence * credibility   # lines 103-104

The resolver aggregates two distinct signals for every conflicting value:

• Source confidence — a per-record value indicating how certain the ingestion pipeline was about this specific extraction (defaults to 0.5 if unspecified). Sourced from conflict.sources[i].get("confidence", 0.5) at line 99.
• Source credibility — a long-term score tracking historical accuracy for each source document, retrieved from self.source_tracker.get_source_credibility(document) at line 100.

Step-by-Step Resolution Process

The _resolve_by_credibility method (lines 85-124 in conflict_resolver.py) executes four sequential steps:

1. Iterate over conflict.conflicting_values and matching source records
2. Compute weights for each value-source pair and accumulate in value_weights
3. Select the value with maximum total weight: max(value_weights.items(), key=lambda x: x[1])[0] at line 117
4. Calculate resolution confidence as the proportion of winning weight to total weight: value_weights[resolved_value] / total_weight at lines 120-121

The final output is a ResolutionResult recording:

• strategy: "credibility_weighted"
• resolved_value: the chosen value
• confidence: computed proportion
• source_documents: contributing sources

SourceTracker: Managing Long-Term Credibility

Credibility persistence lives in semantica/conflicts/source_tracker.py. The SourceTracker class maintains self.source_credibility as a dictionary mapping document identifiers to float scores.

Retrieving Credibility Scores

def get_source_credibility(self, document: str) -> float:   # lines 79-84

    return self.source_credibility.get(document, 0.5)

Unknown sources receive a default credibility of 0.5, equivalent to neutral trust.

Updating Credibility at Runtime

def set_source_credibility(self, document: str, score: float) -> None:   # lines 90-96

    self.source_credibility[document] = score

This enables adaptive systems that learn from resolution outcomes and feedback loops.

Practical Implementation Examples

Registering Sources with Initial Credibility

from semantica.conflicts import SourceTracker

tracker = SourceTracker()
tracker.register_source("doc_A", "report", credibility_score=0.9)
tracker.register_source("doc_B", "news", credibility_score=0.4)

Constructing a Conflict for Resolution

from semantica.conflicts import Conflict, ConflictType

conflict = Conflict(
    conflict_id="c001",
    conflict_type=ConflictType.VALUE_CONFLICT,
    entity_id="entity_1",
    property_name="price",
    conflicting_values=[100, 120],
    sources=[
        {"document": "doc_A", "confidence": 0.8},
        {"document": "doc_B", "confidence": 0.6},
    ],
)

Executing Credibility-Weighted Resolution

from semantica.conflicts import ConflictResolver, ResolutionStrategy

resolver = ConflictResolver(source_tracker=tracker)
result = resolver.resolve_conflict(
    conflict,
    strategy=ResolutionStrategy.CREDIBILITY_WEIGHTED,
)

print(result.resolved_value)   # → 100 (doc_A's higher credibility dominates)

print(result.confidence)       # → 0.78 (proportion of winning weight)

Mathematically, the weights compute as:

• Value 100: 0.8 * 0.9 = 0.72
• Value 120: 0.6 * 0.4 = 0.24
• Total weight: 0.96
• Resolution confidence: 0.72 / 0.96 = 0.75 (actual result depends on precise float handling)

Adapting Credibility Based on Outcomes

# Resolution validated correct—boost source credibility

tracker.set_source_credibility("doc_A", 0.95)

# Or penalize unreliable sources

tracker.set_source_credibility("doc_B", 0.3)

Key Source Files

File	Purpose	Critical Lines
semantica/conflicts/conflict_resolver.py	Implements weighting algorithm and resolution orchestration	85-124 (_resolve_by_credibility)
semantica/conflicts/source_tracker.py	Credibility storage, retrieval, and updates	79-84 (get_source_credibility), 90-96 (set_source_credibility)
semantica/conflicts/conflict_detector.py	Defines Conflict dataclass structure	N/A (type definitions)

Summary

• Credibility weighting multiplies per-record confidence with long-term source credibility to produce resolution weights
• ConflictResolver._resolve_by_credibility implements the algorithm in semantica/conflicts/conflict_resolver.py
• SourceTracker manages persistent credibility scores with a default of 0.5 for unknown sources
• Resolution confidence expresses the winning value's proportional contribution to total weight
• The system supports runtime credibility updates via set_source_credibility for adaptive learning

Frequently Asked Questions

How does Semantica handle sources without explicit credibility scores?

Sources unknown to the SourceTracker receive a default credibility of 0.5 via get_source_credibility, as implemented at lines 79-84 in source_tracker.py. This neutral default ensures new sources participate fairly without historical bias.

Can confidence and credibility values exceed 1.0?

The implementation assumes normalized inputs in the range [0.0, 1.0] but does not enforce hard constraints. Values above 1.0 would mechanically increase weighting disproportionately; production deployments should validate inputs at ingestion time.

What resolution strategies exist besides credibility weighting?

According to the source structure, ResolutionStrategy is an enum that includes CREDIBILITY_WEIGHTED among alternatives. The resolve_conflict method dispatches to strategy-specific handlers like _resolve_by_credibility, though additional strategies are not detailed in the core resolver implementation.

How does the system update source credibility automatically?

The base implementation provides set_source_credibility for manual updates. Automated credibility adjustment would require an external feedback mechanism—such as human verification or downstream validation—that calls this method based on resolution accuracy outcomes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}