Datasets:
File size: 4,031 Bytes
e1ced61 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 | """C2 dual-compile state machine + outcome (``docs/02`` §7).
The C2 compiler runs two *independent* models (a proposer and a verifier) over
the same candidate and reconciles their outputs through a deterministic gate.
The gate has five terminal states, evaluated in priority order — the first
observed failure wins:
* ``ALL_PASS`` — both models compiled a program; the two programs share a
canonical hash (§7.2), agree on the FULL-world answer, and agree on every
mutation in the §7.3 equivalence suite.
* ``PARSE_FAIL`` — at least one model's response did not yield a valid program
after the single allowed repair. That model's record is
``compile_status="invalid_response"``.
* ``CANONICAL_HASH_DIFF`` — both programs parsed, but their canonical program
hashes differ (``REJECT_PROGRAM_COMPILE_DISAGREE``, §7.2).
* ``FULL_ANSWER_DIFF`` — the canonical hashes match yet the executor computes
different ``(status, answer)`` on the untransformed world (a canonicalizer
invariant guard).
* ``MUTATION_DIFF`` — hashes and the full answer agree, but some §7.3 mutation
makes the two programs diverge (a canonicalizer invariant guard).
``FULL_ANSWER_DIFF`` / ``MUTATION_DIFF`` are defense-in-depth: with a correct
canonicalizer, matching hashes imply identical programs, so the suite is a guard
that *validates* the canonicalizer's equivalence claim rather than an independent
reject path. The mutation suite still runs and is recorded whenever the earlier
checks pass, per §7.3 ("mutation suite is essential").
A C2-compiled program is **never** used in primary evaluation (§7); the records
produced here feed training-time augmentation only.
"""
from __future__ import annotations
from dataclasses import dataclass, field
from typing import Any, Literal
C2State = Literal[
"ALL_PASS",
"PARSE_FAIL",
"CANONICAL_HASH_DIFF",
"FULL_ANSWER_DIFF",
"MUTATION_DIFF",
]
# Priority: a higher index short-circuits a lower one when both are observed.
_STATE_PRIORITY: dict[C2State, int] = {
"PARSE_FAIL": 0,
"CANONICAL_HASH_DIFF": 1,
"FULL_ANSWER_DIFF": 2,
"MUTATION_DIFF": 3,
"ALL_PASS": 4,
}
@dataclass(frozen=True)
class MutationEvidence:
"""One row of the §7.3 mutation equivalence suite.
``agree`` is ``True`` iff the proposer and verifier programs produced the
same ``(status, answer_canonical)`` on ``mutation.description``.
"""
leaf: str
kind: str # "SUBSTITUTE" | "REDACT"
description: str
proposer_status: str
proposer_answer: str | int | bool | None
verifier_status: str
verifier_answer: str | int | bool | None
agree: bool
@dataclass(frozen=True)
class C2Outcome:
"""The reconciled result of one C2 dual-compile.
``proposer_record`` / ``verifier_record`` are ``compiled_program``-schema
dicts (one per model). ``mutation_evidence`` is empty unless the suite ran
(parse + canonical hash both passed). ``state`` is the gate verdict.
"""
state: C2State
proposer_record: dict[str, Any]
verifier_record: dict[str, Any]
canonical_hash_proposer: str | None
canonical_hash_verifier: str | None
full_answer_proposer: tuple[str, str | int | bool | None] | None
full_answer_verifier: tuple[str, str | int | bool | None] | None
mutation_evidence: tuple[MutationEvidence, ...] = field(default_factory=tuple)
reason: str = ""
@property
def accepted(self) -> bool:
"""``True`` iff the dual-compile passed every gate (§7 acceptance)."""
return self.state == "ALL_PASS"
def worst(*states: C2State) -> C2State:
"""Return the highest-priority (most-severe) observed state.
An empty input is ``ALL_PASS`` (nothing failed). Used when several checks run
unconditionally and the most-severe failure must be reported.
"""
if not states:
return "ALL_PASS"
return min(states, key=lambda s: _STATE_PRIORITY[s])
__all__ = ["C2Outcome", "C2State", "MutationEvidence", "worst"]
|