Skill: schchit/determinability-checker (version 1.0.2)

--- name: determinability-checker version: 1.0.2 description: Causal Sufficiency Determinability Checker — Meta-Skill Gatekeeper based on JEP Paper CheckDeterminability Algorithm author: Cognitive Emergence Lab <[REDACTED_SECRET]> license: MIT protocol: COE tags: - jep - causality - audit - determinability - gatekeeper - meta-skill entrypoint: skill.api:app host_targets: - mcp - api - python skills: - name: check_determinability description: Determine whether a target fact is zero-error determinable from current evidence; return DETERMINED/NOT_DETERMINED with missing-evidence guidance input_schema: type: object properties: session_id: type: string description: Unique session identifier question: type: string description: The judgment question to evaluate configs: type: array description: Finite configuration family; each item must contain config_id items: type: object omega_field: type: string description: Observation value field name; corresponds to observation function Omega in the paper target_field: type: string description: Target value field name; corresponds to target function D in the paper evidence_fields: type: array items: type: string description: Optional constrained evidence field list for gap analysis required: - session_id - question - configs - omega_field - target_field output_schema: type: object properties: session_id: type: string question: type: string determinability: type: string enum: - DETERMINED - NOT_DETERMINED can_proceed: type: boolean description: Whether the Agent should execute the target action immediately decision_table: type: object description: Observation-to-target mapping returned when DETERMINED counterexample: type: object description: Indistinguishable counterexample pair returned when NOT_DETERMINED missing_evidence: type: array items: type: string description: Evidence fields needed to resolve non-determinability next_skill_suggestion: type: string description: Recommended next skill or evidence type to call when NOT_DETERMINED message: type: string --- # Determinability Checker **Causal Sufficiency Determinability Checker** Algorithm implementation based on the paper *Target Determinability under Partial Causal Observation* (Wang, 2026). ## Core Question Before an Agent calls other skills, it asks itself: > "Based on current evidence, am I sufficient to make this judgment?" ## Determinability Results | Result | Meaning | Agent Action | |--------|---------|------------| | **DETERMINED** | Evidence is sufficient; target is zero-error determinable | Execute immediately; no wasted tokens | | **NOT_DETERMINED** | Evidence is insufficient; indistinguishable counterexample exists | Return missing-evidence list; guide next skill to call | ## Theoretical Foundation - **Theorem 10.1** (Finite Model Checking): The algorithm returns Determined if and only if the target is zero-error determinable; returns NotDetermined with a counterexample pair certificate. - **Theorem 8.2** (Constrained Evidence Coverage): An evidence subset covers all conflict edges if and only if the target becomes determinable from the joint observation. - **Quotient Factorization** (Lemma 7.1): D is determinable from Omega if and only if D is constant on every observation equivalence class, if and only if D = g composed with Omega. ## Usage Example ### Request ```json { "session_id": "audit-001", "question": "Does the final output have a valid verification event?", "configs": [ {"config_id": "C1", "tool": "code", "has_verif": true, "verif_hash": "valid", "output": "correct", "target": 1}, {"config_id": "C2", "tool": "code", "has_verif": false, "verif_hash": "none", "output": "correct", "target": 0} ], "omega_field": "output", "target_field": "target", "evidence_fields": ["tool", "has_verif", "verif_hash"] } ``` ### Response ```json { "session_id": "audit-001", "question": "Does the final output have a valid verification event?", "determinability": "NOT_DETERMINED", "can_proceed": false, "counterexample": { "config1": "C1", "config2": "C2", "observation": "correct", "target1": 1, "target2": 0 }, "missing_evidence": ["tool", "has_verif", "verif_hash"], "next_skill_suggestion": "Supplement the following evidence items: tool, has_verif, verif_hash", "message": "Non-determinability proven: configs C1 and C2 share observation correct but differ on target (1 vs 0)." } ``` --- Cognitive Emergence Lab [REDACTED_SECRET]

path: determinability-checker-skill/CHANGELOG.md
content: # Changelog

All notable changes to the Determinability-Checker Skill will be documented in this file.

## [1.0.2] - 2026-04-26

