Evidence Relations in the Claude-Obsidian Claim Ledger: The Three Valid Types

The claude-obsidian claim ledger recognizes exactly three evidence relations—supports, contradicts, and context—which are enforced by the EVIDENCE_RELATIONS constant in claude_obsidian/ledgers.py to maintain semantic integrity across knowledge base entries.

The AgriciDaniel/claude-obsidian repository implements a structured claim ledger system that tracks how sources interact with claims through predefined evidence relations. These relations determine whether a source backs, refutes, or merely clarifies a claim, ensuring consistent semantic linking across your Obsidian vault. Understanding these evidence relations is essential for building valid claim ledgers that pass the built-in validation logic.

The Three Evidence Relations Defined

The claude-obsidian claim ledger restricts evidence entries to three specific string literals. Each relation carries distinct semantic weight that affects how the knowledge base interprets the relationship between a claim and its supporting sources.

supports

The supports relation indicates that a source provides positive evidence backing the claim. When a source is marked with this relation, the system interprets it as direct confirmation or corroboration of the claim's validity. Use this relation when the cited source explicitly confirms or provides evidence for the statement in question.

contradicts

The contradicts relation signifies that a source offers evidence opposing or refuting the claim. This creates an explicit conflict marker within the ledger, flagging that the claim is contested by the cited source. Sources with this relation are essential for tracking controversial or disputed claims within your knowledge base.

context

The context relation identifies sources that supply contextual information helping to interpret the claim without directly supporting or refuting it. This relation is valuable for background material, definitions, or related information that aids understanding but does not constitute evidence for or against the claim's truth value.

Where Evidence Relations Are Defined in the Source Code

According to the claude-obsidian source code, the allowed evidence relations are formally defined as a constant tuple in claude_obsidian/ledgers.py at line 49:

EVIDENCE_RELATIONS = ("supports", "contradicts", "context")

This constant serves as the single source of truth for valid relation types. During claim-ledger validation, the system checks each evidence entry's relation field against this tuple to ensure data integrity. The validation logic resides at line 1073 in the same file, where the validate_claim_ledger function verifies that every relation value matches one of these three sanctioned strings.

How to Use Evidence Relations in Practice

When constructing claim ledgers programmatically, you must use one of the three valid relations in the evidence array for each claim entry.

Creating a Claim with Evidence

The following Python dictionary demonstrates the correct structure for defining evidence relations when building a claim ledger:

claim = {
    "schema": "claude-obsidian.claim-ledger.v1",
    "generated_at": "2024-10-01T12:00:00Z",
    "claims": {
        "clm-abc123": {
            "text": "Quantum entanglement enables faster-than-light communication.",
            "risk": "high",
            "assessment": "contested",
            "confidence": "medium",
            "location": {"path": "wiki/quantum_entanglement.md"},
            "reviewed_at": "2024-10-02",
            "evidence": [
                {
                    "source_id": "src-001",
                    "relation": "supports",
                    "locator": None
                },
                {
                    "source_id": "src-002",
                    "relation": "contradicts",
                    "locator": None
                },
                {
                    "source_id": "src-003",
                    "relation": "context",
                    "locator": None
                }
            ],
            "notes": "Further experimental validation required."
        }
    }
}

Validating a Claim Ledger

To ensure your evidence relations conform to the schema requirements, use the validation function from claude_obsidian/ledgers:

from claude_obsidian.ledgers import validate_claim_ledger, empty_source_ledger
from datetime import date
from pathlib import Path

source_ledger = empty_source_ledger()
errors = validate_claim_ledger(
    claim_ledger=claim,
    source_ledger=source_ledger,
    as_of=date.today(),
    vault_root=Path("/path/to/vault")
)

if errors:
    print("Validation errors:", errors)
else:
    print("Claim ledger is valid.")

If any evidence entry contains a relation not in EVIDENCE_RELATIONS, the validate_claim_ledger function will return a validation error specifying the invalid relation value.

Related Components

Several modules work together to enforce evidence relation constraints:

• claude_obsidian/ledgers.py: Contains the EVIDENCE_RELATIONS constant and the validate_claim_ledger function that enforces evidence relation constraints during validation (lines 49 and 1073).

• claude_obsidian/transaction.py: Manages the overall ledger transaction schema, ensuring that claim and source ledgers are bundled correctly before validation occurs.

• tests/test_ledgers.py: Provides unit tests that exercise claim-ledger validation, including specific test cases for correct evidence relation handling and error reporting for invalid relation types.

Summary

• The claude-obsidian claim ledger accepts exactly three evidence relations: supports, contradicts, and context.
• Valid relations are defined in the EVIDENCE_RELATIONS constant within claude_obsidian/ledgers.py (line 49).
• The validate_claim_ledger function enforces these relations during validation (line 1073), rejecting any claim containing undefined relation types.
• The supports relation indicates corroborating evidence, contradicts marks opposing evidence, and context provides neutral background information.
• Related validation logic and testing reside in transaction.py and test_ledgers.py respectively.

Frequently Asked Questions

What are the three evidence relations in claude-obsidian?

The three evidence relations are supports, contradicts, and context. The supports relation indicates positive evidence backing a claim, contradicts marks evidence that opposes the claim, and context provides neutral background information that aids interpretation without confirming or denying the claim.

How does the claim ledger validate evidence relations?

The claim ledger validates evidence relations through the validate_claim_ledger function in claude_obsidian/ledgers.py. This function checks each evidence entry's relation field against the EVIDENCE_RELATIONS tuple (defined at line 49). If a relation value does not match one of the three allowed strings, the validator returns an error indicating the invalid relation.

Can I add custom evidence relations to the claim ledger?

No, the claude-obsidian claim ledger does not support custom evidence relations. The system strictly enforces the three predefined relations (supports, contradicts, context) through the validation logic at line 1073 of claude_obsidian/ledgers.py. Attempting to use undefined relation strings will cause validation failures when processing claim ledgers.

What is the difference between contradicts and context relations?

The contradicts relation indicates that a source provides evidence actively opposing or refuting the claim, marking it as contested within the knowledge base. The context relation, conversely, indicates that a source provides background or interpretive information that helps understand the claim without taking a position on its validity. Context sources neither support nor challenge the claim's truth value.

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