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

> Discover the three valid evidence relations supports contradicts and context in the Claude-Obsidian claim ledger. Learn how they ensure semantic integrity.

- Repository: [Agrici.Daniel/claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian)
- Tags: deep-dive
- Published: 2026-08-26

---

**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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/claude_obsidian/ledgers.py)** at line 49:

```python
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:

```python
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`:

```python
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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/transaction.py) and [`test_ledgers.py`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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`](https://github.com/AgriciDaniel/claude-obsidian/blob/main/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.