### Added
- Initial stable release of the Determinability-Checker Skill.
- Implemented `CheckDeterminability` algorithm (Theorem 10.1) from *Target Determinability under Partial Causal Observation* (Wang, 2026).
- Core engine supporting zero-error determinability verification with decision table output.
- Counterexample certificate generation for non-determinability proofs.
- Conflict graph construction and analysis.
- Minimal evidence cover computation via greedy set-cover approximation (Theorem 8.2).
- FastAPI HTTP interface (`/check`, `/health`) compatible with MCP Skill calling conventions.
- Full paper reproduction example (Section 10.2 LLM Agent Audit Case) in `examples/audit_example.py`.
- Unit tests covering determined, non-determined, and evidence-cover scenarios.
- Standard Clawhub `SKILL.md` manifest with YAML frontmatter and JSON schemas.

### Features
- **Gatekeeper Pattern**: Agent calls this skill before executing other skills to verify causal sufficiency.
- **DETERMINED** → returns decision table; Agent proceeds immediately.
- **NOT_DETERMINED** → returns counterexample pair, missing evidence list, and next-skill suggestion.
- Supports arbitrary configuration families, observation functions (`omega_field`), and target functions (`target_field`).
- Extensible evidence field system for constrained causal-evidence coverage analysis.

### References
- Wang, Y. (2026). *Target Determinability under Partial Causal Observation*. Cognitive Emergence Lab.
- Wang, Y. (2026). *JEP: Judgment Event Protocol*. IETF Internet-Draft.


path: determinability-checker-skill/manifest.json
content: {
  "name": "determinability-checker",
  "version": "1.0.2",
  "description": "Causal Sufficiency Determinability Checker — Meta-Skill Gatekeeper based on JEP Paper CheckDeterminability Algorithm",
  "author": "Cognitive Emergence Lab <[REDACTED_SECRET]>",
  "license": "MIT",
  "protocol": "COE",
  "entrypoint": "skill.api:app",
  "host_targets": [
    "mcp",
    "api",
    "python"
  ],
  "dependencies": [
    "fastapi>=0.104.0",
    "uvicorn>=0.24.0",
    "pydantic>=2.5.0"
  ],
  "tags": [
    "jep",
    "causality",
    "audit",
    "determinability",
    "gatekeeper",
    "meta-skill"
  ]
}

path: determinability-checker-skill/README.md
content: # Determinability-Checker Skill v1.0.2

**Causal Sufficiency Determinability Checker** — Algorithm implementation based on the paper *Target Determinability under Partial Causal Observation* (Wang, 2026).

> **Core Question:** Before an Agent calls other skills, it asks itself — "Based on current evidence, am I sufficient to make this judgment?"

---

## What It Does

| Return Value | Meaning | Agent Action |
|--------------|---------|------------|
| **DETERMINED** | Evidence is sufficient; target is zero-error determinable | Execute immediately; no wasted tokens |
| **NOT_DETERMINED** | Evidence is insufficient; indistinguishable counterexample exists | Return missing-evidence list; guide next skill to call |

## Core Capabilities

1. **CheckDeterminability** (Theorem 10.1) — Decide whether a target fact is zero-error determinable from current observation.
2. **Conflict Graph** — Output conflict graph to locate evidence gaps.
3. **Minimal Evidence Cover** (Theorem 8.2) — Compute minimum evidence cover set; guide which skill to call next to supplement evidence.
4. **Counterexample Certificate** — Provide verifiable counterexample pair when non-determinability is proven.

## Quick Start

```bash
pip install -r requirements.txt
uvicorn skill.api:app --host 0.0.0.0 --port 8000
```

## API Call

```bash
curl -X POST http://localhost:8000/check \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "audit-001",
    "question": "Does the final output have a valid verification event?",
    "configs": [
      {"config_id": "C1", "tool": "code", "has_verif": true, "verif_hash": "valid", "output": "correct", "target": 1},
      {"config_id": "C2", "tool": "code", "has_verif": false, "verif_hash": "none", "output": "correct", "target": 0},
      {"config_id": "C3", "tool": "calc", "has_verif": false, "verif_hash": "none", "output": "correct", "target": 0},
      {"config_id": "C4", "tool": "search", "has_verif": false, "verif_hash": "none", "output": "correct", "target": 0},
      {"config_id": "C5", "tool": "code", "has_verif": true, "verif_hash": "failed", "output": "error", "target": 0},
      {"config_id": "C6", "tool": "code", "has_verif": true, "verif_hash": "forged", "output": "correct", "target": 0},
      {"config_id": "C7", "tool": "search", "has_verif": false, "verif_hash": "none", "output": "error", "target": 0},
      {"config_id": "C8", "tool": "calc", "has_verif": false, "verif_hash": "none", "output": "error", "target": 0}
    ],
    "omega_field": "output",
    "target_field": "target",
    "evidence_fields": ["tool", "has_verif", "verif_hash"]
  }'
```

