Evidence Channels

The Six Evidence Channels

JuGeo defines six evidence channels. Each channel is a first-class object implementing the EvidenceChannel protocol. They are ordered by trust level, from weakest to strongest:

EvidenceBundle and EvidenceItem

The \(E\) field of a judgment is an EvidenceBundle — an ordered collection of EvidenceItem objects. Each item carries:

• channel — the ChannelKind enum value
• content — the raw evidence artifact (certificate bytes, test log, proof term, LLM transcript, …)
• trust — the trust level granted by this item
• timestamp — UTC time of evidence collection
• cost_record — resource usage (solver ms, token count, …)
• metadata — channel-specific auxiliary data (e.g., solver model, oracle confidence score)

from jugeo.evidence import EvidenceBundle, EvidenceItem, ChannelKind

# Inspect an evidence bundle
result = jugeo.verify(sum_positive, property="pure")
bundle = result.judgment.evidence

print(bundle.trust)           # TrustLevel.SOLVER
print(len(bundle.items))      # 1

item = bundle.items[0]
print(item.channel)           # ChannelKind.SOLVER
print(item.trust)             # TrustLevel.SOLVER
print(item.cost_record)       # CostRecord(solver_ms=143, tokens=0)
print(item.metadata['model']) # 'z3-4.12.2'

# Combine two bundles (e.g. solver + oracle)
j_solver = jugeo.verify(sum_positive, property="pure",
                        channels=["SOLVER"])
j_oracle = jugeo.verify(sum_positive, property="pure",
                        channels=["ORACLE"])

combined_bundle = j_solver.evidence | j_oracle.evidence
print(combined_bundle.trust)      # max of SOLVER, ORACLE = SOLVER
print(len(combined_bundle.items)) # 2

Channel Jurisdiction

Each channel has a jurisdiction — the set of formula kinds it can handle. Dispatching a formula to a channel outside its jurisdiction either raises a JurisdictionError or falls back to the next channel in the routing order.

Routing

When jugeo.verify() is called without an explicit channel list, the evidence router selects the appropriate channels automatically. The routing algorithm:

1. Classify the formula — determine which SMT fragment (if any) applies, and whether the formula is purely structural, relational, or requires higher-order reasoning.
2. Filter by jurisdiction — retain only channels whose jurisdiction covers the formula class.
3. Apply the routing strategy — the default is Smart routing (see Solver page). Alternatives include Cheapest, Fastest, MostTrusted, and RoundRobin.
4. Invoke in priority order — channels are called in decreasing priority; the first to return a non-NONE trust level wins, unless the all_channels flag is set.
5. Assemble the bundle — all successful channel results are joined into the final EvidenceBundle.

Federation

JuGeo supports federated evidence: evidence gathered by remote agents or on remote data can be incorporated into a local judgment via the federation protocol. A federated evidence item carries a cryptographic signature from the remote agent and is verified before being accepted.

from jugeo.evidence.channels import (
    ChannelFederation,
    ChannelRouter,
    EvidenceChannel,
    EvidenceRequest,
    EvidenceResponse,
)

request = EvidenceRequest(
    coordinate="mymod.sum_positive",
    proposition="function is pure",
    required_kind="proposal",
    fallback_channels=(EvidenceChannel.COPILOT, EvidenceChannel.HUMAN),
)

responses = [
    EvidenceResponse(
        request_id=request.request_id,
        channel=EvidenceChannel.COPILOT,
        evidence_item={"hint": "strengthen the precondition"},
        trust_level="proposal",
        provenance=("copilot",),
    ),
    EvidenceResponse(
        request_id=request.request_id,
        channel=EvidenceChannel.HUMAN,
        evidence_item={"review": "approved after audit"},
        trust_level="human_attested",
        provenance=("review",),
    ),
]

federation = ChannelFederation(ChannelRouter())
merged = federation.federate_request(request, responses)
print(merged.channel.value)  # composed
print(merged.trust_level)    # proposal (conservative meet)