Datasets:
File size: 10,053 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 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | """The C2 dual-compile orchestrator (``docs/02`` §7).
:class:`C2Compiler` runs the proposer (Qwen3.5-9B) and verifier (Gemma-4-12B-it)
*independently* over one :class:`C2Candidate` and reconciles their outputs through
the §7 gate:
1. build the §7.1 request (shared, hides intervention / sibling output /
transformed image);
2. each model compiles → parse to a typed program with one allowed repair;
3. §7.2 canonical-program exact-match (``REJECT_PROGRAM_COMPILE_DISAGREE``);
4. full-world answer agreement via the deterministic P3 executor;
5. §7.3 mutation equivalence suite (``≥8`` alternatives per dependency leaf).
The first observed failure fixes the :class:`C2State`; only ``ALL_PASS`` is
accepted (§7 acceptance). A C2 program is never used in primary evaluation —
the records feed training-time augmentation only. Model calls go through the
injected :class:`ModelClient`; nothing here fakes a response.
"""
from __future__ import annotations
from dataclasses import dataclass
from ..dsl.ast import Dsl, Program
from ..executors import get_executor
from ..executors.base import ExecutionResult
from ..sources.base import World
from .client import ModelClient
from .mutations import deterministic_mutations
from .parse import ParsedProgram, parse_program_response
from .record import ParseStatus, build_compiled_program
from .request import C2Candidate, CompileRequest, build_compile_request
from .state import C2Outcome, MutationEvidence
# Parse-status literals matched to ``compiled_program.schema.json``.
_FIRST: ParseStatus = "valid_first_response"
_REPAIR: ParseStatus = "valid_after_one_repair"
_INVALID: ParseStatus = "invalid"
@dataclass(frozen=True)
class C2Compiler:
"""Inject the two independent model clients and compile candidates."""
proposer: ModelClient
verifier: ModelClient
def compile(self, candidate: C2Candidate, *, seed: int = 0) -> C2Outcome:
request = build_compile_request(candidate)
world = candidate.world
prop_parsed, prop_response_sha, prop_status = self._compile_one(
self.proposer, request, candidate
)
ver_parsed, ver_response_sha, ver_status = self._compile_one(
self.verifier, request, candidate
)
proposer_record = build_compiled_program(
base_id=candidate.base_id,
question_sha256=candidate.question_sha256,
choices_sha256=candidate.choices_sha256,
compiler_role="program_proposer",
model_repo_id=self.proposer.model_repo_id,
model_revision=self.proposer.model_revision,
request_sha256=request.request_sha256,
response_sha256=prop_response_sha,
parse_status=prop_status,
parsed=prop_parsed if prop_parsed.ok else None,
)
verifier_record = build_compiled_program(
base_id=candidate.base_id,
question_sha256=candidate.question_sha256,
choices_sha256=candidate.choices_sha256,
compiler_role="independent_program_verifier",
model_repo_id=self.verifier.model_repo_id,
model_revision=self.verifier.model_revision,
request_sha256=request.request_sha256,
response_sha256=ver_response_sha,
parse_status=ver_status,
parsed=ver_parsed if ver_parsed.ok else None,
)
# Gate 1: both models must produce a valid program.
if not (prop_parsed.ok and ver_parsed.ok):
return C2Outcome(
state="PARSE_FAIL",
proposer_record=proposer_record,
verifier_record=verifier_record,
canonical_hash_proposer=prop_parsed.canonical_program_sha256,
canonical_hash_verifier=ver_parsed.canonical_program_sha256,
full_answer_proposer=None,
full_answer_verifier=None,
reason="one or both models failed to compile a valid program",
)
# Gate 2: §7.2 canonical-program exact-match.
hash_p = prop_parsed.canonical_program_sha256
hash_v = ver_parsed.canonical_program_sha256
if hash_p != hash_v:
return C2Outcome(
state="CANONICAL_HASH_DIFF",
proposer_record=proposer_record,
verifier_record=verifier_record,
canonical_hash_proposer=hash_p,
canonical_hash_verifier=hash_v,
full_answer_proposer=None,
full_answer_verifier=None,
reason="REJECT_PROGRAM_COMPILE_DISAGREE: canonical hashes differ",
)
# Gate 3: full-world answer agreement (canonicalizer-invariant guard).
assert prop_parsed.program is not None and ver_parsed.program is not None
full_p, full_v, full_agree = check_full_answer(
prop_parsed.program, ver_parsed.program, world, dsl=candidate.dsl
)
if not full_agree:
return C2Outcome(
state="FULL_ANSWER_DIFF",
proposer_record=proposer_record,
verifier_record=verifier_record,
canonical_hash_proposer=hash_p,
canonical_hash_verifier=hash_v,
full_answer_proposer=full_p,
full_answer_verifier=full_v,
reason="programs disagree on the FULL-world answer",
)
# Gate 4: §7.3 mutation equivalence suite.
evidence, diverged = run_mutation_suite(
prop_parsed.program, ver_parsed.program, world, dsl=candidate.dsl, seed=seed
)
if diverged:
return C2Outcome(
state="MUTATION_DIFF",
proposer_record=proposer_record,
verifier_record=verifier_record,
canonical_hash_proposer=hash_p,
canonical_hash_verifier=hash_v,
full_answer_proposer=full_p,
full_answer_verifier=full_v,
mutation_evidence=tuple(evidence),
reason="programs diverge on a §7.3 mutation",
)
return C2Outcome(
state="ALL_PASS",
proposer_record=proposer_record,
verifier_record=verifier_record,
canonical_hash_proposer=hash_p,
canonical_hash_verifier=hash_v,
full_answer_proposer=full_p,
full_answer_verifier=full_v,
mutation_evidence=tuple(evidence),
reason="dual-compile accepted (canonical match + full + mutations)",
)
# --- one model's compile-with-one-repair -------------------------------
def _compile_one(
self, client: ModelClient, request: CompileRequest, candidate: C2Candidate
) -> tuple[ParsedProgram, str, ParseStatus]:
response = client.compile(request)
parsed = parse_program_response(
response.text,
dsl=candidate.dsl,
world=candidate.world,
base_id=candidate.base_id,
question_sha256=candidate.question_sha256,
choices_sha256=candidate.choices_sha256,
)
if parsed.ok:
return parsed, response.response_sha256, _FIRST
# The single allowed repair (§7): re-ask with the first-response errors.
repaired = client.repair(request, list(parsed.errors))
again = parse_program_response(
repaired.text,
dsl=candidate.dsl,
world=candidate.world,
base_id=candidate.base_id,
question_sha256=candidate.question_sha256,
choices_sha256=candidate.choices_sha256,
)
if again.ok:
return again, repaired.response_sha256, _REPAIR
return parsed, response.response_sha256, _INVALID
def _answer_key(result: ExecutionResult) -> tuple[str, str | int | bool | None]:
"""The comparison key for answer agreement (status + canonical answer)."""
return (result.status, result.answer_canonical)
def check_full_answer(
proposer: Program, verifier: Program, world: World, *, dsl: Dsl
) -> tuple[tuple[str, str | int | bool | None], tuple[str, str | int | bool | None], bool]:
"""Execute both programs on the FULL world; return ``(key_p, key_v, agree)``.
Extracted so the gate-3 branch is unit-testable with crafted programs (the
pipeline otherwise short-circuits at the §7.2 canonical-hash diff).
"""
executor = get_executor(dsl)
exec_p = executor.execute(proposer, world=world)
exec_v = executor.execute(verifier, world=world)
key_p, key_v = _answer_key(exec_p), _answer_key(exec_v)
return key_p, key_v, key_p == key_v
def run_mutation_suite(
proposer: Program,
verifier: Program,
world: World,
*,
dsl: Dsl,
seed: int,
) -> tuple[list[MutationEvidence], bool]:
"""Run the §7.3 mutation suite; return ``(evidence, diverged)``.
Extracted so the gate-4 branch is unit-testable with crafted programs.
"""
executor = get_executor(dsl)
exec_p = executor.execute(proposer, world=world)
leaves = exec_p.dependency_node_ids
mutations = deterministic_mutations(world, leaves, dsl=dsl, seed=seed)
evidence: list[MutationEvidence] = []
diverged = False
for mut in mutations:
e_p = executor.execute(proposer, world=mut.world)
e_v = executor.execute(verifier, world=mut.world)
kp, kv = _answer_key(e_p), _answer_key(e_v)
agree = kp == kv
evidence.append(
MutationEvidence(
leaf=mut.leaf,
kind=mut.kind,
description=mut.description,
proposer_status=e_p.status,
proposer_answer=e_p.answer_canonical,
verifier_status=e_v.status,
verifier_answer=e_v.answer_canonical,
agree=agree,
)
)
if not agree:
diverged = True
return evidence, diverged
__all__ = ["C2Compiler", "check_full_answer", "run_mutation_suite"]
|