## Paper Reproduction

```bash
cd examples
python audit_example.py
```

Reproduces the LLM Agent audit case from Section 10.2 of the paper, verifying four levels of observation functions:
- Omega0 (output only) -> NOT_DETERMINED
- OmegaT (output + tool type) -> NOT_DETERMINED
- OmegaTV (output + tool + verification flag) -> NOT_DETERMINED
- OmegaTVH (output + tool + flag + hash) -> **DETERMINED**

---

Cognitive Emergence Lab  
Email: [REDACTED_SECRET]


path: determinability-checker-skill/requirements.txt
content: fastapi>=0.104.0
uvicorn>=0.24.0
pydantic>=2.5.0


path: determinability-checker-skill/tests/test_core.py
content: """
Core Algorithm Unit Tests
Run: pytest tests/test_core.py
"""
import sys
sys.path.insert(0, "..")

from skill.core import DeterminabilityCore
from skill.types import Config, DeterminabilityResult


def test_determined_case():
    """Simple determinable case."""
    configs = [
        Config("A", {"obs": "x", "target": 1}),
        Config("B", {"obs": "y", "target": 0}),
    ]
    result = DeterminabilityCore.check(
        configs,
        lambda C: C.data["obs"],
        lambda C: C.data["target"]
    )
    assert result.result == DeterminabilityResult.DETERMINED
    assert result.decision_table.mapping == {"x": 1, "y": 0}


def test_not_determined_case():
    """Non-determinable case: same observation, different targets."""
    configs = [
        Config("A", {"obs": "x", "target": 1}),
        Config("B", {"obs": "x", "target": 0}),
    ]
    result = DeterminabilityCore.check(
        configs,
        lambda C: C.data["obs"],
        lambda C: C.data["target"]
    )
    assert result.result == DeterminabilityResult.NOT_DETERMINED
    assert result.counterexample is not None
    assert result.counterexample.config1.config_id == "A"
    assert result.counterexample.config2.config_id == "B"


def test_evidence_cover():
    """Test evidence cover computation."""
    configs = [
        Config("C1", {"obs": "same", "tool": "code", "hash": "valid", "target": 1}),
        Config("C2", {"obs": "same", "tool": "code", "hash": "none", "target": 0}),
    ]
    evidences = [
        ("tool", lambda C: C.data["tool"]),
        ("hash", lambda C: C.data["hash"]),
    ]
    result = DeterminabilityCore.check(
        configs,
        lambda C: C.data["obs"],
        lambda C: C.data["target"],
        evidences
    )
    assert result.result == DeterminabilityResult.NOT_DETERMINED
    minimal = DeterminabilityCore.find_minimal_evidence_cover(result.conflict_graph, evidences)
    assert "hash" in minimal


if __name__ == "__main__":
    test_determined_case()
    test_not_determined_case()
    test_evidence_cover()
    print("All tests passed.")


path: determinability-checker-skill/skill/api.py
content: """
Determinability Checker Skill API
Exposed as FastAPI HTTP service, compatible with MCP Skill calling conventions.
"""
from typing import Any, Dict, List, Optional
from fastapi import FastAPI
from pydantic import BaseModel

from .core import DeterminabilityCore
from .types import Config, DeterminabilityResult


class CheckRequest(BaseModel):
    """Agent request payload."""
    session_id: str
    question: str
    configs: List[Dict[str, Any]]
    omega_field: str
    target_field: str
    evidence_fields: Optional[List[str]] = None

    class Config:
        json_schema_extra = {
            "example": {
                "session_id": "audit-001",
                "question": "Does the final output have a valid verification event?",
                "configs": [
                    {"config_id": "C1", "tool": "code", "has_verif": True, "verif_hash": "valid", "output": "correct", "target": 1},
                    {"config_id": "C2", "tool": "code", "has_verif": False, "verif_hash": "none", "output": "correct", "target": 0}
                ],
                "omega_field": "output",
                "target_field": "target",
                "evidence_fields": ["tool", "has_verif", "verif_hash"]
            }
        }


class DeterminabilityResponse(BaseModel):
    """Structured response to Agent."""
    session_id: str
    question: str
    determinability: str
    can_proceed: bool
    decision_table: Optional[Dict[str, Any]] = None
    counterexample: Optional[Dict[str, Any]] = None
    missing_evidence: Optional[List[str]] = None
    next_skill_suggestion: Optional[str] = None
    message: str


app = FastAPI(
    title="Determinability-Checker Skill",
    description="Causal Sufficiency Determinability Checker — Meta-Skill Gatekeeper based on JEP Paper",
    version="1.0.2"
)

core = DeterminabilityCore()


@app.post("/check", response_model=DeterminabilityResponse)
async def check(request: CheckRequest):
    configs = [Config(config_id=c["config_id"], data=c) for c in request.configs]
    omega = lambda C: C.data.get(request.omega_field)
    target = lambda C: C.data.get(request.target_field)

    evidences = None
    if request.evidence_fields:
        evidences = [
            (field, lambda C, f=field: C.data.get(f))
            for field in request.evidence_fields
        ]

    result = core.check(configs, omega, target, evidences)

    response = DeterminabilityResponse(
        session_id=request.session_id,
        question=request.question,
        determinability=result.result.value,
        can_proceed=(result.result == DeterminabilityResult.DETERMINED),
        message=result.message
    )

    if result.result == DeterminabilityResult.DETERMINED and result.decision_table:
        response.decision_table = result.decision_table.mapping

    if result.result == DeterminabilityResult.NOT_DETERMINED:
        if result.counterexample:
            response.counterexample = {
                "config1": result.counterexample.config1.config_id,
                "config2": result.counterexample.config2.config_id,
                "observation": result.counterexample.observation_value,
                "target1": result.counterexample.target1,
                "target2": result.counterexample.target2
            }

        if result.conflict_graph and evidences:
            minimal_cover = core.find_minimal_evidence_cover(result.conflict_graph, evidences)
            if minimal_cover:
                response.missing_evidence = minimal_cover
                response.next_skill_suggestion = f"Supplement the following evidence items: {', '.join(minimal_cover)}"
            else:
                response.next_skill_suggestion = "Current evidence family cannot cover all conflicts. Expand evidence sources or relax the target."
        else:
            response.next_skill_suggestion = "Observation function is too coarse. Refine observation granularity."

    return response


@app.get("/health")
async def health():
    return {"status": "ok", "skill": "determinability-checker", "version": "1.0.2"}


@app.get("/")
async def root():
    return {
        "name": "Determinability-Checker Skill",
        "version": "1.0.2",
        "description": "Causal Sufficiency Determinability Checker based on JEP Paper CheckDeterminability Algorithm",
        "endpoints": ["/check", "/health"]
    }


path: determinability-checker-skill/skill/core.py
content: """
Determinability Checker Core Engine
Implements CheckDeterminability (Theorem 10.1), Conflict Graph, Evidence Coverage (Theorem 8.2)
"""
from typing import List, Dict, Tuple, Set, Optional, Any, Callable
from collections import defaultdict

from .types import (
    Config, CheckResult, DeterminabilityResult, DecisionTable,
    CounterExample, ConflictEdge, EvidenceGap, OmegaFunc, TargetFunc, EvidenceFunc
)


class DeterminabilityCore:
    """
    Core engine for causal sufficiency determinability checking.
    Direct implementation of the paper algorithm.
    """

    @staticmethod
    def check(
        configs: List[Config],
        omega: OmegaFunc,
        target: TargetFunc,
        evidences: Optional[List[Tuple[str, EvidenceFunc]]] = None
    ) -> CheckResult:
        if not configs:
            return CheckResult(
                result=DeterminabilityResult.DETERMINED,
                decision_table=DecisionTable(mapping={}, observation_count=0, config_count=0),
                message="Empty configuration family is trivially determined."
            )

        groups: Dict[Any, List[Config]] = defaultdict(list)
        for C in configs:
            groups[omega(C)].append(C)

        decision_table = {}
        counterexample = None
        conflict_edges = []

        for w, group in groups.items():
            values = {target(C) for C in group}
            if len(values) > 1:
                vals = list(values)
                C1 = next(C for C in group if target(C) == vals[0])
                C2 = next(C for C in group if target(C) == vals[1])
                counterexample = CounterExample(
                    config1=C1, config2=C2,
                    observation_value=w,
                    target1=vals[0], target2=vals[1]
                )
                for i in range(len(group)):
                    for j in range(i + 1, len(group)):
                        if target(group[i]) != target(group[j]):
                            conflict_edges.append(ConflictEdge(
                                config1=group[i], config2=group[j],
                                observation_class=w
                            ))
            else:
                decision_table[w] = target(group[0])

        if counterexample:
            result = CheckResult(
                result=DeterminabilityResult.NOT_DETERMINED,
                counterexample=counterexample,
                conflict_graph=conflict_edges,
                message=(f"Non-determinability proven: configs {counterexample.config1.config_id} "
                         f"and {counterexample.config2.config_id} share observation {counterexample.observation_value} "
                         f"but differ on target ({counterexample.target1} vs {counterexample.target2}).")
            )
            if evidences:
                result.evidence_gaps = DeterminabilityCore._analyze_evidence_gaps(
                    conflict_edges, evidences
                )
            return result

        return CheckResult(
            result=DeterminabilityResult.DETERMINED,
            decision_table=DecisionTable(
                mapping=decision_table,
                observation_count=len(groups),
                config_count=len(configs)
            ),
            message=f"Target is zero-error determinable. Decision table covers {len(groups)} observation classes over {len(configs)} configurations."
        )

    @staticmethod
    def _analyze_evidence_gaps(
        conflict_edges: List[ConflictEdge],
        evidences: List[Tuple[str, EvidenceFunc]]
    ) -> List[EvidenceGap]:
        gaps = []
        for edge in conflict_edges:
            required = []
            for name, E in evidences:
                if E(edge.config1) != E(edge.config2):
                    required.append(name)
            gaps.append(EvidenceGap(
                conflict_edge=edge,
                required_evidence=required
            ))
        return gaps

    @staticmethod
    def find_minimal_evidence_cover(
        conflict_edges: List[ConflictEdge],
        evidences: List[Tuple[str, EvidenceFunc]]
    ) -> Optional[List[str]]:
        if not conflict_edges:
            return []

        uncovered = set(range(len(conflict_edges)))
        evidence_covers: Dict[str, Set[int]] = {}

        for name, E in evidences:
            covers = set()
            for idx, edge in enumerate(conflict_edges):
                if E(edge.config1) != E(edge.config2):
                    covers.add(idx)
            evidence_covers[name] = covers

        selected = []
        while uncovered:
            best_name = None
            best_cover = set()
            for name, covers in evidence_covers.items():
                current = covers & uncovered
                if len(current) > len(best_cover):
                    best_cover = current
                    best_name = name

            if not best_cover or best_name is None:
                return None

            selected.append(best_name)
            uncovered -= best_cover

        return selected

    @staticmethod
    def ambiguity_set_size(
        configs: List[Config],
        omega: OmegaFunc,
        target: TargetFunc
    ) -> Dict[Any, int]:
        groups: Dict[Any, List[Config]] = defaultdict(list)
        for C in configs:
            groups[omega(C)].append(C)
        return {
            w: len({target(C) for C in group})
            for w, group in groups.items()
        }


path: determinability-checker-skill/skill/types.py
content: """
Determinability Checker — Core Types
Based on: Target Determinability under Partial Causal Observation (Wang, 2026)
"""
from typing import Any, Callable, Dict, List, Tuple, Set, Optional, Union
from dataclasses import dataclass
from enum import Enum


class DeterminabilityResult(Enum):
    DETERMINED = "DETERMINED"
    NOT_DETERMINED = "NOT_DETERMINED"


@dataclass(frozen=True)
class Config:
    """A finite causal event configuration."""
    config_id: str
    data: Any

    def __hash__(self):
        return hash(self.config_id)


@dataclass
class DecisionTable:
    """Observation -> Target mapping when determined."""
    mapping: Dict[Any, Any]
    observation_count: int
    config_count: int


@dataclass
class CounterExample:
    """Certificate of non-determinability."""
    config1: Config
    config2: Config
    observation_value: Any
    target1: Any
    target2: Any


@dataclass
class ConflictEdge:
    """An edge in the conflict graph."""
    config1: Config
    config2: Config
    observation_class: Any


@dataclass
class EvidenceGap:
    """Missing evidence items needed to resolve a conflict."""
    conflict_edge: ConflictEdge
    required_evidence: List[str]


@dataclass
class CheckResult:
    """Complete check result."""
    result: DeterminabilityResult
    decision_table: Optional[DecisionTable] = None
    counterexample: Optional[CounterExample] = None
    conflict_graph: Optional[List[ConflictEdge]] = None
    evidence_gaps: Optional[List[EvidenceGap]] = None
    message: str = ""


OmegaFunc = Callable[[Config], Any]
TargetFunc = Callable[[Config], Any]
EvidenceFunc = Callable[[Config], Any]


path: determinability-checker-skill/skill/__init__.py
content: """
Determinability Checker Skill v1.0.2
Cognitive Emergence Lab
"""
__version__ = "1.0.2"


path: determinability-checker-skill/examples/audit_example.py
content: """
Paper Section 10.2 Reproduction: LLM Agent Tool-Call Audit
Run: python audit_example.py
"""
import sys
sys.path.insert(0, "..")

from skill.core import DeterminabilityCore
from skill.types import Config, DeterminabilityResult


def run_paper_example():
    """Reproduce Table 1 from the paper: 8-configuration audit case."""

    configs_data = [
        {"id": "C1", "output": "correct", "tool": "code", "verif_flag": 1, "verif_hash": "valid_hash",   "target": 1},
        {"id": "C2", "output": "correct", "tool": "code", "verif_flag": 0, "verif_hash": "none",         "target": 0},
        {"id": "C3", "output": "correct", "tool": "calc", "verif_flag": 0, "verif_hash": "none",         "target": 0},
        {"id": "C4", "output": "correct", "tool": "search", "verif_flag": 0, "verif_hash": "none",       "target": 0},
        {"id": "C5", "output": "error",   "tool": "code", "verif_flag": 1, "verif_hash": "failed_hash",  "target": 0},
        {"id": "C6", "output": "correct", "tool": "code", "verif_flag": 1, "verif_hash": "forged_hash",  "target": 0},
        {"id": "C7", "output": "error",   "tool": "search", "verif_flag": 0, "verif_hash": "none",        "target": 0},
        {"id": "C8", "output": "error",   "tool": "calc", "verif_flag": 0, "verif_hash": "none",         "target": 0},
    ]

    configs = [Config(config_id=d["id"], data=d) for d in configs_data]

    evidences = [
        ("tool_type", lambda C: C.data["tool"]),
        ("verif_flag", lambda C: C.data["verif_flag"]),
        ("verif_hash", lambda C: C.data["verif_hash"]),
    ]

    print("=" * 70)
    print("Paper Section 10.2 Reproduction: LLM Agent Tool-Call Audit")
    print("=" * 70)

    observation_levels = [
        ("Omega0: output only", lambda C: C.data["output"]),
        ("OmegaT: output + tool type", lambda C: (C.data["output"], C.data["tool"])),
        ("OmegaTV: output + tool + verification flag", lambda C: (C.data["output"], C.data["tool"], C.data["verif_flag"])),
        ("OmegaTVH: output + tool + flag + hash", lambda C: (C.data["output"], C.data["tool"], C.data["verif_flag"], C.data["verif_hash"])),
    ]

    for name, omega in observation_levels:
        print(f"\n[{name}]")
        result = DeterminabilityCore.check(configs, omega, lambda C: C.data["target"], evidences)

        if result.result == DeterminabilityResult.DETERMINED:
            print(f"  Result: DETERMINED [OK]")
            print(f"  Decision Table: {result.decision_table.mapping}")
        else:
            print(f"  Result: NOT_DETERMINED [FAIL]")
            ce = result.counterexample
            print(f"  Counterexample: {ce.config1.config_id} vs {ce.config2.config_id}")
            print(f"    Observation={ce.observation_value}, Target conflict={ce.target1} vs {ce.target2}")

            if result.evidence_gaps:
                print(f"  Conflict edges: {len(result.conflict_graph)}")
                minimal = DeterminabilityCore.find_minimal_evidence_cover(result.conflict_graph, evidences)
                if minimal:
                    print(f"  Minimal evidence cover: {minimal}")

    print("\n" + "=" * 70)
    print("Expected results:")
    print("  Omega0      -> NOT_DETERMINED (C1/C2 conflict under 'correct')")
    print("  OmegaT      -> NOT_DETERMINED (C1/C2 conflict under (correct, code))")
    print("  OmegaTV     -> NOT_DETERMINED (C1/C6 conflict under (correct, code, 1))")
    print("  OmegaTVH    -> DETERMINED (valid_hash uniquely maps to 1)")
    print("=" * 70)


if __name__ == "__main__":
    run_paper_example()


Security scan verdicts — ClawScan: clean | static analysis: clean | VirusTotal: clean | SkillSpector: clean (LOW)